RTFloat.h

/*
 * Licensed Materials - Property of HCL and/or IBM
 * Copyright HCL Technologies Ltd. 2016, 2021. All Rights Reserved.
 * Copyright IBM Corporation 1999, 2016. All Rights Reserved.
 *
 * U.S. Government Users Restricted Rights -  Use, duplication or 
 * disclosure restricted by GSA ADP Schedule.
 */
 
#ifndef __RTFloat_h__
#define __RTFloat_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTConfig_h__
#include <RTConfig.h>
#endif
 
#if RTUseFloatingPoint
 
struct RTFloat
{
    enum
    {
    mantissa_words  = 12
      , bits_per_word   = 8
      , word_scale      = 1 << bits_per_word
      , word_mask       = word_scale - 1
 
      , mantissa_bits   = mantissa_words * bits_per_word
      , mantissa_digits = ( 10 * mantissa_bits + 32 ) / 33
    };
 
    // We use word to store the digits of mantissas in a base(word_scale)
    // representation. Those digits lie in the range [ 0, word_mask ].
    typedef unsigned char word;
 
    // value is represented by:
    // mantissa * ( 10 ** exp10 ) * (  2 ** exp_2 )
    // mantissa[ 0 ] is the most significant word.
    word mantissa[ mantissa_words ];
    int  exp10;
    int  exp_2;
 
    // These are useful for binary to decimal conversions.
 
    // Assigned value must be positive.
    void assign( double );
 
    // Arrange that exp_2 is zero and adjust exp10
    // so that mantissa is not a multiple of ten.
    void normalize10( void );
 
    // Return ( mantissa % 10 )
    int  mod10( void ) const;
 
    // mantissa /= 10; returns zero if result is zero
    int  div10( void );
 
    // These are useful for decimal to binary conversions.
 
    // Set everything to zero.
    void clear( void );
 
    // mantissa = 10 * mantissa + digit
    void mul10( int digit );
 
    // Arrange that exp_10 is zero and adjust exp_2
    // so that mantissa is not a multiple of two.
    void normalize2( void );
 
    // mantissa = 10 * mantissa + digit
    double value( void );
 
    // Shared functionality.
 
    // Compute 2 ** exponent.
    static double pow2( unsigned exponent );
 
    // multiply
    void multiply( const RTFloat & );
 
    // We use dword to compute the sum of a column in the multiplication
    // algorithm. It must be capable of representing, in the worst case,
    // the sum of the carry from the previous column and mantissa_words
    // products of operands no larger than word_mask. That sum is bounded
    // by mantissa_words * word_mask * word_scale.
    typedef unsigned long  dword;
};
 
#endif // RTUseFloatingPoint
 
#endif // __RTFloat_h__