encode()

std::string GSE2::waveform::CM6::encode

(

const intT &

invalue

)

CM6 subformat encoding function.

The function encodes the integer value in CM6 subformat. It returns the character sequence representing the numerical value. The second differences must have already been supplied to the data stream. The value is already a second difference value.

Author

Thomas Forbriger, Stefan Stange and others (see comments in the source code)

Parameters

value

integer value to be encoded in CM6 subformat

Returns

character string with encoded integer value

See also

GSE2::waveform::TDAT2writeCM6

Definition at line 77 of file gsexx_cm6.cc.

Referenced by GSE2::waveform::TDAT2writeCM6::convert().

{
  // string variable to store return value
  std::string retval;
 
// The original version of the core of this function was coded by Stefan
// Stange. The code (compress_6b) can be found in gse_functions.c in his
// library. Here is the original comment by Stefan Stange:
/*********************************************************************
  Function: compress_6b
    This routine computes the 6Byte encoding of integer data according
    GSE2.0 based on cmprs6.f in CODECO by Urs Kradolfer. Again, here we
    can cope with consecutive chunks of a data series.
    Input is the data series (integer) and the # of samples. The character
    representation of the data is successively stored to the dynamic
    character buffer written by Andreas Greve.
    Attention: Clipping is at 2**27 - 1 although it looks like 2**28 -1
    in the FORTRAN-Code.

    St. Stange, 28.4.1998
*********************************************************************/

  // copy of value to be manipulated
  intT value=invalue;
  // this defines the value to character mapping
  char achar[] = 
       " +-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  
  // some powers of 2
  //                 2**5 2**10 2**15  2**20    2**25     2**27      
  long expo_2[] = { 0, 32, 1024, 32768, 1048576, 33554432, 134217728 };

  // some powers of 2 minus 1
  //            -1 +      2**5  2**10  2**15   2**20     2**25     
  long expo_2m1_o[] = { 01, 037, 01777, 077777, 03777777, 0177777777 };

  // internal values
  int nflag;
  int mflag = 32;
  long jc;
  int case_expo;

  nflag = 1;
  // convert sign
  if (value < 0 )
  { nflag += 16; value = -value; }

  // clip at 2**27 -1 
  // value = (value >= expo_2[6]) ? expo_2[6] - 1 : value; 
  // the original code clipped at 2**27 -1
  // we consider a number that large to be illegal
  if (value >= expo_2[6]) 
  {
    std::cerr << "ERROR (CM6::encode): "
      << "sample value exceeds largest value which can be handled\n"
          << "Error is triggered by absolute value being ";
    std::cerr.setf(std::ios_base::hex,std::ios_base::basefield);
    std::cerr << "0x0" << value << ">=" << "0x0" << expo_2[6] << std::endl;
    std::cerr << "The input value passed to the encoder is "
      << "0x0" << invalue << std::endl;
    throw Terror("ERROR (CM6::encode): illegal value");
  }

  // compute the exponent base 2
  std::frexp (double(value), &case_expo); 
  // and reduce by integer division
  case_expo = case_expo/5;      

  // check value
  if (case_expo > 5 || case_expo < 0) 
  {
    std::cerr << "ERROR (CM6::encode): exponent is " 
                                       << case_expo << std::endl;
    std::cerr << "ERROR (CM6::encode): sample value is is " 
                                       << invalue << std::endl;
    throw Terror("ERROR (CM6::encode): illegal exponent");
  }

  for ( ; case_expo > 0; case_expo--)
  {                             
    // create one character per turn
    jc = value/expo_2[case_expo] + nflag + mflag;
    /*if (jc > 64 || jc < 1) return jc;*/
    retval+=achar[jc];
    value = value & expo_2m1_o[case_expo];
    nflag = 1;
  }

  // one character to go
  jc = value + nflag;
  retval+=achar[jc];

  return(retval);
}

Here is the caller graph for this function: