ga_bitstring.c

来自「http://gaul.sourceforge.net/ 这里大部分人讨论的」· C语言 代码 · 共 690 行 · 第 1/2 页

		bitstring.
  parameters:
  return:
  last updated: 08 Jan 2003
 **********************************************************************/

static void gray_to_binary( byte *gray_bstr, int n, byte *int_bstr, int length )
  {
  boolean	bit;
  int		i;

  bit = ga_bit_get( gray_bstr, n );
  if (bit)
    ga_bit_set( int_bstr, 0 );
  else
    ga_bit_clear( int_bstr, 0 );

  for ( i=1; i<length; i++ )
    {
    if (bit)
      bit = !ga_bit_get( gray_bstr, n+i );
    else
      bit = ga_bit_get( gray_bstr, n+i );

    if (bit)
      ga_bit_set( int_bstr, i );
    else
      ga_bit_clear( int_bstr, i );
    }  

  return;
  }


/**********************************************************************
  binary_to_gray()
  synopsis:	Convert a binary-encoded bitstring into a gray-encoded
		bitstring.
  parameters:
  return:
  last updated: 08 Jan 2003
 **********************************************************************/

static void binary_to_gray( byte *gray_bstr, int n, byte *int_bstr, int length )
  {
  boolean	bit;
  int		i;

  bit = ga_bit_get( int_bstr, 0 );
  if (bit)
    ga_bit_set( gray_bstr, n );
  else
    ga_bit_clear( gray_bstr, n );

  for ( i=1; i < length; i++ )
    {

    if (bit)
      {
      bit = ga_bit_get( int_bstr, i );
      if (bit)
        ga_bit_clear( gray_bstr, n+i );
      else
        ga_bit_set( gray_bstr, n+i );
      }
    else
      {
      bit = ga_bit_get( int_bstr, i );
      if (bit)
        ga_bit_set( gray_bstr, n+i );
      else
        ga_bit_clear( gray_bstr, n+i );
      }
    }

  return;
  }


/**********************************************************************
  ga_bit_decode_gray_int()
  synopsis:	Convert a gray-encoded bitstring into a signed int
		starting at a given offset. 
  parameters:
  return:
  last updated: 08 Jan 2003
 **********************************************************************/

int ga_bit_decode_gray_int( byte *bstr, int n, int length )
  {
  byte		*int_bstr;
  int		val;

  if ( !(int_bstr = (byte *) s_malloc( ga_bit_sizeof( length ) )) )
    die("Unable to allocate bitstring.");

  gray_to_binary( bstr, n, int_bstr, length );

  val = ga_bit_decode_binary_int( int_bstr, 0, length );

  s_free(int_bstr);

  return val;
  }


/**********************************************************************
  ga_bit_decode_gray_uint()
  synopsis:	Convert a gray-encoded bitstring into an unsigned int
		starting at a given offset. 
  parameters:
  return:
  last updated: 08 Jan 2003
 **********************************************************************/

unsigned int ga_bit_decode_gray_uint( byte *bstr, int n, int length )
  {
  byte		*int_bstr;
  unsigned int	val;

  if ( !(int_bstr = (byte *) s_malloc( ga_bit_sizeof( length ) )) )
    die("Unable to allocate bitstring.");

  gray_to_binary( bstr, n, int_bstr, length );

  val = ga_bit_decode_binary_uint( int_bstr, 0, length );

  s_free(int_bstr);

  return val;
  }


/**********************************************************************
  ga_bit_encode_gray_uint()
  synopsis:	Convert an unsigned int into a gray-encoded bitstring
		starting at a given offset. 
  parameters:
  return:
  last updated: 08 Jan 2003
 **********************************************************************/

void ga_bit_encode_gray_uint( byte *bstr, int n, int length, unsigned int value )
  {
  byte	*int_bstr;

  if ( !(int_bstr = (byte *) s_malloc( ga_bit_sizeof( length ) )) )
    die("Unable to allocate bitstring.");

  ga_bit_encode_binary_uint( int_bstr, 0, length, value );
  binary_to_gray( bstr, n, int_bstr, length );

  s_free(int_bstr);

  return;
  }


/**********************************************************************
  ga_bit_encode_gray_int()
  synopsis:	Convert an unsigned int into a gray-encoded bitstring
		starting at a given offset. 
  parameters:
  return:
  last updated: 08 Jan 2003
 **********************************************************************/

void ga_bit_encode_gray_int( byte *bstr, int n, int length, int value )
  {
  byte	*int_bstr;

  if ( !(int_bstr = (byte *) s_malloc( ga_bit_sizeof( length ) )) )
    die("Unable to allocate bitstring.");

  ga_bit_encode_binary_int( int_bstr, 0, length, value );
  binary_to_gray( bstr, n, int_bstr, length );

  s_free(int_bstr);

  return;
  }


/**********************************************************************
  ga_bit_decode_binary_real()
  synopsis:	Convert a binary-encoded bitstring at a given offset
		into a real. 
  parameters:
  return:
  last updated: 08 Jan 2003
 **********************************************************************/

double ga_bit_decode_binary_real( byte *bstr, int n, int mantissa, int exponent )
  {
  double	value;
  int		int_mantissa, int_exponent;

  int_mantissa = ga_bit_decode_binary_int( bstr, n, mantissa );
  int_exponent = ga_bit_decode_binary_int( bstr, n+mantissa, exponent );

  value = ((double)int_mantissa) / ((double)(1<<(mantissa-1)))
          * pow( 2.0, (double) int_exponent );

  return value;        
  }


/**********************************************************************
  ga_bit_encode_binary_real()
  synopsis:	Convert a real into a binary-encoded bitstring at a
                given offset. 
  parameters:
  return:
  last updated: 08 Jan 2003
 **********************************************************************/

void ga_bit_encode_binary_real( byte *bstr, int n, int mantissa, int exponent, double value )
  {
  int int_mantissa, int_exponent;

  int_mantissa = (int) floor(frexp( value, &int_exponent ) * (double)(1<<(mantissa-1)));
  ga_bit_encode_binary_int( bstr, n, mantissa, int_mantissa );
  ga_bit_encode_binary_int( bstr, n+mantissa, exponent, int_exponent );

  return;
  }


/**********************************************************************
  ga_bit_decode_gray_real()
  synopsis:	Convert a Gray-encoded bitstring at a given offset
		into a real. 
  parameters:
  return:
  last updated: 25 Jul 2003
 **********************************************************************/

double ga_bit_decode_gray_real( byte *bstr, int n, int mantissa, int exponent )
  {
  double	value;
  int		int_mantissa, int_exponent;

  int_mantissa = ga_bit_decode_gray_int( bstr, n, mantissa );
  int_exponent = ga_bit_decode_gray_int( bstr, n+mantissa, exponent );

  value = pow( 2.0, (double) int_exponent ) *
          ((double)int_mantissa) / ((double)(1<<(mantissa-1)));

  return value;        
  }


/**********************************************************************
  ga_bit_encode_gray_real()
  synopsis:	Convert a real into a Gray-encoded bitstring at a
                given offset. 
  parameters:
  return:
  last updated: 25 Jul 2003
 **********************************************************************/

void ga_bit_encode_gray_real( byte *bstr, int n, int mantissa, int exponent, double value )
  {
  int int_mantissa, int_exponent;

  int_mantissa = (int) floor(frexp( value, &int_exponent ) * (double)(1<<(mantissa-1)));

  ga_bit_encode_gray_int( bstr, n, mantissa, int_mantissa );
  ga_bit_encode_gray_int( bstr, n+mantissa, exponent, int_exponent );

  return;
  }


/**********************************************************************
  ga_bit_test()
  synopsis:	Test bitstring conversion routines.
  parameters:	none
  return:	Always TRUE, currently.
  last updated: 06 Oct 2004
 **********************************************************************/

boolean ga_bit_test( void )
  {
  int		i;			/* Loop variable. */
  double	origval, newval;	/* Value before and after encoding+decoding. */
  int		origint, newint;	/* Value before and after encoding+decoding. */
  byte		*bstr;

  if ( !(bstr = (byte *) s_malloc( ga_bit_sizeof( 128 ) )) )
    die("Unable to allocate bitstring.");

  printf("Binary encoding of integers:\n");

  for (i=0; i<10; i++)
    {
    origint = 23*i-30;
    ga_bit_encode_binary_int( bstr, 0, 64, origint );
    newint = ga_bit_decode_binary_int( bstr, 0, 64 );
    printf("Orig val = %d new val = %d %s\n",
           origint, newint, origint==newint?"PASSED":"FAILED");
    }

  printf("Binary encoding of reals:\n");

  for (i=0; i<10; i++)
    {
    origval = -0.3+0.16*i;
    ga_bit_encode_binary_real( bstr, 0, 64, 64, origval );
    newval = ga_bit_decode_binary_real( bstr, 0, 64, 64 );
    printf("Orig val = %f new val = %f %s\n",
           origval, newval,
           (origval>newval-TINY&&origval<newval+TINY)?"PASSED":"FAILED");
    }

  printf("Gray encoding of integers:\n");

  for (i=0; i<10; i++)
    {
    origint = 23*i-30;
    ga_bit_encode_gray_int( bstr, 0, 64, origint );
    newint = ga_bit_decode_gray_int( bstr, 0, 64 );
    printf("Orig val = %d new val = %d %s\n",
           origint, newint, origint==newint?"PASSED":"FAILED");
    }

  printf("Gray encoding of reals:\n");

  for (i=0; i<10; i++)
    {
    origval = -0.3+0.16*i;
    ga_bit_encode_gray_real( bstr, 0, 64, 64, origval );
    newval = ga_bit_decode_gray_real( bstr, 0, 64, 64 );
    printf("Orig val = %f new val = %f %s\n",
           origval, newval,
           (origval>newval-TINY&&origval<newval+TINY)?"PASSED":"FAILED");
    }

  s_free(bstr);

  return TRUE;
  }