Unit bigdecimalmath_template

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

Overview

Classes, Interfaces, Objects and Records

Name	Description
Record `BigDecimal`	Big Decimal type

Functions and Procedures

function TryStrToBigDecimal(const s: string; res: PBigDecimal; errCode: PBigDecimalErrorCode = nil): boolean;

function StrToBigDecimal(const s: string): BigDecimal; inline;

function BigDecimalToStr(const v: BigDecimal; format: TBigDecimalFormat = bdfExact): string;

function BigDecimalToT_NativeInt_(const a: BigDecimal): T_NativeInt_;

function BigDecimalToExtended(const a: BigDecimal): Extended;

operator :=(const a: T_NativeInt_): BigDecimal;

operator :=(const a: Extended): BigDecimal; deprecated 'Direct casting of float to bigdecimal might lead to rounding errors. Consider using StrToBigDecimal.';

operator -(const a: BigDecimal): BigDecimal;

operator +(const a: BigDecimal; const b: BigDecimal): BigDecimal;

operator -(const a: BigDecimal; const b: BigDecimal): BigDecimal;

operator *(const a: BigDecimal; const b: BigDecimal): BigDecimal;

operator /(const a: BigDecimal; const b: BigDecimal): BigDecimal;

operator div(const a: BigDecimal; const b: BigDecimal): BigDecimal;

operator mod(const a: BigDecimal; const b: BigDecimal): BigDecimal;

operator **(const a: BigDecimal; const b: int64): BigDecimal;

procedure divideModNoAlias(out quotient, remainder: BigDecimal; const a, b: BigDecimal; targetPrecision: integer = 18; flags: TBigDecimalDivisionFlags = [bddfKeepDividentPrecision, bddfKeepDivisorPrecision, bddfAddHiddenDigit]);

function divide(const a, b: BigDecimal; maximalAdditionalFractionDigits: integer = 18; flags: TBigDecimalDivisionFlags = [bddfKeepDividentPrecision, bddfKeepDivisorPrecision, bddfAddHiddenDigit]): BigDecimal;

procedure shift10(var v: BigDecimal; shift: integer);

function shifted10(const v: BigDecimal; shift: integer): BigDecimal;

function compareBigDecimals(const a, b: BigDecimal): integer;

operator _OP_(const a: BigDecimal; const b: BigDecimal): boolean;

procedure normalize(var x: BigDecimal);

function precision(const v: BigDecimal): integer;

function round(const v: BigDecimal; toDigit: integer = 0; roundingMode: TBigDecimalRoundingMode = bfrmRound): BigDecimal; overload;

function roundInRange(mi, exact, ma: BigDecimal): BigDecimal;

function getDigit(const v: BigDecimal; digit: integer): BigDecimalBin;

procedure setZero(out r: BigDecimal);

procedure setOne(out r: BigDecimal);

function isZero(const v: BigDecimal): boolean; overload;

function isIntegral(const v: BigDecimal): boolean;

function isLongint(const v: BigDecimal): boolean;

function isInt64(const v: BigDecimal): boolean;

function odd(const v: BigDecimal): boolean; overload;

function even(const v: BigDecimal): boolean; overload;

function abs(const v: BigDecimal): BigDecimal; overload;

function power(const v: BigDecimal; const exp: Int64): BigDecimal; overload;

function sqrt(const v: BigDecimal; precision: integer = 9): BigDecimal; overload;

function gcd(const a,b: BigDecimal): BigDecimal; overload;

function lcm(const a,b: BigDecimal): BigDecimal; overload;

function fastpower2to(const exp: Int64): BigDecimal;

function fastpower5to(const exp: Int64): BigDecimal;

Types

BigDecimalBin = integer;

BigDecimalBinSquared = int64;

PBigDecimal = ˆBigDecimal;

TBigDecimalErrorCode = (...);

PBigDecimalErrorCode = ˆTBigDecimalErrorCode;

TBigDecimalFormat = (...);

TBigDecimalFloatFormat = (...);

TBigDecimalDivisionFlags = set of (bddfKeepDividentPrecision, bddfKeepDivisorPrecision, bddfAddHiddenDigit, bddfFillIntegerPart, bddfNoFractionalPart);

TBigDecimalRoundingMode = (...);

Constants

DIGITS_PER_ELEMENT = 9;

ELEMENT_OVERFLOW = 1000000000;

Description

Functions and Procedures

function TryStrToBigDecimal(const s: string; res: PBigDecimal; errCode: PBigDecimalErrorCode = nil): boolean;

Converts a decimal string to a bigdecimal.
Supports standard decimal notation, like -123.456 or 1E-2 (-?[0-9]+(.[0-9]+)?([eE][-+]?[0-9]+))

function StrToBigDecimal(const s: string): BigDecimal; inline;

Converts a decimal string to a bigdecimal.
Supports standard decimal notation, like -123.456 or 1E-2 (-?[0-9]+(.[0-9]+)?([eE][-+]?[0-9]+)) Raises an exception on invalid input.

function BigDecimalToStr(const v: BigDecimal; format: TBigDecimalFormat = bdfExact): string;

Converts a bigdecimal to a decimal string
The result will be fixed width format [0-9]+(.[0-9]+)?, even if the input had an exponent

function BigDecimalToT_NativeInt_(const a: BigDecimal): T_NativeInt_;

Converts a bigdecimal to a native int (can overflow)

function BigDecimalToExtended(const a: BigDecimal): Extended;

Converts a bigdecimal to an extended (may introduce rounding errors)

operator :=(const a: T_NativeInt_): BigDecimal;

Converts a native integer to a BigDecimal

operator :=(const a: Extended): BigDecimal; deprecated 'Direct casting of float to bigdecimal might lead to rounding errors. Consider using StrToBigDecimal.';

Warning: this symbol is deprecated: Direct casting of float to bigdecimal might lead to rounding errors. Consider using StrToBigDecimal.

Converts an extended to a BigDecimal
Marked as deprecated, because it may lead to rounding errors. FloatToBigDecimal is exact, but probably some magnitudes slower. For constant values StrToBigDecimal should be used instead.

operator -(const a: BigDecimal): BigDecimal;

Standard operator unary -

operator +(const a: BigDecimal; const b: BigDecimal): BigDecimal;

Standard operator binary +

operator -(const a: BigDecimal; const b: BigDecimal): BigDecimal;

Standard operator binary -

operator *(const a: BigDecimal; const b: BigDecimal): BigDecimal;

Standard operator binary *

operator /(const a: BigDecimal; const b: BigDecimal): BigDecimal;

Standard operator binary /
If the result can not be represented as finite decimal number (e.g. 1/3) it will be calculated with 18 digit precision after the decimal point, with an additional hidden digit for rounding (so 1/3 is 0.333333333333333333, and 0.333333333333333333*3 is 0.999999999999999999, but (1/3) * 3 is 1).

operator div(const a: BigDecimal; const b: BigDecimal): BigDecimal;

Standard operator binary div
The result is an integer, so 1.23E3 / 7 will be 175

operator mod(const a: BigDecimal; const b: BigDecimal): BigDecimal;

Standard operator binary mod
Calculates the remainder of an integer division a - (a div b) * b

operator **(const a: BigDecimal; const b: int64): BigDecimal;

Standard operator binary **

procedure divideModNoAlias(out quotient, remainder: BigDecimal; const a, b: BigDecimal; targetPrecision: integer = 18; flags: TBigDecimalDivisionFlags = [bddfKeepDividentPrecision, bddfKeepDivisorPrecision, bddfAddHiddenDigit]);

Universal division/modulo function. Calculates the quotient and remainder of a / b.
bddfKeepDividentPrecision: calculates as least as many non-zero digit of the quotient as the divident (1st arg) has
bddfKeepDivisorPrecision: calculates as least as many non-zero digit of the quotient as the divisor (2nd arg) has
bddfAddHiddenDigit: Calculates an additional digit for rounding, which will not be displayed by BigDecimalToStr
bddfFillIntegerPart: Calculate at least all digits of the integer part of the quotient, independent of the precision of the input
bddfNoFractionalPart: Do not calculate the fractional part of the quotient (remember that a bigdecimal is a scaled integer. So bfdfFillIntegerPart ensures that the result has not less digits than an integer division (necessary in case of an exponent > 0) and bfdfKillFractions that the result has not more digits than an integer division (in case of an exponent < 0) )
not all flag combinations were tested

Parameters

maximalAdditionalFractionDigits: How many digits should be added to the quotient, if the result cannot be represented with the current precision
flags: Division options:

function divide(const a, b: BigDecimal; maximalAdditionalFractionDigits: integer = 18; flags: TBigDecimalDivisionFlags = [bddfKeepDividentPrecision, bddfKeepDivisorPrecision, bddfAddHiddenDigit]): BigDecimal;

Wrapper around divideModNoAlias, ignoring the calculated remainder

procedure shift10(var v: BigDecimal; shift: integer);

Calculates a decimal shift: v := v * 10ˆshift

function shifted10(const v: BigDecimal; shift: integer): BigDecimal;

Calculates a decimal shift: result := v * 10ˆshift

function compareBigDecimals(const a, b: BigDecimal): integer;

Compares the big decimals. Returns -1, 0 or 1 corresponding to a <, = or > b

operator _OP_(const a: BigDecimal; const b: BigDecimal): boolean;

procedure normalize(var x: BigDecimal);

Removes leading (pre .) and trailing (post .) zeros

function precision(const v: BigDecimal): integer;

How many non-zero digits the number contains

function round(const v: BigDecimal; toDigit: integer = 0; roundingMode: TBigDecimalRoundingMode = bfrmRound): BigDecimal; overload;

Universal rounding function
Rounds v to the precision of a certain digit, subject to a certain rounding mode.
Positive toDigit will round to an integer with toDigit trailing zeros, negative toDigit will round to a decimal with -toDigit numbers after the decimal point

function roundInRange(mi, exact, ma: BigDecimal): BigDecimal;

Given mi < exact < ma, truncate exact to a bigdecimal result, such that
mi < result < ma
result has the minimal number of non-zero digits
| result - exact | is minimized

function getDigit(const v: BigDecimal; digit: integer): BigDecimalBin;

Returns the digit-th digit of v.
Last integer digit is digit 0, digits at negative indices are behind the decimal point.

procedure setZero(out r: BigDecimal);

Sets the bigdecimal to 0

procedure setOne(out r: BigDecimal);

Sets the bigdecimal to 1

function isZero(const v: BigDecimal): boolean; overload;

Returns true iff the bigdecimal is zero

function isIntegral(const v: BigDecimal): boolean;

Returns true iff v has no fractional digits

function isLongint(const v: BigDecimal): boolean;

Returns true iff v has no fractional digits and can be stored within an longint (32 bit integer)

function isInt64(const v: BigDecimal): boolean;

Returns true iff v has no fractional digits and can be stored within an int64

function odd(const v: BigDecimal): boolean; overload;

Checks if v is odd. A number with fractional digits is never odd (only weird)

function even(const v: BigDecimal): boolean; overload;

Checks if v is even. A number with fractional digits is never even (and neither odd, which is odd)

function abs(const v: BigDecimal): BigDecimal; overload;

Returns the absolute value of v

function power(const v: BigDecimal; const exp: Int64): BigDecimal; overload;

Calculates v ** exp, with exp being an integer

function sqrt(const v: BigDecimal; precision: integer = 9): BigDecimal; overload;

Calculates the square root of v, to precision digits after the decimal point
Not much tested

function gcd(const a,b: BigDecimal): BigDecimal; overload;

Calculates the greatest common denominator (only makes sense for positive integer input)

function lcm(const a,b: BigDecimal): BigDecimal; overload;

Calculates the least common multiple

function fastpower2to(const exp: Int64): BigDecimal;

Calculates 2 ** exp exactly, with exp being an integer (faster than power for negative exp)

function fastpower5to(const exp: Int64): BigDecimal;

Calculates 5 ** exp exactly, with exp being an integer (faster than power for negative exp)

Types

BigDecimalBin = integer;

BigDecimalBinSquared = int64;

PBigDecimal = ˆBigDecimal;

TBigDecimalErrorCode = (...);

Values

bdceNoError
bdceParsingInvalidFormat
bdceParsingTooBig

PBigDecimalErrorCode = ˆTBigDecimalErrorCode;

TBigDecimalFormat = (...);

Values

bdfExact
bdfExponent

TBigDecimalFloatFormat = (...);

Values

bdffExact
bdffShortest

TBigDecimalDivisionFlags = set of (bddfKeepDividentPrecision, bddfKeepDivisorPrecision, bddfAddHiddenDigit, bddfFillIntegerPart, bddfNoFractionalPart);

TBigDecimalRoundingMode = (...);

Values

bfrmTrunc
bfrmCeil
bfrmFloor
bfrmRound
bfrmRoundHalfUp
bfrmRoundHalfToEven

Constants

DIGITS_PER_ELEMENT = 9;

ELEMENT_OVERFLOW = 1000000000;

Generated by PasDoc 0.16.0.