BigUnsignedInABase Class Reference

#include <BigUnsignedInABase.hh>

Inheritance diagram for BigUnsignedInABase:

Collaboration diagram for BigUnsignedInABase:

Public Types
typedef unsigned short	Digit
typedef Digit	Base

Public Member Functions
	BigUnsignedInABase ()
	BigUnsignedInABase (const BigUnsignedInABase &x)
void	operator= (const BigUnsignedInABase &x)
	BigUnsignedInABase (const Digit *d, Index l, Base base)
	~BigUnsignedInABase ()
	BigUnsignedInABase (const BigUnsigned &x, Base base)
	operator BigUnsigned () const
	operator std::string () const
	BigUnsignedInABase (const std::string &s, Base base)
Base	getBase () const
Digit	getDigit (Index i) const
bool	isZero () const
bool	operator== (const BigUnsignedInABase &x) const
bool	operator!= (const BigUnsignedInABase &x) const

Protected Types
typedef unsigned int	Index

Protected Member Functions
	BigUnsignedInABase (int, Index c)
void	zapLeadingZeros ()
void	allocate (Index c)
void	allocateAndCopy (Index c)
Index	getCapacity () const
Index	getLength () const
unsigned short	getBlock (Index i) const
bool	isEmpty () const
bool	operator== (const NumberlikeArray< unsigned short > &x) const
bool	operator!= (const NumberlikeArray< unsigned short > &x) const

Protected Attributes
Base	base
Index	cap
Index	len
unsigned short *	blk

Static Protected Attributes
static const unsigned int	N

Detailed Description

Definition at line 32 of file BigUnsignedInABase.hh.

Member Typedef Documentation

typedef Digit BigUnsignedInABase::Base

Definition at line 38 of file BigUnsignedInABase.hh.

typedef unsigned short BigUnsignedInABase::Digit

Definition at line 36 of file BigUnsignedInABase.hh.

typedef unsigned int NumberlikeArray< unsigned short >::Index

inherited

Definition at line 25 of file NumberlikeArray.hh.

Constructor & Destructor Documentation

BigUnsignedInABase::BigUnsignedInABase ( int  , Index  c  )

inlineprotected

Definition at line 45 of file BigUnsignedInABase.hh.

: NumberlikeArray<Digit>(0, c) {}

BigUnsignedInABase::BigUnsignedInABase ( )

inline

Definition at line 55 of file BigUnsignedInABase.hh.

: NumberlikeArray<Digit>(), base(2) {}

BigUnsignedInABase::BigUnsignedInABase ( const BigUnsignedInABase &  x )

inline

Definition at line 58 of file BigUnsignedInABase.hh.

: NumberlikeArray<Digit>(x), base(x.base) {}

BigUnsignedInABase::BigUnsignedInABase	(	const Digit *	d,
		Index	l,
		Base	base
	)

Definition at line 3 of file BigUnsignedInABase.cc.

    : NumberlikeArray<Digit>(d, l), base(base) {
    // Check the base
    if (base < 2)
        throw "BigUnsignedInABase::BigUnsignedInABase(const Digit *, Index, Base): The base must be at least 2";

    // Validate the digits.
    for (Index i = 0; i < l; i++)
        if (blk[i] >= base)
            throw "BigUnsignedInABase::BigUnsignedInABase(const Digit *, Index, Base): A digit is too large for the specified base";

    // Eliminate any leading zeros we may have been passed.
    zapLeadingZeros();
}

Here is the call graph for this function:

BigUnsignedInABase::~BigUnsignedInABase ( )

inline

Definition at line 70 of file BigUnsignedInABase.hh.

{}

BigUnsignedInABase::BigUnsignedInABase	(	const BigUnsigned &	x,
		Base	base
	)

Definition at line 32 of file BigUnsignedInABase.cc.

                                                                      {
    // Check the base
    if (base < 2)
        throw "BigUnsignedInABase(BigUnsigned, Base): The base must be at least 2";
    this->base = base;

    // Get an upper bound on how much space we need
    int maxBitLenOfX = x.getLength() * BigUnsigned::N;
    int minBitsPerDigit = bitLen(base) - 1;
    int maxDigitLenOfX = ceilingDiv(maxBitLenOfX, minBitsPerDigit);
    len = maxDigitLenOfX; // Another change to comply with `staying in bounds'.
    allocate(len); // Get the space

    BigUnsigned x2(x), buBase(base);
    Index digitNum = 0;

    while (!x2.isZero()) {
        // Get last digit.  This is like `lastDigit = x2 % buBase, x2 /= buBase'.
        BigUnsigned lastDigit(x2);
        lastDigit.divideWithRemainder(buBase, x2);
        // Save the digit.
        blk[digitNum] = lastDigit.toUnsignedShort();
        // Move on.  We can't run out of room: we figured it out above.
        digitNum++;
    }

    // Save the actual length.
    len = digitNum;
}

Here is the call graph for this function:

BigUnsignedInABase::BigUnsignedInABase	(	const std::string &	s,
		Base	base
	)

Definition at line 73 of file BigUnsignedInABase.cc.

                                                                    {
    // Check the base.
    if (base > 36)
        throw "BigUnsignedInABase(std::string, Base): The default string conversion routines use the symbol set 0-9, A-Z and therefore support only up to base 36.  You tried a conversion with a base over 36; write your own string conversion routine.";
    // Save the base.
    // This pattern is seldom seen in C++, but the analogous ``this.'' is common in Java.
    this->base = base;

    // `s.length()' is a `size_t', while `len' is a `NumberlikeArray::Index',
    // also known as an `unsigned int'.  Some compilers warn without this cast.
    len = Index(s.length());
    allocate(len);

    Index digitNum, symbolNumInString;
    for (digitNum = 0; digitNum < len; digitNum++) {
        symbolNumInString = len - 1 - digitNum;
        char theSymbol = s[symbolNumInString];
        if (theSymbol >= '0' && theSymbol <= '9')
            blk[digitNum] = theSymbol - '0';
        else if (theSymbol >= 'A' && theSymbol <= 'Z')
            blk[digitNum] = theSymbol - 'A' + 10;
        else if (theSymbol >= 'a' && theSymbol <= 'z')
            blk[digitNum] = theSymbol - 'a' + 10;
        else
            throw "BigUnsignedInABase(std::string, Base): Bad symbol in input.  Only 0-9, A-Z, a-z are accepted.";

        if (blk[digitNum] >= base)
            throw "BigUnsignedInABase::BigUnsignedInABase(const Digit *, Index, Base): A digit is too large for the specified base";
    }
    zapLeadingZeros();
}

Here is the call graph for this function:

Member Function Documentation

void NumberlikeArray< unsigned short >::allocate ( Index  c )

inherited

Here is the caller graph for this function:

void NumberlikeArray< unsigned short >::allocateAndCopy ( Index  c )

inherited

Base BigUnsignedInABase::getBase ( ) const

inline

Definition at line 100 of file BigUnsignedInABase.hh.

{ return base; }

unsigned short NumberlikeArray< unsigned short >::getBlock ( Index  i ) const

inlineinherited

Definition at line 74 of file NumberlikeArray.hh.

{ return blk[i];   }

Index NumberlikeArray< unsigned short >::getCapacity ( ) const

inlineinherited

Definition at line 72 of file NumberlikeArray.hh.

{ return cap;      }

Digit BigUnsignedInABase::getDigit ( Index  i ) const

inline

Definition at line 108 of file BigUnsignedInABase.hh.

{ return i >= len ? 0 : blk[i]; }

Index NumberlikeArray< unsigned short >::getLength ( ) const

inlineinherited

Definition at line 73 of file NumberlikeArray.hh.

{ return len;      }

bool NumberlikeArray< unsigned short >::isEmpty ( ) const

inlineinherited

Definition at line 75 of file NumberlikeArray.hh.

{ return len == 0; }

bool BigUnsignedInABase::isZero ( ) const

inline

Definition at line 111 of file BigUnsignedInABase.hh.

{ return NumberlikeArray<Digit>::isEmpty(); }

Here is the call graph for this function:

BigUnsignedInABase::operator BigUnsigned

(

)

const

Definition at line 62 of file BigUnsignedInABase.cc.

                                               {
    BigUnsigned ans(0), buBase(base), temp;
    Index digitNum = len;
    while (digitNum > 0) {
        digitNum--;
        temp.multiply(ans, buBase);
        ans.add(temp, BigUnsigned(blk[digitNum]));
    }
    return ans;
}

Here is the call graph for this function:

BigUnsignedInABase::operator std::string

(

)

const

Definition at line 105 of file BigUnsignedInABase.cc.

                                             {
    if (base > 36)
        throw "BigUnsignedInABase ==> std::string: The default string conversion routines use the symbol set 0-9, A-Z and therefore support only up to base 36.  You tried a conversion with a base over 36; write your own string conversion routine.";
    if (len == 0)
        return std::string("0");
    // Some compilers don't have push_back, so use a char * buffer instead.
    char *s = new char[len + 1];
    s[len] = '\0';
    Index digitNum, symbolNumInString;
    for (symbolNumInString = 0; symbolNumInString < len; symbolNumInString++) {
        digitNum = len - 1 - symbolNumInString;
        Digit theDigit = blk[digitNum];
        if (theDigit < 10)
            s[symbolNumInString] = char('0' + theDigit);
        else
            s[symbolNumInString] = char('A' + theDigit - 10);
    }
    std::string s2(s);
    delete [] s;
    return s2;
}

bool NumberlikeArray< unsigned short >::operator!= ( const NumberlikeArray< unsigned short > &  x ) const

inlineinherited

Definition at line 82 of file NumberlikeArray.hh.

                                                          {
        return !operator ==(x);
    }

Here is the call graph for this function:

bool BigUnsignedInABase::operator!= ( const BigUnsignedInABase &  x ) const

inline

Definition at line 118 of file BigUnsignedInABase.hh.

{ return !operator ==(x); }

Here is the call graph for this function:

void BigUnsignedInABase::operator= ( const BigUnsignedInABase &  x )

inline

Definition at line 61 of file BigUnsignedInABase.hh.

                                                 {
        NumberlikeArray<Digit>::operator =(x);
        base = x.base;
    }

Here is the call graph for this function:

bool NumberlikeArray< unsigned short >::operator== ( const NumberlikeArray< unsigned short > &  x ) const

inherited

bool BigUnsignedInABase::operator== ( const BigUnsignedInABase &  x ) const

inline

Definition at line 115 of file BigUnsignedInABase.hh.

                                                        {
        return base == x.base && NumberlikeArray<Digit>::operator ==(x);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void BigUnsignedInABase::zapLeadingZeros ( )

inlineprotected

Definition at line 48 of file BigUnsignedInABase.hh.

                           { 
        while (len > 0 && blk[len - 1] == 0)
            len--;
    }

Here is the caller graph for this function:

Field Documentation

Base BigUnsignedInABase::base

protected

Definition at line 42 of file BigUnsignedInABase.hh.

unsigned short * NumberlikeArray< unsigned short >::blk

inherited

Definition at line 34 of file NumberlikeArray.hh.

Index NumberlikeArray< unsigned short >::cap

inherited

Definition at line 30 of file NumberlikeArray.hh.

Index NumberlikeArray< unsigned short >::len

inherited

Definition at line 32 of file NumberlikeArray.hh.

const unsigned int NumberlikeArray< unsigned short >::N

staticinherited

Definition at line 27 of file NumberlikeArray.hh.

---

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

• BigUnsignedInABase.hh
• BigUnsignedInABase.cc