DecimalSystem Class Reference

#include <ntextd.h>

Inheritance diagram for DecimalSystem:

Collaboration diagram for DecimalSystem:

Public Member Functions
	DecimalSystem ()
	DecimalSystem (unsigned int digits)
	DecimalSystem (unsigned int digits, const char fractionPoint)
	~DecimalSystem ()
virtual const char *	GetText (Number *number)
Public Member Functions inherited from PositionalNumeralSystem
	PositionalNumeralSystem (unsigned int base, unsigned int digits, const char fractionPoint)
	~PositionalNumeralSystem ()
virtual const char *	GetName ()
virtual const char *	GetPrefix ()
virtual unsigned int	GetDigits ()
virtual void	SetDigits (unsigned int digits)
virtual const char	GetFractionPoint ()
virtual void	SetFractionPoint (const char fractionPoint)
virtual Number *	Parse (const char *text, unsigned int *length, char **end)
Public Member Functions inherited from NumeralSystem
	NumeralSystem ()
virtual	~NumeralSystem ()
virtual Number *	Parse (const char *text)

Private Member Functions
const char *	GetText (double number) const

Additional Inherited Members
Protected Member Functions inherited from PositionalNumeralSystem
const char *	GetSpecialCase (Number *number)
void	IntegerToBuffer (double value, unsigned int digits, int *outdigits) const
Protected Attributes inherited from PositionalNumeralSystem
double	baseDouble
unsigned int	digits
char	fractionPoint
Protected Attributes inherited from NumeralSystem
CharBuffer *	buf

Detailed Description

Definition at line 35 of file ntextd.h.

Constructor & Destructor Documentation

DecimalSystem() [1/3]

DecimalSystem::DecimalSystem

(

)

Definition at line 62 of file ntextd.cpp.

References PositionalNumeralSystem::PositionalNumeralSystem().

                             : PositionalNumeralSystem(10, 5, '\0')
{
}

Here is the call graph for this function:

DecimalSystem() [2/3]

DecimalSystem::DecimalSystem

(

unsigned int

digits

)

Definition at line 66 of file ntextd.cpp.

References PositionalNumeralSystem::PositionalNumeralSystem().

Referenced by PlotStatement::Execute(), MemoryStatement::Execute(), DigitsStatement::Execute(), PreferencesBase::GetDescription(), PositionalNumeralSystem::GetName(), Parser::ParseDigistStatement(), and Parser::ParseNumeralStatement().

                                                :
    PositionalNumeralSystem(10, digits, '\0')
{
}

Here is the call graph for this function:

Here is the caller graph for this function:

DecimalSystem() [3/3]

DecimalSystem::DecimalSystem	(	unsigned int	digits,
		const char	fractionPoint
	)

Definition at line 71 of file ntextd.cpp.

References PositionalNumeralSystem::PositionalNumeralSystem().

Referenced by Program::NewPositionalInput(), Program::NewPositionalOutput(), and Program::Program().

                                                                          :
    PositionalNumeralSystem(10, digits, fractionPoint)
{
}

Here is the call graph for this function:

Here is the caller graph for this function:

~DecimalSystem()

DecimalSystem::~DecimalSystem

(

)

Definition at line 76 of file ntextd.cpp.

{
}

Member Function Documentation

GetText() [1/2]

const char * DecimalSystem::GetText ( Number *  number )

virtual

Reimplemented from PositionalNumeralSystem.

Definition at line 80 of file ntextd.cpp.

References CharBuffer::Append(), NumeralSystem::buf, cimag(), creal(), CharBuffer::Empty(), ComplexNumber::GetComplexValue(), Number::GetRealValue(), PositionalNumeralSystem::GetSpecialCase(), CharBuffer::GetString(), GetText(), nsysreal, and Number::system.

{
    const char *sc = GetSpecialCase(number);
    if (sc != nullptr)
    {
        return sc;
    }

    if (number->system == nsysreal)
    {
        buf->Empty();
        return GetText(number->GetRealValue());
    }

    complex w = ((ComplexNumber *)number)->GetComplexValue();
    double a = creal(w);
    double b = cimag(w);

    buf->Empty();
    if (a != 0.0)
    {
        GetText(a);
    }

    if (a != 0.0 && b > 0.0)
    {
        buf->Append('+');
    }

    if (b != 0.0)
    {
        GetText(b);
        buf->Append('i');
    }

    return buf->GetString();
}

Here is the call graph for this function:

GetText() [2/2]

const char * DecimalSystem::GetText ( double  number ) const

private

Definition at line 118 of file ntextd.cpp.

References CharBuffer::Append(), NumeralSystem::buf, CharBuffer::Contains(), CutoffMode_FractionLength, CutoffMode_TotalLength, PositionalNumeralSystem::digits, Dragon4(), CharBuffer::EnsureGrowth(), fabs(), FloatUnion64::floatingPoint, PositionalNumeralSystem::fractionPoint, FloatUnion64::GetExponent(), FloatUnion64::GetMantissa(), CharBuffer::GetString(), PositionalNumeralSystem::IntegerToBuffer(), FloatUnion64::IsNegative(), log10(), log2i(), MemCopy(), CharBuffer::RemoveTrailing(), and trunc().

Referenced by GetText().

{
    int32_t printExponent = 0;
    double dexponent = log10(fabs(number));
    int32_t precision = digits - (int32_t)trunc(dexponent) - 1;
    int32_t lim = 15;
    bool sci = (dexponent > 9.0 || dexponent < -8.0);    
    if (sci)
    {
        precision = digits;
    }
    else if (dexponent < 0.0)
    {
        precision++;
        lim--;
    }

    if (precision > lim)
    {
        precision = lim;
    }
    
    static const int size = 64;
    char *out = new char[size];
    char *pOutBuffer = out;
    uint32_t bufferSize = size;

    FloatUnion64 floatUnion;
    floatUnion.floatingPoint = number;
    uint32_t floatExponent = floatUnion.GetExponent();
    uint64_t floatMantissa = floatUnion.GetMantissa();

    if (floatUnion.IsNegative())
    {
        pOutBuffer[0] = '-';
        ++pOutBuffer;
        --bufferSize;
    }

    uint64_t mantissa;
    int32_t exponent;
    uint32_t mantissaHighBitIdx;
    bool hasUnequalMargins;

    if (floatExponent != 0)
    {
        // normal
        mantissa = (1ull << 52) | floatMantissa;
        exponent = floatExponent - 1023 - 52;
        mantissaHighBitIdx = 52;
        hasUnequalMargins = (floatExponent != 1) && (floatMantissa == 0);
    }
    else
    {
        // subnormal
        mantissa = floatMantissa;
        exponent = 1 - 1023 - 52;
        mantissaHighBitIdx = log2i(mantissa);
        hasUnequalMargins = false;
    }

    if (!sci)
    {
        int32_t printExponent;
        uint32_t numPrintDigits;
        uint32_t maxPrintLen = bufferSize - 1;
        numPrintDigits = Dragon4(mantissa,
                                 exponent,
                                 mantissaHighBitIdx,
                                 hasUnequalMargins,
                                 CutoffMode_FractionLength,
                                 precision,
                                 pOutBuffer,
                                 maxPrintLen,
                                 &printExponent);

        // track the number of digits past the decimal point that have been printed
        uint32_t numFractionDigits = 0;

        // if output has a whole number
        if (printExponent >= 0)
        {
            // leave the whole number at the start of the buffer
            uint32_t numWholeDigits = printExponent + 1;
            if (numPrintDigits < numWholeDigits)
            {
                // don't overflow the buffer
                if (numWholeDigits > maxPrintLen)
                    numWholeDigits = maxPrintLen;

                // add trailing zeros up to the decimal point
                for (; numPrintDigits < numWholeDigits; ++numPrintDigits)
                    pOutBuffer[numPrintDigits] = '0';
            }
            // insert the decimal point prior to the fraction
            else if (numPrintDigits > (uint32_t)numWholeDigits)
            {
                numFractionDigits = numPrintDigits - numWholeDigits;
                uint32_t maxFractionDigits = maxPrintLen - numWholeDigits - 1;
                if (numFractionDigits > maxFractionDigits)
                    numFractionDigits = maxFractionDigits;

                MemCopy(pOutBuffer + numWholeDigits + 1, pOutBuffer + numWholeDigits, numFractionDigits);
                pOutBuffer[numWholeDigits] = fractionPoint;
                numPrintDigits = numWholeDigits + 1 + numFractionDigits;
            }
        }
        else
        {
            // shift out the fraction to make room for the leading zeros
            if (maxPrintLen > 2)
            {
                uint32_t numFractionZeros = (uint32_t)-printExponent - 1;
                uint32_t maxFractionZeros = maxPrintLen - 2;
                if (numFractionZeros > maxFractionZeros)
                    numFractionZeros = maxFractionZeros;

                uint32_t digitsStartIdx = 2 + numFractionZeros;

                // shift the significant digits right such that there is room for leading zeros
                numFractionDigits = numPrintDigits;
                uint32_t maxFractionDigits = maxPrintLen - digitsStartIdx;
                if (numFractionDigits > maxFractionDigits)
                    numFractionDigits = maxFractionDigits;

                MemCopy(pOutBuffer + digitsStartIdx, pOutBuffer, numFractionDigits);

                // insert the leading zeros
                for (uint32_t i = 2; i < digitsStartIdx; ++i)
                    pOutBuffer[i] = '0';

                // update the counts
                numFractionDigits += numFractionZeros;
                numPrintDigits = numFractionDigits;
            }

            // add the decimal point
            if (maxPrintLen > 1)
            {
                pOutBuffer[1] = fractionPoint;
                numPrintDigits += 1;
            }

            // add the initial zero
            if (maxPrintLen > 0)
            {
                pOutBuffer[0] = '0';
                numPrintDigits += 1;
            }
        }

        // add trailing zeros up to precision length
        if (precision > (int32_t)numFractionDigits && numPrintDigits < maxPrintLen)
        {
            // add a decimal point if this is the first fractional digit we are printing
            if (numFractionDigits == 0)
            {
                pOutBuffer[numPrintDigits++] = fractionPoint;
            }

            // compute the number of trailing zeros needed
            uint32_t totalDigits = numPrintDigits + (precision - numFractionDigits);
            if (totalDigits > maxPrintLen)
                totalDigits = maxPrintLen;

            for (; numPrintDigits < totalDigits; ++numPrintDigits)
                pOutBuffer[numPrintDigits] = '0';
        }

        pOutBuffer[numPrintDigits] = '\0';
    }
    else
    {
        uint32_t numPrintDigits;
        numPrintDigits = Dragon4(mantissa,
                                 exponent,
                                 mantissaHighBitIdx,
                                 hasUnequalMargins,
                                 CutoffMode_TotalLength,
                                 precision + 1,
                                 pOutBuffer,
                                 bufferSize,
                                 &printExponent);

        char *pCurOut = pOutBuffer;
        pCurOut += 1;

        // insert the decimal point prior to the fractional number
        uint32_t numFractionDigits = numPrintDigits - 1;
        if (numFractionDigits > 0 && bufferSize > 1)
        {
            uint32_t maxFractionDigits = bufferSize - 2;
            if (numFractionDigits > maxFractionDigits)
                numFractionDigits = maxFractionDigits;

            MemCopy(pCurOut + 1, pCurOut, numFractionDigits);
            pCurOut[0] = fractionPoint;
            pCurOut += (1 + numFractionDigits);
        }

        pCurOut[0] = '\0';
    }

    buf->EnsureGrowth(size);
    buf->Append(out);

    if (fractionPoint != '\0' && buf->Contains(fractionPoint))
    {
        while (buf->RemoveTrailing('0'))
            ;
        buf->RemoveTrailing(fractionPoint);
    }

    if (printExponent != 0)
    {
        buf->Append('e');
        if (printExponent >= 0)
        {
            buf->Append('+');
        }
        else
        {
            buf->Append('-');
            printExponent = -printExponent;
        }
        int temp;
        IntegerToBuffer(printExponent, 3, &temp);
    }

    if (fractionPoint != '\0' && buf->Contains(fractionPoint) && !buf->Contains('e'))
    {
        while (buf->RemoveTrailing('0'))
            ;
        buf->RemoveTrailing(fractionPoint);
    }

    delete[] out;
    return buf->GetString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• src/lib/ntextd.h
• src/lib/ntextd.cpp