java.lang.Object
- net.sourceforge.uiq3.math.BCDInteger

All Implemented Interfaces:

Cloneable, Comparable<Number>, Number
```
public final class BCDInteger
extends Object
implements Number
```
Arbitrary Max_Precision BCD Integer Arithmetic

Field Summary

Fields
Modifier and Type	Field	Description
`private byte[]`	`Digits`	number: sum(i = 0 ...
`private static String`	`INTEGER_VALUES_CAN_NOT_USE_LOGARITHMIC_FUNCTIONS`
`private static String`	`INTEGER_VALUES_CAN_NOT_USE_TRIGONOMETRIC_FUNCTIONS`
`private @Nullable BCDInteger`	`Last_Remainder`	remainder of last long division
`private byte`	`Last_Remainder_Short`	remainder of last short division
`private static Logger`	`Logger`	Class logger instance.
`private boolean`	`Negative`	sign
`private static byte[]`	`Null_Digits`	No digits
`static BCDInteger`	`Num_0`	0
`static BCDInteger`	`Num_1`	1
`static BCDInteger`	`Num_10`	10
`static BCDInteger`	`Num_2`	2
`private int`	`Num_Digits`	number of digits
`private static String`	`TAG`	Class logger tag.

Fields inherited from interface net.sourceforge.uiq3.math.Number
Compare_Equal, Compare_Greater, Compare_Less, Effective_Precision, Max_Precision

Constructor Summary

Constructors
Constructor	Description
`BCDInteger()`	new Number, val = 0, length = 0
`BCDInteger(byte @NotNull [] Digits, boolean Negative)`	new Number from attributes.
`BCDInteger(int n)`	new Number, val = 0, length = n
`BCDInteger(long value)`	new Number, val = 0, length = n
`BCDInteger(@NotNull CharSequence s)`	new Number, val and length from string
`BCDInteger(@NotNull BCDInteger Value)`	new Number from existing number

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`@NotNull Number`	`$div(@NotNull Number y)`	signed division
`@NotNull Number`	`$minus(@NotNull Number y)`	signed subtraction
`@NotNull Number`	`$plus(@NotNull Number y)`	signed addition
`@NotNull Number`	`$times(@NotNull Number y)`	signed multiplication
`@NotNull Number`	`$times$times(@NotNull Number y)`	x^y
`@NotNull Number`	`abs()`	\|x\|
`(package private) @NotNull BCDInteger`	`addUnsigned(int y)`	unsigned (absolute) addition of one digit
`private @NotNull BCDInteger`	`addUnsigned(@NotNull BCDInteger a)`	unsigned (absolute) addition
`@NotNull Number`	`and(@NotNull Number y)`	Logical and
`@NotNull Number`	`arc_cos()`	arc cosine
`@NotNull Number`	`arc_cos(@NotNull Number Half_Circle)`	arc cosine
`@NotNull Number`	`arc_cos_hyp()`	area hyperbolic cosine: log_e (x + √(x-1) × √(x+1))
`@NotNull Number`	`arc_sin()`	arc sine
`@NotNull Number`	`arc_sin(@NotNull Number Half_Circle)`	arc sine
`@NotNull Number`	`arc_sin_hyp()`	area hyperbolic sine: log_e (x + √(x² + 1))
`@NotNull Number`	`arc_tan()`	arc tangent
`@NotNull Number`	`arc_tan(@NotNull Number Half_Circle)`	arc tangent
`@NotNull Number`	`arc_tan_hyp()`	area hyperbolic tangent: log_e ((1 + x) ÷ (1 - x)) / 2
`@NotNull BCDFloat`	`As_BCDFloat()`	Either convert to a BCDFloat or return this.
`@NotNull BCDFraction`	`As_BCDFraction()`	Either convert to a or return this.
`@NotNull BCDInteger`	`As_BCDInteger()`	Either convert to a BCDInteger or return this.
`@NotNull Object`	`clone()`	clone the float - but it might be easier to use the provided copy Constructor instead.
`@NotNull Number`	`Clone()`	clone the integer - but it might be easier to use the provided copy Constructor instead.
`long`	`Coefficient_As_Long()`	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.
`int`	`Compare(@NotNull Number Value)`	signed compare
`(package private) int`	`Compare_Unsigned(@NotNull BCDInteger Value)`	unsigned (absolute) compare
`int`	`compareTo(@NotNull Number rightValue)`
`@NotNull Number`	`cos()`	cos (x)
`@NotNull Number`	`cos(@NotNull Number Half_Circle)`	cosine
`@NotNull Number`	`cos_hyp()`	Hyperbolic cosine: (Exponent^x + Exponent^-x)/2
`byte[]`	`Digits()`	number: sum(i = 0 ...
`private @NotNull BCDInteger`	`divUnsigned(int y)`	`predicate: Num_Digits > v.numDigits, v = v.Normalize(), v.numDigits > 1`
`private @NotNull BCDInteger`	`divUnsigned(@NotNull BCDInteger Right)`	`predicate: Num_Digits > v.numDigits, v = v.Normalize(), v.numDigits > 1`
`boolean`	`equals(@NotNull Object rightValue)`
`@NotNull Number`	`exp_10()`	10^x
`@NotNull Number`	`exp_e()`	e^x
`int`	`Exponent()`	current exponent - note that the exponent is based on the internal representation where the radix point is right most.
`@NotNull Number`	`Fix(int Decimal, int Exponent)`	Round to a given Precision after the decimal point.
`@NotNull Number`	`Frac()`	Recompose a frac double from the given data.
`@NotNull BCDInteger`	`gcd(@NotNull BCDInteger y)`	<>calculate the greatest common denominator using the Euclidean algorithm
`int`	`hashCode()`
`int`	`Indirect_Value(int Digit_Count)`	Get valuef or indirect addressing.
`@NotNull Number`	`Integer()`	integer part of the BCDFloat
`boolean`	`Is_Finite()`	current value is a normal number
`boolean`	`Is_Infinite()`	current value is Infinity.
`boolean`	`Is_Integer()`	Current value is integer value.
`boolean`	`Is_NaN()`	current value is not a number
`boolean`	`Is_Negative()`	Current value us negative
`boolean`	`Is_Zero()`	value is 0
`(package private) @Nullable BCDInteger`	`Last_Remainder()`
`@NotNull Number`	`log_10()`	log₁₀ (x)
`@NotNull Number`	`log_e()`	log_e (x)
`private @NotNull BCDInteger`	`mid(int start, int len)`	get part of number
`private @NotNull BCDInteger`	`mulUnsigned(int y)`	unsigned (absolute) multiplication by one digit
`private @NotNull BCDInteger`	`mulUnsigned(@NotNull BCDInteger y)`	unsigned (absolute) multiplication
`@NotNull Number`	`neg()`
`void`	`Normalize()`	Normalize (remove leading zero digits)
`@NotNull Number`	`not()`	Logical not
`int`	`Num_Digits()`	returns number of digits
`@NotNull Number`	`or(@NotNull Number y)`	Logical or
`@NotNull Number`	`P_To_X(@NotNull Number θ)`	Convert Polar to Rectangle Coordinates
`@NotNull Number`	`P_To_X(Number θ, Number Half_Circle)`	Convert Polar to Rectangle Coordinates
`@NotNull Number`	`P_To_Y(@NotNull Number θ)`	Convert Polar to Rectangle Coordinates
`@NotNull Number`	`P_To_Y(@NotNull Number θ, @NotNull Number Half_Circle)`	Convert Polar to Rectangle Coordinates
`@NotNull Number`	`R_To_R(@NotNull Number y)`	Convert Rectangle to Polar Coordinates
`@NotNull Number`	`R_To_θ(@NotNull Number y)`	Convert Rectangle to Polar Coordinates
`@NotNull Number`	`R_To_θ(@NotNull Number y, @NotNull Number Half_Circle)`	Convert Rectangle to Polar Coordinates
`@NotNull Number`	`root(@NotNull Number r)`	^r√x
`@NotNull Number`	`Round()`	Round to effective Precision and Exponent.
`@NotNull Number`	`Round(int Precision, int Exponent)`	Round to a given Precision and Exponent.
`(package private) @NotNull BCDInteger`	`Shift_Left(int n)`	shift left by n digits (= divide by 10ⁿ)
`(package private) @NotNull BCDInteger`	`Shift_Right(int n)`	shift right by n digits (= multiply by 10ⁿ)
`@NotNull Number`	`sin()`	sine
`@NotNull Number`	`sin(@NotNull Number Half_Circle)`	sine
`@NotNull Number`	`sin_hyp()`	hyperbolic sine: (e^x - e^-x) ÷ 2
`@NotNull Number`	`square()`	x²
`@NotNull Number`	`square_root()`	²√x
`private @NotNull BCDInteger`	`subUnsigned(@NotNull BCDInteger y)`	unsigned (absolute) subtraction
`@NotNull Number`	`tan()`	tan x
`@NotNull Number`	`tan(@NotNull Number Half_Circle)`	tangent
`@NotNull Number`	`tan_hyp()`	Hyperbolic tangent: (e^2x - 1) ÷ (e^2x + 1)
`@NotNull String`	`To_Debug_String()`	convert to native/debug string representation
`int`	`To_Integer()`	Convert to integer
`long`	`To_Long()`	Convert to long integer
`@NotNull String`	`toString()`	return string representation of number
`@NotNull Number`	`xor(@NotNull Number y)`	Logical xor

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.sourceforge.uiq3.math.Number
div, minus, plus, pow, times

- Field Detail
  - INTEGER_VALUES_CAN_NOT_USE_LOGARITHMIC_FUNCTIONS
```
private static final String INTEGER_VALUES_CAN_NOT_USE_LOGARITHMIC_FUNCTIONS
```
    See Also:
    
    Constant Field Values
  - INTEGER_VALUES_CAN_NOT_USE_TRIGONOMETRIC_FUNCTIONS
```
private static final String INTEGER_VALUES_CAN_NOT_USE_TRIGONOMETRIC_FUNCTIONS
```
    See Also:
    
    Constant Field Values
  - Logger
```
private static final Logger Logger
```
    Class logger instance.
  - Null_Digits
```
private static final byte[] Null_Digits
```
    No digits
  - TAG
```
private static final String TAG
```
    Class logger tag.
  - Num_0
```
public static final BCDInteger Num_0
```
    0
  - Num_1
```
public static final BCDInteger Num_1
```
    1
  - Num_10
```
public static final BCDInteger Num_10
```
    10
  - Num_2
```
public static final BCDInteger Num_2
```
    2
  - Digits
```
private byte[] Digits
```
    number: sum(i = 0 ... Num_Digits-1; Digits[i]*10^i)
  - Last_Remainder
```
@Nullable
private @Nullable BCDInteger Last_Remainder
```
    remainder of last long division
  - Last_Remainder_Short
```
private byte Last_Remainder_Short
```
    remainder of last short division
  - Negative
```
private boolean Negative
```
    sign
  - Num_Digits
```
private int Num_Digits
```
    number of digits
- Constructor Detail
  - BCDInteger
```
public BCDInteger()
```
    new Number, val = 0, length = 0
  - BCDInteger
```
public BCDInteger(@NotNull
                  @NotNull BCDInteger Value)
```
    new Number from existing number
    
    Parameters:
    
    Value - value to copy
  - BCDInteger
```
public BCDInteger(byte @NotNull [] Digits,
                  boolean Negative)
```
    new Number from attributes.
  - BCDInteger
```
public BCDInteger(@NotNull
                  @NotNull CharSequence s)
```
    new Number, val and length from string
    
    Parameters:
    
    s - string to extract number from
  - BCDInteger
```
public BCDInteger(int n)
```
    new Number, val = 0, length = n
    
    Parameters:
    
    n - digits for new number
  - BCDInteger
```
public BCDInteger(long value)
```
    new Number, val = 0, length = n
    
    Parameters:
    
    value - to init the integer from
- Method Detail
  - $div
```
@Contract(pure=true)
@NotNull
public @NotNull Number $div(@NotNull
                            @NotNull Number y)
```
    signed division
    
    Specified by:
    
    $div in interface Number
    
    Parameters:
    
    y - right value
    
    Returns:
    
    x ÷ y
  - $minus
```
@Contract(pure=true)
@NotNull
public @NotNull Number $minus(@NotNull
                              @NotNull Number y)
```
    signed subtraction
    
    Specified by:
    
    $minus in interface Number
    
    Parameters:
    
    y - right value
    
    Returns:
    
    x - y
  - $plus
```
@Contract(pure=true)
@NotNull
public @NotNull Number $plus(@NotNull
                             @NotNull Number y)
```
    signed addition
    
    Specified by:
    
    $plus in interface Number
    
    Parameters:
    
    y - right value
    
    Returns:
    
    x + y
  - $times
```
@Contract(pure=true)
@NotNull
public @NotNull Number $times(@NotNull
                              @NotNull Number y)
```
    signed multiplication
    
    Specified by:
    
    $times in interface Number
    
    Parameters:
    
    y - Multipicator
    
    Returns:
    
    x × y
  - $times$times
```
@Contract(pure=true)
@NotNull
public @NotNull Number $times$times(@NotNull
                                    @NotNull Number y)
                             throws BCDError
```
    x^y
    
    Specified by:
    
    $times$times in interface Number
    
    Parameters:
    
    y - right value
    
    Returns:
    
    x^y
    
    Throws:
    
    BCDError - calculation error
  - As_BCDFloat
```
@NotNull
public @NotNull BCDFloat As_BCDFloat()
```
    Either convert to a BCDFloat or return this.
    
    Specified by:
    
    As_BCDFloat in interface Number
    
    Returns:
    
    value as java int
  - As_BCDFraction
```
@NotNull
public @NotNull BCDFraction As_BCDFraction()
```
    Either convert to a or return this.
    
    Specified by:
    
    As_BCDFraction in interface Number
    
    Returns:
    
    value as java int
  - As_BCDInteger
```
@NotNull
public @NotNull BCDInteger As_BCDInteger()
```
    Either convert to a BCDInteger or return this.
    
    Specified by:
    
    As_BCDInteger in interface Number
    
    Returns:
    
    value as java int
  - Clone
```
@NotNull
public @NotNull Number Clone()
```
    clone the integer - but it might be easier to use the provided copy Constructor instead.
    
    Specified by:
    
    Clone in interface Number
    
    Returns:
    
    a new BCDFloat from an existing one.
    
    See Also:
    
    Object.clone()
  - Coefficient_As_Long
```
public long Coefficient_As_Long()
                         throws BCDError
```
    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.
    
    Specified by:
    
    Coefficient_As_Long in interface Number
    
    Returns:
    
    Coefficient
    
    Throws:
    
    BCDError - when it's not a normal number
  - Compare
```
public int Compare(@NotNull
                   @NotNull Number Value)
```
    signed compare
    
    Specified by:
    
    Compare in interface Number
    
    Parameters:
    
    Value - value to compare with
    
    Returns:
    
    Compare_Equal
    
    Values are the same
    
    Compare_Less
    
    Left value less the right value
    
    Compare_Greater
    
    Left value greater the right value
  - Compare_Unsigned
```
int Compare_Unsigned(@NotNull
                     @NotNull BCDInteger Value)
```
    unsigned (absolute) compare
    
    Parameters:
    
    Value - value to compare with
    
    Returns:
    
    Compare_Equal
    
    Values are the same
    
    Compare_Less
    
    Left value less the right value
    
    Compare_Greater
    
    Left value greater the right value
  - Digits
```
public byte[] Digits()
```
    number: sum(i = 0 ... Num_Digits-1; Digits[i]*10^i)
    
    Specified by:
    
    Digits in interface Number
  - Exponent
```
public int Exponent()
             throws BCDError
```
    current exponent - note that the exponent is based on the internal representation where the radix point is right most. For example π is 314159265358979324×10^-17.
    
    Specified by:
    
    Exponent in interface Number
    
    Returns:
    
    allways 0
    
    Throws:
    
    BCDError - when the value is not finite
  - Fix
```
@NotNull
public @NotNull Number Fix(int Decimal,
                           int Exponent)
```
    Round to a given Precision after the decimal point.
    
    Specified by:
    
    Fix in interface Number
    
    Parameters:
    
    Decimal - decimal digits to keep
    
    Exponent - max exponent
    
    Returns:
    
    rounded value
  - Frac
```
@NotNull
public @NotNull Number Frac()
```
    Recompose a frac double from the given data.
    
    Specified by:
    
    Frac in interface Number
    
    Returns:
    
    0
  - Indirect_Value
```
public int Indirect_Value(int Digit_Count)
```
    Get valuef or indirect addressing.
    
    Specified by:
    
    Indirect_Value in interface Number
    
    Parameters:
    
    Digit_Count - Should be 1 … 2 depending if value is used to access memory or perform a goto.
    
    Returns:
    
    int value for indirect addressing.
  - Integer
```
@NotNull
public @NotNull Number Integer()
```
    integer part of the BCDFloat
    Do not mix up with To_Integer - This version returns another Number!
    
    Specified by:
    
    Integer in interface Number
    
    Returns:
    
    a clone
  - Is_Finite
```
public boolean Is_Finite()
```
    current value is a normal number
    
    Specified by:
    
    Is_Finite in interface Number
    
    Returns:
    
    true as all intergers are finite
  - Is_Infinite
```
public boolean Is_Infinite()
```
    current value is Infinity.
    
    Specified by:
    
    Is_Infinite in interface Number
    
    Returns:
    
    false since all integer are finite
  - Is_Integer
```
public boolean Is_Integer()
```
    Current value is integer value.
    
    Specified by:
    
    Is_Integer in interface Number
    
    Returns:
    
    true since all integers are – well – integers
  - Is_NaN
```
public boolean Is_NaN()
```
    current value is not a number
    
    Specified by:
    
    Is_NaN in interface Number
    
    Returns:
    
    false since all integers are numbers
  - Is_Negative
```
public boolean Is_Negative()
```
    Current value us negative
    
    Specified by:
    
    Is_Negative in interface Number
    
    Returns:
    
    true when x <= -0
  - Is_Zero
```
public final boolean Is_Zero()
```
    value is 0
    
    Specified by:
    
    Is_Zero in interface Number
    
    Returns:
    
    true when x is 0
  - Last_Remainder
```
@Nullable
@Nullable BCDInteger Last_Remainder()
```
  - Normalize
```
public void Normalize()
```
    Normalize (remove leading zero digits)
    
    Specified by:
    
    Normalize in interface Number
  - Num_Digits
```
public int Num_Digits()
```
    returns number of digits
    
    Specified by:
    
    Num_Digits in interface Number
    
    Returns:
    
    Num_Digits
  - P_To_X
```
@Contract(pure=true)
@NotNull
public @NotNull Number P_To_X(@NotNull
                              Number θ,
                              @NotNull
                              Number Half_Circle)
```
    Convert Polar to Rectangle Coordinates
    
    Specified by:
    
    P_To_X in interface Number
    
    Parameters:
    
    \u03b8 - angle to convert
    
    Half_Circle - 180 for deg, 200 for gra, pi for rad
    
    Returns:
    
    x = cos (θ) × r
  - P_To_X
```
@Contract(pure=true)
@NotNull
public @NotNull Number P_To_X(@NotNull
                              @NotNull Number θ)
```
    Convert Polar to Rectangle Coordinates
    
    Specified by:
    
    P_To_X in interface Number
    
    Parameters:
    
    \u03b8 - angle
    
    Returns:
    
    x = cos (θ) × r
  - P_To_Y
```
@Contract(pure=true)
@NotNull
public @NotNull Number P_To_Y(@NotNull
                              @NotNull Number θ)
```
    Convert Polar to Rectangle Coordinates
    
    Specified by:
    
    P_To_Y in interface Number
    
    Parameters:
    
    \u03b8 - angle
    
    Returns:
    
    y = sin (θ) × r
  - P_To_Y
```
@Contract(pure=true)
@NotNull
public @NotNull Number P_To_Y(@NotNull
                              @NotNull Number θ,
                              @NotNull
                              @NotNull Number Half_Circle)
```
    Convert Polar to Rectangle Coordinates
    
    Specified by:
    
    P_To_Y in interface Number
    
    Parameters:
    
    \u03b8 - angle
    
    Half_Circle - 180 for deg, 200 for gra, pi for rad
    
    Returns:
    
    y = sin (θ) × r
  - R_To_R
```
@Contract(pure=true)
@NotNull
public @NotNull Number R_To_R(@NotNull
                              @NotNull Number y)
```
    Convert Rectangle to Polar Coordinates
    
    Specified by:
    
    R_To_R in interface Number
    
    Parameters:
    
    y - y position
    
    Returns:
    
    r = √(x²+y²)
  - R_To_θ
```
@Contract(pure=true)
@NotNull
public @NotNull Number R_To_θ(@NotNull
                              @NotNull Number y)
```
    Convert Rectangle to Polar Coordinates
    
    Specified by:
    
    R_To_θ in interface Number
    
    Parameters:
    
    y - y position
    
    Returns:
    
    θ = arctan (y÷x)
  - R_To_θ
```
@Contract(pure=true)
@NotNull
public @NotNull Number R_To_θ(@NotNull
                              @NotNull Number y,
                              @NotNull
                              @NotNull Number Half_Circle)
```
    Convert Rectangle to Polar Coordinates
    
    Specified by:
    
    R_To_θ in interface Number
    
    Parameters:
    
    y - y position
    
    Half_Circle - 180 for deg, 200 for gra, pi for rad
    
    Returns:
    
    θ = arctan (y÷x)
  - Round
```
@NotNull
public @NotNull Number Round()
```
    Round to effective Precision and Exponent.
    
    Specified by:
    
    Round in interface Number
    
    Returns:
    
    rounded value
  - Round
```
@NotNull
public @NotNull Number Round(int Precision,
                             int Exponent)
```
    Round to a given Precision and Exponent.
    
    Specified by:
    
    Round in interface Number
    
    Parameters:
    
    Precision - Total precison
    
    Exponent - max exponent
    
    Returns:
    
    rounded value
  - Shift_Left
```
@NotNull
@NotNull BCDInteger Shift_Left(int n)
```
    shift left by n digits (= divide by 10ⁿ)
    
    Parameters:
    
    n - digits to shift
    
    Returns:
    
    x ÷ 10ⁿ
  - Shift_Right
```
@NotNull
@NotNull BCDInteger Shift_Right(int n)
```
    shift right by n digits (= multiply by 10ⁿ)
    
    Parameters:
    
    n - digits to shift
    
    Returns:
    
    x × 10ⁿ
  - To_Debug_String
```
@NotNull
public @NotNull String To_Debug_String()
```
    convert to native/debug string representation
    
    Specified by:
    
    To_Debug_String in interface Number
    
    Returns:
    
    (Coefficient, Exponent)
  - To_Integer
```
public int To_Integer()
```
    Convert to integer
    
    Do not mix up with Integer – This version returns a Java int! Actualy it just returns (int)To_Long ()
    
    Specified by:
    
    To_Integer in interface Number
    
    Returns:
    
    value as java int
  - To_Long
```
public long To_Long()
```
    Description copied from interface: Number
    
    Convert to long integer
    Do not mix up with Integer - This version returns a Java int!
    
    Specified by:
    
    To_Long in interface Number
    
    Returns:
    
    return mantissa as long integer.
  - abs
```
@Contract(pure=true)
@NotNull
public @NotNull Number abs()
```
    |x|
    
    Specified by:
    
    abs in interface Number
    
    Returns:
    
    abs value
  - addUnsigned
```
@NotNull
private @NotNull BCDInteger addUnsigned(@NotNull
                                        @NotNull BCDInteger a)
```
    unsigned (absolute) addition
    
    Parameters:
    
    a - right value
    
    Returns:
    
    abs (x) + abs (y)
  - addUnsigned
```
@NotNull
@NotNull BCDInteger addUnsigned(int y)
```
    unsigned (absolute) addition of one digit
    
    Parameters:
    
    y - right value
    
    Returns:
    
    abs (x) - abs (y)
  - and
```
@Contract(pure=true)
@NotNull
public @NotNull Number and(@NotNull
                           @NotNull Number y)
```
    Logical and
    
    Specified by:
    
    and in interface Number
    
    Returns:
    
    x ∧ y
  - arc_cos
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_cos()
```
    arc cosine
    
    Specified by:
    
    arc_cos in interface Number
    
    Returns:
    
    arc cosine
  - arc_cos
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_cos(@NotNull
                               @NotNull Number Half_Circle)
```
    arc cosine
    
    Specified by:
    
    arc_cos in interface Number
    
    Parameters:
    
    Half_Circle - value for a half circle
    
    Returns:
    
    arccos (x) ÷ π × Half_Circle
  - arc_cos_hyp
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_cos_hyp()
```
    area hyperbolic cosine: log_e (x + √(x-1) × √(x+1))
    
    Specified by:
    
    arc_cos_hyp in interface Number
    
    Returns:
    
    Hyperbolic sine.
  - arc_sin
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_sin()
```
    arc sine
    
    Specified by:
    
    arc_sin in interface Number
    
    Returns:
    
    arc sine
  - arc_sin
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_sin(@NotNull
                               @NotNull Number Half_Circle)
```
    arc sine
    
    Specified by:
    
    arc_sin in interface Number
    
    Parameters:
    
    Half_Circle - value for a half circle
    
    Returns:
    
    arcsin (x) ÷ π × Half_Circle
  - arc_sin_hyp
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_sin_hyp()
```
    area hyperbolic sine: log_e (x + √(x² + 1))
    
    Specified by:
    
    arc_sin_hyp in interface Number
    
    Returns:
    
    Hyperbolic sine.
  - arc_tan
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_tan()
```
    arc tangent
    
    Specified by:
    
    arc_tan in interface Number
    
    Returns:
    
    arc tangent
  - arc_tan
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_tan(@NotNull
                               @NotNull Number Half_Circle)
```
    arc tangent
    
    Specified by:
    
    arc_tan in interface Number
    
    Parameters:
    
    Half_Circle - value for a half circle
    
    Returns:
    
    arctan (x) ÷ π × Half_Circle
  - arc_tan_hyp
```
@Contract(pure=true)
@NotNull
public @NotNull Number arc_tan_hyp()
```
    area hyperbolic tangent: log_e ((1 + x) ÷ (1 - x)) / 2
    
    Specified by:
    
    arc_tan_hyp in interface Number
    
    Returns:
    
    Hyperbolic sine.
  - clone
```
@NotNull
public @NotNull Object clone()
                      throws CloneNotSupportedException
```
    clone the float - but it might be easier to use the provided copy Constructor instead.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    a new BCDInteger from an existing one.
    
    Throws:
    
    CloneNotSupportedException
    
    See Also:
    
    Object.clone()
  - compareTo
```
public int compareTo(@NotNull
                     @NotNull Number rightValue)
```
    Specified by:
    
    compareTo in interface Comparable<Number>
    
    Specified by:
    
    compareTo in interface Number
    
    Parameters:
    
    rightValue - value to compare with
    
    Returns:
    
    Compare_Equal
    
    Values are the same
    
    Compare_Less
    
    Left value less the right value
    
    Compare_Greater
    
    Left value greater the right value
    
    See Also:
    
    Comparable.compareTo(java.lang.Object)
  - cos
```
@Contract(pure=true)
@NotNull
public @NotNull Number cos()
```
    cos (x)
    
    Specified by:
    
    cos in interface Number
    
    Returns:
    
    cos (x)
  - cos
```
@Contract(pure=true)
@NotNull
public @NotNull Number cos(@NotNull
                           @NotNull Number Half_Circle)
```
    cosine
    
    Specified by:
    
    cos in interface Number
    
    Parameters:
    
    Half_Circle - value for a half circle
    
    Returns:
    
    sin (x × π ÷ Half_Circle)
  - cos_hyp
```
@Contract(pure=true)
@NotNull
public @NotNull Number cos_hyp()
```
    Hyperbolic cosine: (Exponent^x + Exponent^-x)/2
    
    Specified by:
    
    cos_hyp in interface Number
    
    Returns:
    
    Hyperbolic cosine.
  - divUnsigned
```
@NotNull
private @NotNull BCDInteger divUnsigned(@NotNull
                                        @NotNull BCDInteger Right)
```
    predicate: Num_Digits > v.numDigits, v = v.Normalize(), v.numDigits > 1
    
    Parameters:
    
    Right - right value
    
    Returns:
    
    abs(x) ÷ abs(y)
  - divUnsigned
```
@NotNull
private @NotNull BCDInteger divUnsigned(int y)
```
    predicate: Num_Digits > v.numDigits, v = v.Normalize(), v.numDigits > 1
    
    Parameters:
    
    y - right value
    
    Returns:
    
    abs(x) ÷ abs(y)
  - equals
```
public boolean equals(@NotNull
                      @NotNull Object rightValue)
```
    Specified by:
    
    equals in interface Number
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    rightValue - right value
    
    Returns:
    
    true when the values are equal
  - exp_10
```
@Contract(pure=true)
@NotNull
public @NotNull Number exp_10()
                       throws BCDError
```
    10^x
    
    Specified by:
    
    exp_10 in interface Number
    
    Returns:
    
    10^x
    
    Throws:
    
    BCDError - calculation error
  - exp_e
```
@Contract(pure=true)
@NotNull
public @NotNull Number exp_e()
```
    e^x
    
    Specified by:
    
    exp_e in interface Number
    
    Returns:
    
    e^x
  - gcd
```
@NotNull
public @NotNull BCDInteger gcd(@NotNull
                               @NotNull BCDInteger y)
```
    <>calculate the greatest common denominator using the Euclidean algorithm
    
    Parameters:
    
    y - second value
    
    Returns:
    
    gcd
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - log_10
```
@Contract(pure=true)
@NotNull
public @NotNull Number log_10()
```
    log₁₀ (x)
    
    Specified by:
    
    log_10 in interface Number
    
    Returns:
    
    log₁₀ (x)
  - log_e
```
@Contract(pure=true)
@NotNull
public @NotNull Number log_e()
```
    log_e (x)
    
    Specified by:
    
    log_e in interface Number
    
    Returns:
    
    log_e (x)
  - mid
```
@NotNull
private @NotNull BCDInteger mid(int start,
                                int len)
```
    get part of number
    
    Parameters:
    
    start - extract from
    
    len - extract length
    
    Returns:
    
    digits from start to start + len
  - mulUnsigned
```
@NotNull
private @NotNull BCDInteger mulUnsigned(@NotNull
                                        @NotNull BCDInteger y)
```
    unsigned (absolute) multiplication
    
    Parameters:
    
    y - right value
    
    Returns:
    
    abs (x) × abs (y)
  - mulUnsigned
```
@NotNull
private @NotNull BCDInteger mulUnsigned(int y)
```
    unsigned (absolute) multiplication by one digit
    
    Parameters:
    
    y - right value
    
    Returns:
    
    abs (x) × abs (y)
  - neg
```
@Contract(pure=true)
@NotNull
public @NotNull Number neg()
```
    Specified by:
    
    neg in interface Number
    
    Returns:
    
    negative value
  - not
```
@Contract(pure=true)
@NotNull
public @NotNull Number not()
```
    Logical not
    
    Specified by:
    
    not in interface Number
    
    Returns:
    
    ¬ x
  - or
```
@Contract(pure=true)
@NotNull
public @NotNull Number or(@NotNull
                          @NotNull Number y)
```
    Logical or
    
    Specified by:
    
    or in interface Number
    
    Parameters:
    
    y - right value
    
    Returns:
    
    x ∨ y
  - root
```
@Contract(pure=true)
@NotNull
public @NotNull Number root(@NotNull
                            @NotNull Number r)
```
    ^r√x
    
    Specified by:
    
    root in interface Number
    
    Parameters:
    
    r - root
    
    Returns:
    
    e^{(log_e x ÷ r)}
  - sin
```
@Contract(pure=true)
@NotNull
public @NotNull Number sin()
```
    sine
    
    Specified by:
    
    sin in interface Number
    
    Returns:
    
    sin (x)
  - sin
```
@Contract(pure=true)
@NotNull
public @NotNull Number sin(@NotNull
                           @NotNull Number Half_Circle)
```
    sine
    
    Specified by:
    
    sin in interface Number
    
    Parameters:
    
    Half_Circle - value for a half circle
    
    Returns:
    
    sin (x × π ÷ Half_Circle)
  - sin_hyp
```
@Contract(pure=true)
@NotNull
public @NotNull Number sin_hyp()
```
    hyperbolic sine: (e^x - e^-x) ÷ 2
    
    Specified by:
    
    sin_hyp in interface Number
    
    Returns:
    
    Hyperbolic sine.
  - square
```
@Contract(pure=true)
@NotNull
public @NotNull Number square()
```
    x²
    
    Specified by:
    
    square in interface Number
    
    Returns:
    
    x²
  - square_root
```
@Contract(pure=true)
@NotNull
public @NotNull Number square_root()
```
    ²√x
    
    Specified by:
    
    square_root in interface Number
    
    Returns:
    
    ²√x
  - subUnsigned
```
@NotNull
private @NotNull BCDInteger subUnsigned(@NotNull
                                        @NotNull BCDInteger y)
```
    unsigned (absolute) subtraction
    predicate: this > a (or this < a if Num_Digits == a.numDigits and underflow in most significant digit is allowed)
    
    Parameters:
    
    y - right value
    
    Returns:
    
    abs (x) - abs (y)
  - tan
```
@Contract(pure=true)
@NotNull
public @NotNull Number tan()
```
    tan x
    
    Specified by:
    
    tan in interface Number
    
    Returns:
    
    tan (x × π ÷ Half_Circle)
  - tan
```
@Contract(pure=true)
@NotNull
public @NotNull Number tan(@NotNull
                           @NotNull Number Half_Circle)
```
    tangent
    
    Specified by:
    
    tan in interface Number
    
    Parameters:
    
    Half_Circle - value for a half circle
    
    Returns:
    
    tangent
  - tan_hyp
```
@NotNull
public @NotNull Number tan_hyp()
```
    Hyperbolic tangent: (e^2x - 1) ÷ (e^2x + 1)
    
    Specified by:
    
    tan_hyp in interface Number
    
    Returns:
    
    Hyperbolic tangent.
  - toString
```
@NotNull
public @NotNull String toString()
```
    return string representation of number
    
    Specified by:
    
    toString in interface Number
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    string representation
    
    See Also:
    
    Object.toString()
  - xor
```
@Contract(pure=true)
@NotNull
public @NotNull Number xor(@NotNull
                           @NotNull Number y)
```
    Logical xor
    
    Specified by:
    
    xor in interface Number
    
    Returns:
    
    x ⊻ y

Class BCDInteger

Field Summary

Fields inherited from interface net.sourceforge.uiq3.math.Number

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface net.sourceforge.uiq3.math.Number

Field Detail

INTEGER_VALUES_CAN_NOT_USE_LOGARITHMIC_FUNCTIONS

INTEGER_VALUES_CAN_NOT_USE_TRIGONOMETRIC_FUNCTIONS

Logger

Null_Digits

TAG

Num_0

Num_1

Num_10

Num_2

Digits

Last_Remainder

Last_Remainder_Short

Negative

Num_Digits

Constructor Detail

BCDInteger

BCDInteger

BCDInteger

BCDInteger

BCDInteger

BCDInteger

Method Detail

$div

$minus

$plus

$times

$times$times

As_BCDFloat

As_BCDFraction

As_BCDInteger

Clone

Coefficient_As_Long

Compare

Compare_Unsigned

Digits

Exponent

Fix

Frac

Indirect_Value

Integer

Is_Finite

Is_Infinite

Is_Integer

Is_NaN

Is_Negative

Is_Zero

Last_Remainder

Normalize

Num_Digits

P_To_X

P_To_X

P_To_Y

P_To_Y

R_To_R

R_To_θ

R_To_θ

Round

Round

Shift_Left

Shift_Right

To_Debug_String

To_Integer

To_Long

abs

addUnsigned

addUnsigned

and

arc_cos

arc_cos

arc_cos_hyp

arc_sin

arc_sin