coefficient - while a 18 digits number can also be represented as an long an 18digits multiplication need a 36digits temporary and that is more then a long can do.

Compare

open fun Compare(Value: Number): Int

signed compare

Compare_Unsigned

open fun Compare_Unsigned(Value: BCDInteger): Int

unsigned (absolute) compare

compareTo

abstract fun compareTo(p: T): Int

open fun compareTo(rightValue: Number): Int

cos

open fun cos(): Number

cos (x)

open fun cos(Half_Circle: Number): Number

cosine

cos_hyp

open fun cos_hyp(): Number

Hyperbolic cosine: (Exponent^x + Exponent^-x)/2

Digits

open fun Digits(): Array<Byte>

number: sum(i = 0 ...

div

open fun div(y: Number): Number

x ÷ y

divUnsigned

private open fun divUnsigned(y: Int): BCDInteger

private open fun divUnsigned(Right: BCDInteger): BCDInteger


    predicate: Num_Digits > v.numDigits, v = v.Normalize(), v.numDigits > 1

equals

open fun equals(rightValue: Any): Boolean

exp_10

open fun exp_10(): Number

10x

exp_e

open fun exp_e(): Number

Exponent

open fun Exponent(): Int

current exponent - note that the exponent is based on the internal representation where the radix point is right most.

finalize

protected open fun finalize()

Fix

open fun Fix(Decimal: Int, Exponent: Int): Number

Round to a given Precision after the decimal point.

Frac

open fun Frac(): Number

Recompose a frac double from the given data.

gcd

open fun gcd(y: BCDInteger): BCDInteger

<>calculate the greatest common denominator using the Euclidean algorithm

getClass

fun getClass(): Class<out Any>

hashCode

open fun hashCode(): Int

Indirect_Value

open fun Indirect_Value(Digit_Count: Int): Int

Get valuef or indirect addressing.

Integer

open fun Integer(): Number

integer part of the BCDFloat Do not mix up with To_Integer - This version returns another Number!

Is_Finite

open fun Is_Finite(): Boolean

current value is a normal number

Is_Infinite

open fun Is_Infinite(): Boolean

current value is Infinity.

Is_Integer

open fun Is_Integer(): Boolean

Current value is integer value.

Is_NaN

open fun Is_NaN(): Boolean

current value is not a number

Is_Negative

open fun Is_Negative(): Boolean

Current value us negative

Is_Zero

fun Is_Zero(): Boolean

value is 0

Last_Remainder

open fun Last_Remainder(): BCDInteger

log_10

open fun log_10(): Number

log10 (x)

log_e

open fun log_e(): Number

loge (x)

mid

private open fun mid(start: Int, len: Int): BCDInteger

get part of number

minus

open fun minus(y: Number): Number

x - y

mulUnsigned

private open fun mulUnsigned(y: Int): BCDInteger

unsigned (absolute) multiplication by one digit

private open fun mulUnsigned(y: BCDInteger): BCDInteger

unsigned (absolute) multiplication

neg

open fun neg(): Number

Normalize

open fun Normalize()

Normalize (remove leading zero digits)

not

open fun not(): Number

Logical not

notify

fun notify()

notifyAll

fun notifyAll()

Num_Digits

open fun Num_Digits(): Int

returns number of digits

open fun or(y: Number): Number

Logical or

P_To_X

open fun P_To_X(θ: Number): Number

open fun P_To_X(θ: Number, Half_Circle: Number): Number

Convert Polar to Rectangle Coordinates

P_To_Y

open fun P_To_Y(θ: Number): Number

open fun P_To_Y(θ: Number, Half_Circle: Number): Number

Convert Polar to Rectangle Coordinates

plus

open fun plus(y: Number): Number

x + y

pow

open fun pow(y: Number): Number

R_To_R

open fun R_To_R(y: Number): Number

Convert Rectangle to Polar Coordinates

R_To_θ

open fun R_To_θ(y: Number): Number

open fun R_To_θ(y: Number, Half_Circle: Number): Number

Convert Rectangle to Polar Coordinates

root

open fun root(r: Number): Number

r√x

Round

open fun Round(): Number

Round to effective Precision and Exponent.

open fun Round(Precision: Int, Exponent: Int): Number

Round to a given Precision and Exponent.

Shift_Left

open fun Shift_Left(n: Int): BCDInteger

shift left by n digits (= divide by 10n)

Shift_Right

open fun Shift_Right(n: Int): BCDInteger

shift right by n digits (= multiply by 10n)

sin

open fun sin(): Number

open fun sin(Half_Circle: Number): Number

sine

sin_hyp

open fun sin_hyp(): Number

hyperbolic sine: (ex - e-x) ÷ 2

square

open fun square(): Number

x²

square_root

open fun square_root(): Number

²√x

subUnsigned

private open fun subUnsigned(y: BCDInteger): BCDInteger

unsigned (absolute) subtraction


    predicate: this > a (or this < a if Num_Digits == a.numDigits and underflow in most significant digit is allowed)

tan

open fun tan(): Number

tan x

open fun tan(Half_Circle: Number): Number

tangent

tan_hyp

open fun tan_hyp(): Number

Hyperbolic tangent: (e2x - 1) ÷ (e2x + 1)

times

open fun times(y: Number): Number

x × y

To_Debug_String

open fun To_Debug_String(): String

convert to native/debug string representation

To_Integer

open fun To_Integer(): Int

Convert to integer Do not mix up with Integer – This version returns a Java int!

To_Long

open fun To_Long(): Long

toString

open fun toString(): String

return string representation of number

wait

fun wait()

xor

open fun xor(y: Number): Number

Logical xor