bignum.h file | source file

This header defines the BigNumber intrinsic class.

Summary of Classes

`BigNumber`

Summary of Global Functions

(none)

Summary of Macros

`BignumCommas BignumCompact BignumEuroStyle BignumExp BignumExpSign BignumKeepTrailingZeros BignumLeadingZero BignumMaxSigDigits BignumPoint BignumPosSpace BignumSign NumTypeInf NumTypeNAN NumTypeNInf NumTypeNum NumTypeNZero NumTypePInf NumTypePZero NumTypeZero`

Summary of Enums

(none)

Summary of Templates

(none)

Global Functions

(none)

Macros

`BignumCommas` | `bignum.h[255]`

`0x0020`
insert commas to denote thousands, millions, etc

`BignumCompact` | `bignum.h[273]`

`0x0100`
"Compact" format: use the shorter of the regular format and scientific notation. If the scientific notation exponent is less than -4 or greater than or equal to the number of digits after the decimal point, we'll use scientific notation; otherwise we'll use the plain format.

`BignumEuroStyle` | `bignum.h[265]`

`0x0080`
use European-style formatting: use a comma instead of a period for the decimal point, and use periods instead of commas to set off thousands, millions, etc

`BignumExp` | `bignum.h[240]`

`0x0002`
always show in exponential format (scientific notation, as in "1.0e20")

`BignumExpSign` | `bignum.h[243]`

`0x0004`
always show a sign in the exponent, even if positive

`BignumKeepTrailingZeros` | `bignum.h[286]`

`0x0400`
Keep trailing zeros. If there's a maxDigits value, this keeps enough trailing zeros so that the number of digits shown equals maxDigits. By default, trailing zeros after the decimal point are removed.

`BignumLeadingZero` | `bignum.h[249]`

`0x0008`
show a zero before the decimal point - this is only relevant in non-exponential format when the number is between -1 and +1

`BignumMaxSigDigits` | `bignum.h[279]`

`0x0200`
maxDigits counts only significant digits; leading zeros aren't counted against the maximum.

`BignumPoint` | `bignum.h[252]`

`0x0010`
always show a decimal point

`BignumPosSpace` | `bignum.h[258]`

`0x0040`
show a leading space if the number is positive

`BignumSign` | `bignum.h[237]`

`0x0001`
always show a sign, even if positive

`NumTypeInf` | `bignum.h[320]`

`(NumTypePInf | NumTypeNInf)`
no description available

`NumTypeNAN` | `bignum.h[307]`

`0x0002`
Number type: "Not a number" (NaN). This indicates that the value is the result of a calculation with invalid input(s). Currently there are no BigNumber calculations that return NaNs, as all functions on invalid inputs throw errors instead. But it's possible to construct NaN value, such as by reading an IEEE 754-2008 NaN value from a file via unpackBytes().

`NumTypeNInf` | `bignum.h[319]`

`0x0008`
no description available

`NumTypeNum` | `bignum.h[297]`

`0x0001`
Number type: ordinary number.

`NumTypeNZero` | `bignum.h[332]`

`0x0020`
no description available

`NumTypePInf` | `bignum.h[318]`

`0x0004`
Number type: positive infinity, negative infinity. These indicate a value that overflowed the capacity of the BigNumber type, or a calculation that yields infinity (e.g., tan(pi/2)). Currently there are no BigNumber calculations that return Infinities, as all functions where an overflow is possible throw errors instead. But it's possible to construct an Infinity value, such as by reading an IEEE 754-2008 Infinity value from a file via unpackBytes().

`NumTypePZero` | `bignum.h[331]`

`0x0010`
Number type: zero, positive or negative. Mathematically, zero is neither positive nor negative, but the BigNumber type retains a sign for all values, even zeros. Negative zeros can come from calculations that yield negative results with absolute values too small for the internal representation. It's also possible to construct a negative zero, such as by reading an IEEE 754-2008 negative zero value from a file via unpackBytes().

`NumTypeZero` | `bignum.h[333]`

`(NumTypePZero | NumTypeNZero)`
no description available

Enums

(none)

Templates

(none)

TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3