FixedBin

java.lang.Object
- java.lang.Number
- - com.heirloomcomputing.epli.runtime.FixedBin

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<FixedBin>
```
public class FixedBin
extends java.lang.Number
implements java.lang.Comparable<FixedBin>
```
Emulate the arbitrary precision fixed binary arithmetic datatype using Java's native "long" or "BigInteger" with a scale.
This represents a PL/I "FIXED BINARY PRECISION(p,q)" datatype. A FIXED BIN(p,q) means that it has a "p" total binary digits, "q" of which are to the right of the "binary point". Values will be stored internally to FixedBin as a "long" for values up to 63 bits, e.g., FIXED BIN(15), FIXED BIN(31), FIXED BIN(63,20) all will use "long" arithmetic where possible. Larger values than 63 will use BigInteger internally which is of arbitrary size.
For example, a FIXED BIN(5,3) in PL/I is a FixedBin with 5 digits and scale factor of 3. Such a value can be created with the "valueOf()" static method call as in,
```
     FixedBin A = FixedBin.valueOf("10.111B");
 
```
This method call will create an immutable object of 5 digits and 3 scale. This represents the binary value 10.111B or decimal value 2.875 ("2 + 2**-1 + 2**-2 + 2**-3" or "2 + 1/2 + 1/4 + 1/8"). Within FixedBin this is represented with a long of value "10111B" or "23". To create a specific sized variable, say of 15 digits 5 precision, use
```
     FixedBin B = FixedBin.valueOf(2.875, 15, 5);
 
```
which is the same as
```
     FixedBin B = new FixedBin("10.111B", 15, 5);
 
```
A major problem with FIXED BIN arithmetic are overflows and loss of precision. long can hold arbitrary numbers of binary digits, solving overflows. Precision is handled FixedBin by expanding the result of a arithmetic value (e.g., multiply() or divide() to accommodate the sum of the two scales. The assignment of an expression of the above,
```
     FixedBin C = A.multiply(B); // multiply 2.875*2.87500
 
```
results in a a FIXED BIN(14,10). Multiplying quantities of equal precision will also expand the scale. For example, FIXED BIN(5,3) values 10.001B and 10.001B multiplied will give 100.000001B, a FIXED BIN(9,6). OVERFLOW or UNDERFLOW (PL/I) conditions will be raised if the result is scaled down to the original FIXED BIN(5,3) precision which can be attempted with
```
     FixedBin A = new FixedBin("10.111B", 5, 3);
     FixedBin B = new FixedBin("10.111B", 5, 3);
     FixedBin C = new FixedBin(A.multiply(B), 5, 3);
     // throws Java Conditions for various PL/I CONVERSION, OVERFLOW or UNDERFLOW conditions
 
```
FixedBin, like Long, Integer or other wrappered types, are immutable. They can't be changed by can be converted to other FixedBin (or other forms like Double, String) as a result of arithmetic (multiply()) and have the the same interfaces as those wrapper classes (intValue(), longValue(), valueOf(), toString(), etc)
Author:

Heirloom Computing, Inc.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static FixedBin ONE

static FixedBin TEN

static FixedBin ZERO

Fields
Modifier and Type	Field and Description
`static FixedBin`	`ONE`
`static FixedBin`	`TEN`
`static FixedBin`	`ZERO`

Constructor Summary

Constructors
Constructor and Description
`FixedBin(java.math.BigInteger cpyv, int cpyd, int cpys)` Piecemeal, non-converting, copy constructor.
`FixedBin(byte[] val)` Construct a FixedBin from a byte array containing the twos-complement binary rep of a FixedBin into a FixedBin, of scale 0.
`FixedBin(byte[] val, int digits, int scale)` Construct a FixedBin from a byte array containing a twos-compliment binary representation of a FixedBin with a given precision and scale
`FixedBin(FixedBin cpy)` Copy constructor creates a duplicate of another FixedBin
`FixedBin(FixedBin val, int digits, int scale)` Construct a FixedBin of one scale to another of the same or different scale
`FixedBin(int signum, byte[] val)` Construct a 0-scale FixedBin number
`FixedBin(int bitLength, int certainty, java.util.Random rnd)` Constructs a randomly generated positive 0-scale FixedBin that is probably prime, with the specified bitLength.
`FixedBin(int numBits, java.util.Random rnd)` Construct a randomly generated positive 0-scale FixedBin
`FixedBin(long cpyv, int cpyd, int cpys)` piecemeal, non-converting, copy constructor
`FixedBin(java.lang.String val)` Construct the decimal String representation of a FixedBin into a n-scale FixedBin.
`FixedBin(java.lang.String val, int radix)` Construct a FixedBin from a the String representation in radix into a 0-scale FixedBin.
`FixedBin(java.lang.String val, int digits, int scale)` Construct the decimal String representation of a FixedBin into a n-scale FixedBin.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FixedBin`	`add(FixedBin x)` add - add two FixedBin numbers returning the result
`java.math.BigInteger`	`bigIntegerValue()` bigIntegerValue() - return a big integer from a FixedBin number
`boolean`	`booleanValue()` Convert to boolean
`byte`	`byteValue()` Convert to byte, truncating any digits to the right of the binary point
`byte`	`byteValueExact()` Convert to short, truncating any digits to the right of the binary point
`static int`	`compare(FixedBin x, FixedBin y)` compare - static compare two FixedBin values
`int`	`compareTo(FixedBin y)` compareTo - compare two FixedBin values after adjusting to the higher precision and return he value 0 if this FixedBin is equal to the argument FixedBin; a value less than 0 if this FixedBin is numerically less than the argument FixedBin; and a value greater than 0 if this FixedBin is numerically greater than the argument FixedBin (signed comparison).
`int`	`digits()` Return the number of defined or adjusted by way of computations
`FixedBin`	`divide(FixedBin x)` divide - divide a FixedBin number by another and return the result
`double`	`doubleValue()` Convert to double
`boolean`	`equals(java.lang.Object y)` equals - Compares this object to the specified object.
`float`	`floatValue()` Convert to float
`void`	`fromBytes(byte[] bytes)` fromBytes - convert a byte array (likely generated by toBytes()) back into a FixedBin
`int`	`getSize()` the size "if converted to an array of bytes" is calculated by converting it to bytes
`int`	`intValue()` Convert to int, truncating any digits to the right of the binary point
`int`	`intValueExact()` Convert to int, truncating any digits to the right of the binary point and throwing exceptions if precision is lost
`long`	`longValue()` Convert to long, truncating any digits to the right of the binary point
`long`	`longValueExact()` Convert to long, truncating any digits to the right of the binary point and throwing exceptions if precision is lost
`static void`	`main(java.lang.String[] args)` main -- FixedBin unit test
`FixedBin`	`multiply(FixedBin x)` multiply - multiply a FixedBin number by another and return the result
`FixedBin`	`negate()` negate - negate a FixedBin number
`int`	`precision()` Return the number of defined or adjusted by way of computations
`int`	`scale()` Return the scale factor defined or adjusted by way of computations
`short`	`shortValue()` Convert to short, truncating any digits to the right of the binary point
`short`	`shortValueExact()` Convert to short, truncating any digits to the right of the binary point
`int`	`size()` size - return the size in bytes if this FixedBin were to be converted toBytes()
`FixedBin`	`subtract(FixedBin x)` subtract - subtract a FixedBin number from this one and return the result
`byte[]`	`toByteArray()` toByteArray - synonym for toBytes()
`byte[]`	`toBytes()` toBytes - generate a byte array of the internal data value of the variable of variable size, not including 0s or -1s indicating sign.
`java.lang.String`	`toString()` Convert to String
`java.lang.String`	`toString(int radix)` Convert to String with radix
`static FixedBin`	`valueOf(java.math.BigDecimal val)` Factory method to convert from BigDecimal with specific precision and scale to FixedBin
`static FixedBin`	`valueOf(java.math.BigDecimal val, int digits, int scale)` Factory method to convert from BigDecimal with specific precision and scale to FixedBin
`static FixedBin`	`valueOf(byte val)` Factory method to convert from byte (with implied scale 0) to FixedBin scale 0.
`static FixedBin`	`valueOf(byte[] val)` Factory method to convert from byte array with specific precision and scale to FixedBin
`static FixedBin`	`valueOf(byte[] val, int digits, int scale)` Factory method to convert from byte array with specific precision and scale to FixedBin
`static FixedBin`	`valueOf(byte val, int digits, int scaling)` Factory method to convert from byte (with implied scale 0) FixedBin with a specific number of digits and scale
`static FixedBin`	`valueOf(double val)` Factory method to convert from double (with inherent scale) to FixedBin
`static FixedBin`	`valueOf(double val, int digits, int scale)` Factory method to convert from double with specific precision and scale to FixedBin
`static FixedBin`	`valueOf(float val)` Factory method to convert from float (with inherent scale) to FixedBin
`static FixedBin`	`valueOf(float val, int digits, int scale)` Factory method to convert from float with specific precision and scale to FixedBin
`static FixedBin`	`valueOf(int val)` Factory method to convert from int (with implied scale 0) to FixedBin scale 0.
`static FixedBin`	`valueOf(int val, int digits, int scaling)` Factory method to convert from int (with implied scale 0) FixedBin with a specific number of digits and scale
`static FixedBin`	`valueOf(long val)` Factory method to convert from long (with implied scale 0) to FixedBin scale 0.
`static FixedBin`	`valueOf(long val, int digits, int scaling)` Factory method to convert from long (with implied scale 0) FixedBin with a specific number of digits and scale
`static FixedBin`	`valueOf(java.lang.Object val, int... pq)` Factory method to convert an arbitrary Object (instanceof one of the other valueOf() methods) to FixedBin
`static FixedBin`	`valueOf(short val)` Factory method to convert from short (with implied scale 0) to FixedBin scale 0.
`static FixedBin`	`valueOf(short val, int digits, int scaling)` Factory method to convert from short (with implied scale 0) FixedBin with a specific number of digits and scale
`static FixedBin`	`valueOf(java.lang.String val)` Factory method to convert from String without specific precision and scale to FixedBin
`static FixedBin`	`valueOf(java.lang.String val, int digits, int scale)` Factory method to convert from String with specific precision and scale to FixedBin

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

- Field Detail
  - ZERO
```
public static final FixedBin ZERO
```
  - ONE
```
public static final FixedBin ONE
```
  - TEN
```
public static final FixedBin TEN
```
- Constructor Detail
  - FixedBin
```
public FixedBin(byte[] val)
```
    Construct a FixedBin from a byte array containing the twos-complement binary rep of a FixedBin into a FixedBin, of scale 0.
    
    Parameters:
    
    val - - the byte array to use
  - FixedBin
```
public FixedBin(byte[] val,
                int digits,
                int scale)
```
    Construct a FixedBin from a byte array containing a twos-compliment binary representation of a FixedBin with a given precision and scale
    
    Parameters:
    
    val - the byte array value
    
    digits - - the number of digits of precision
    
    scale - - the number of digits to the right of the decimal point
  - FixedBin
```
public FixedBin(int signum,
                byte[] val)
```
    Construct a 0-scale FixedBin number
    
    Parameters:
    
    signum - - translate the sign-magnitude rep of a FixedBin into a FixedBin
    
    val - - the byte array value
  - FixedBin
```
public FixedBin(int bitLength,
                int certainty,
                java.util.Random rnd)
```
    Constructs a randomly generated positive 0-scale FixedBin that is probably prime, with the specified bitLength. Follows the format for similar method of BigInteger
    
    Parameters:
    
    bitLength - - number of bits
    
    certainty - - not used
    
    rnd - - random number
  - FixedBin
```
public FixedBin(int numBits,
                java.util.Random rnd)
```
    Construct a randomly generated positive 0-scale FixedBin
    
    Parameters:
    
    numBits - - number of bits
    
    rnd - - random number
  - FixedBin
```
public FixedBin(java.lang.String val)
```
    Construct the decimal String representation of a FixedBin into a n-scale FixedBin.
    
    Parameters:
    
    val - - the string rep of the FixedBin number
  - FixedBin
```
public FixedBin(java.lang.String val,
                int digits,
                int scale)
```
    Construct the decimal String representation of a FixedBin into a n-scale FixedBin.
    
    Parameters:
    
    val - - the string rep of the FixedBin number
    
    digits - - the number of digits of precision
    
    scale - - the number of digits to the right of the decimal point
  - FixedBin
```
public FixedBin(java.lang.String val,
                int radix)
```
    Construct a FixedBin from a the String representation in radix into a 0-scale FixedBin.
    
    Parameters:
    
    val - - the string rep of the bits to convert
    
    radix - - and radix
  - FixedBin
```
public FixedBin(FixedBin val,
                int digits,
                int scale)
```
    Construct a FixedBin of one scale to another of the same or different scale
    
    Parameters:
    
    val - - another fixed bin
    
    digits - - the new defined number of digits (an arithmetic operation involving the variable, like adding 0 to it, might reduce the result's number of digits
    
    scale - - the new scale, either higher or lower or same precision
    
    Throws:
    
    Condition.OVERFLOW - on OVERFLOW (the number of digits is too small to hold the result) or UNDERFLOW (the scale is not big enough to hold the result and results in truncation
  - FixedBin
```
public FixedBin(FixedBin cpy)
```
    Copy constructor creates a duplicate of another FixedBin
  - FixedBin
```
public FixedBin(java.math.BigInteger cpyv,
                int cpyd,
                int cpys)
```
    Piecemeal, non-converting, copy constructor.
    
    Parameters:
    
    cpyv - - the unscaled BigInteger value to assign
    
    cpyd - - the number of digits (in bits)
    
    cpys - - the scale (in bits to the right of the binary point) Note: Not to be used to get a FixedBin from a BigInteger, use FixedBin.valueOf(big-int.longValue(), num-digits, scale-factor)
  - FixedBin
```
public FixedBin(long cpyv,
                int cpyd,
                int cpys)
```
    piecemeal, non-converting, copy constructor
    
    Parameters:
    
    cpyv - - the long value to assign
    
    cpyd - - the number of digits (in bits)
    
    cpys - - the scale (in bits to the right of the binary point) Note: Not to be used to get a FixedBin of a regular long with digits and scale, use FixedBin.valueOf(long-number, number-of-digits, scaling-factor) DCL A FIXED BIN(15,5) INIT(1234) >> FixedBin.valueOf(1234,15,5)
- Method Detail
  - valueOf
```
public static FixedBin valueOf(long val)
```
    Factory method to convert from long (with implied scale 0) to FixedBin scale 0.
    
    Parameters:
    
    val - - long value to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(int val)
```
    Factory method to convert from int (with implied scale 0) to FixedBin scale 0.
    
    Parameters:
    
    val - - int value to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(short val)
```
    Factory method to convert from short (with implied scale 0) to FixedBin scale 0.
    
    Parameters:
    
    val - - short value to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(byte val)
```
    Factory method to convert from byte (with implied scale 0) to FixedBin scale 0.
    
    Parameters:
    
    val - - long value to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(long val,
                               int digits,
                               int scaling)
```
    Factory method to convert from long (with implied scale 0) FixedBin with a specific number of digits and scale
    
    Parameters:
    
    val - - long value to be used to set the value of the FixedBin
    
    digits - - the defined number of binary digits to use (< LONGDIGITS)
    
    scaling - - the defined binary scaling factor
    
    Returns:
    
    a new FixedBin with the given value Note: performs conversion such that valueOf(n, p, q).longValue() == n Note: digits may not be the number of digits needed to hold the value, use FixedBin.valueOf(val, defined-digits, defined-scale).multiply(FixedBin.valueOf(1)).digits() to see the minimum defined size to hold the value. e.g., DCL A FIXED BIN(15,5) INIT(1234) actually only needs FIXED BIN(10,5)
  - valueOf
```
public static FixedBin valueOf(int val,
                               int digits,
                               int scaling)
```
    Factory method to convert from int (with implied scale 0) FixedBin with a specific number of digits and scale
    
    Parameters:
    
    val - - int value to be used to set the value of the FixedBin
    
    digits - - the defined number of binary digits to use (< LONGDIGITS)
    
    scaling - - the defined binary scaling factor
    
    Returns:
    
    a new FixedBin with the given value Note: performs conversion such that valueOf(n, p, q).longValue() == n Note: digits may not be the number of digits needed to hold the value, use FixedBin.valueOf(val, defined-digits, defined-scale).multiply(FixedBin.valueOf(1)).digits() to see the minimum defined size to hold the value. e.g., DCL A FIXED BIN(15,5) INIT(1234) actually only needs FIXED BIN(10,5)
  - valueOf
```
public static FixedBin valueOf(short val,
                               int digits,
                               int scaling)
```
    Factory method to convert from short (with implied scale 0) FixedBin with a specific number of digits and scale
    
    Parameters:
    
    val - - short value to be used to set the value of the FixedBin
    
    digits - - the defined number of binary digits to use (< LONGDIGITS)
    
    scaling - - the defined binary scaling factor
    
    Returns:
    
    a new FixedBin with the given value Note: performs conversion such that valueOf(n, p, q).longValue() == n Note: digits may not be the number of digits needed to hold the value, use FixedBin.valueOf(val, defined-digits, defined-scale).multiply(FixedBin.valueOf(1)).digits() to see the minimum defined size to hold the value. e.g., DCL A FIXED BIN(15,5) INIT(1234) actually only needs FIXED BIN(10,5)
  - valueOf
```
public static FixedBin valueOf(byte val,
                               int digits,
                               int scaling)
```
    Factory method to convert from byte (with implied scale 0) FixedBin with a specific number of digits and scale
    
    Parameters:
    
    val - - byte value to be used to set the value of the FixedBin
    
    digits - - the defined number of binary digits to use (< LONGDIGITS)
    
    scaling - - the defined binary scaling factor
    
    Returns:
    
    a new FixedBin with the given value Note: performs conversion such that valueOf(n, p, q).longValue() == n Note: digits may not be the number of digits needed to hold the value, use FixedBin.valueOf(val, defined-digits, defined-scale).multiply(FixedBin.valueOf(1)).digits() to see the minimum defined size to hold the value. e.g., DCL A FIXED BIN(15,5) INIT(1234) actually only needs FIXED BIN(10,5)
  - valueOf
```
public static FixedBin valueOf(double val)
```
    Factory method to convert from double (with inherent scale) to FixedBin
    
    Parameters:
    
    val - - double value to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(float val)
```
    Factory method to convert from float (with inherent scale) to FixedBin
    
    Parameters:
    
    val - - float value to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(double val,
                               int digits,
                               int scale)
```
    Factory method to convert from double with specific precision and scale to FixedBin
    
    Parameters:
    
    val - - double to be used to set the value of the FixedBin
    
    digits - - the number of binary digits of precision
    
    scale - - the number of binary digits to the right of the decimal point
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(float val,
                               int digits,
                               int scale)
```
    Factory method to convert from float with specific precision and scale to FixedBin
    
    Parameters:
    
    val - - float to be used to set the value of the FixedBin
    
    digits - - the number of binary digits of precision
    
    scale - - the number of binary digits to the right of the decimal point
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(java.math.BigDecimal val)
```
    Factory method to convert from BigDecimal with specific precision and scale to FixedBin
    
    Parameters:
    
    val - - BigDecimal to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(java.math.BigDecimal val,
                               int digits,
                               int scale)
```
    Factory method to convert from BigDecimal with specific precision and scale to FixedBin
    
    Parameters:
    
    val - - BigDecimal to be used to set the value of the FixedBin
    
    digits - - the number of binary digits of precision
    
    scale - - the number of binary digits to the right of the decimal point
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(byte[] val)
```
    Factory method to convert from byte array with specific precision and scale to FixedBin
    
    Parameters:
    
    val - - byte array to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(byte[] val,
                               int digits,
                               int scale)
```
    Factory method to convert from byte array with specific precision and scale to FixedBin
    
    Parameters:
    
    val - - byte array to be used to set the value of the FixedBin
    
    digits - - the number of digits of precision
    
    scale - - the number of digits to the right of the decimal point
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(java.lang.String val,
                               int digits,
                               int scale)
```
    Factory method to convert from String with specific precision and scale to FixedBin
    
    Parameters:
    
    val - - string to be used to set the value of the FixedBin
    
    digits - - the number of digits of precision
    
    scale - - the number of digits to the right of the decimal point
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(java.lang.String val)
```
    Factory method to convert from String without specific precision and scale to FixedBin
    
    Parameters:
    
    val - - string to be used to set the value of the FixedBin
    
    Returns:
    
    a new FixedBin with the given value
  - valueOf
```
public static FixedBin valueOf(java.lang.Object val,
                               int... pq)
```
    Factory method to convert an arbitrary Object (instanceof one of the other valueOf() methods) to FixedBin
    
    Parameters:
    
    val - - string to be used to set the value of the FixedBin
    
    pq - - zero to 2 ints giving the precision and the scale, if provided
    
    Returns:
    
    a new FixedBin with the given value
  - digits
```
public int digits()
```
    Return the number of defined or adjusted by way of computations
    
    Returns:
    
    number of digits in this FixedBin (p in FIXED BIN(p,q))
  - precision
```
public int precision()
```
    Return the number of defined or adjusted by way of computations
    
    Returns:
    
    number of digits in this FixedBin (p in FIXED BIN(p,q))
  - scale
```
public int scale()
```
    Return the scale factor defined or adjusted by way of computations
    
    Returns:
    
    scale factor in this FixedBin (q in FIXED BIN(p,q))
  - longValue
```
public long longValue()
```
    Convert to long, truncating any digits to the right of the binary point
    
    Specified by:
    
    longValue in class java.lang.Number
    
    Returns:
    
    - the long value (with digits to the right of the binary point truncated)
  - longValueExact
```
public long longValueExact()
```
    Convert to long, truncating any digits to the right of the binary point and throwing exceptions if precision is lost
    
    Returns:
    
    - the long value (with digits to the right of the binary point truncated)
    
    Throws:
    
    -Condition.CONDITION.CONVERSION - if it can't be converted to a long
    
    -Condition.CONDITION.OVERFLOW - if it can't fit in a long
  - intValue
```
public int intValue()
```
    Convert to int, truncating any digits to the right of the binary point
    
    Specified by:
    
    intValue in class java.lang.Number
    
    Returns:
    
    - the int value (with digits to the right of the binary point truncated)
  - intValueExact
```
public int intValueExact()
```
    Convert to int, truncating any digits to the right of the binary point and throwing exceptions if precision is lost
    
    Returns:
    
    - the int value (with digits to the right of the binary point truncated)
    
    Throws:
    
    -Condition.CONDITION.CONVERSION - if it can't be converted to an int
    
    -Condition.CONDITION.OVERFLOW - if it can't fit in an int
  - shortValue
```
public short shortValue()
```
    Convert to short, truncating any digits to the right of the binary point
    
    Overrides:
    
    shortValue in class java.lang.Number
    
    Returns:
    
    - the short value (with digits to the right of the binary point truncated)
  - shortValueExact
```
public short shortValueExact()
```
    Convert to short, truncating any digits to the right of the binary point
    
    Returns:
    
    - the short value (with digits to the right of the binary point truncated)
    
    Throws:
    
    -Condition.CONDITION.CONVERSION - if it can't be converted to a short
    
    -Condition.CONDITION.OVERFLOW - if it can't fit in a short
  - byteValue
```
public byte byteValue()
```
    Convert to byte, truncating any digits to the right of the binary point
    
    Overrides:
    
    byteValue in class java.lang.Number
    
    Returns:
    
    - the byte value (with digits to the right of the binary point truncated)
  - byteValueExact
```
public byte byteValueExact()
```
    Convert to short, truncating any digits to the right of the binary point
    
    Returns:
    
    - the short value (with digits to the right of the binary point truncated)
    
    Throws:
    
    -Condition.CONDITION.CONVERSION - if it can't be converted to a byte
    
    -Condition.CONDITION.OVERFLOW - if it can't fit in a byte
  - bigIntegerValue
```
public java.math.BigInteger bigIntegerValue()
```
    bigIntegerValue() - return a big integer from a FixedBin number
    
    Returns:
    
    the value part as a big int
  - doubleValue
```
public double doubleValue()
```
    Convert to double
    
    Specified by:
    
    doubleValue in class java.lang.Number
    
    Returns:
    
    - the double representation; note that there is no doubleValueExact() for this interface even though we could have implemented one. therefore, a value resulting in Double.POSITIVE_INFINITY will not throw OVERFLOW Condition
  - floatValue
```
public float floatValue()
```
    Convert to float
    
    Specified by:
    
    floatValue in class java.lang.Number
    
    Returns:
    
    - the float representation
  - booleanValue
```
public boolean booleanValue()
```
    Convert to boolean
    
    Returns:
    
    - the boolean representation which is "false" for the value 0 and "true" otherwise
  - toString
```
public java.lang.String toString()
```
    Convert to String
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    - the string representation as a decimal value
  - toString
```
public java.lang.String toString(int radix)
```
    Convert to String with radix
    
    Parameters:
    
    radix - - the radix to convert to
    
    Returns:
    
    - the string representation as a decimal value
  - negate
```
public FixedBin negate()
```
    negate - negate a FixedBin number
    
    Returns:
    
    -this
  - add
```
public FixedBin add(FixedBin x)
```
    add - add two FixedBin numbers returning the result
    
    Parameters:
    
    x - the FixedBin to add to this
    
    Returns:
    
    the result
  - subtract
```
public FixedBin subtract(FixedBin x)
```
    subtract - subtract a FixedBin number from this one and return the result
    
    Parameters:
    
    x - the FixedBin to subtract to this
    
    Returns:
    
    the result
  - multiply
```
public FixedBin multiply(FixedBin x)
```
    multiply - multiply a FixedBin number by another and return the result
    
    Parameters:
    
    x - the FixedBin to multiply to this
    
    Returns:
    
    the result
  - divide
```
public FixedBin divide(FixedBin x)
```
    divide - divide a FixedBin number by another and return the result
    
    Parameters:
    
    x - the FixedBin to divide into this
    
    Returns:
    
    the result
  - compareTo
```
public int compareTo(FixedBin y)
```
    compareTo - compare two FixedBin values after adjusting to the higher precision and return he value 0 if this FixedBin is equal to the argument FixedBin; a value less than 0 if this FixedBin is numerically less than the argument FixedBin; and a value greater than 0 if this FixedBin is numerically greater than the argument FixedBin (signed comparison).
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<FixedBin>
    
    Parameters:
    
    y - the FixedBin to compare against to this
    
    Returns:
    
    -1 if this is < x, 0 if this is == x, 1 if this is > x
  - compare
```
public static int compare(FixedBin x,
                          FixedBin y)
```
    compare - static compare two FixedBin values
    
    Parameters:
    
    x - the FixedBin to compare against to this
    
    Returns:
    
    -1 if this is < x, 0 if this is == x, 1 if this is > x
  - equals
```
public boolean equals(java.lang.Object y)
```
    equals - Compares this object to the specified object. The result is true if and only if the argument is not null and is a FixedBin object that contains the same value as this object.
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    
    y - the FixedBin to compare against to this
    
    Returns:
    
    -1 if this is < x, 0 if this is == x, 1 if this is > x
  - size
```
public int size()
```
    size - return the size in bytes if this FixedBin were to be converted toBytes()
    
    Returns:
    
    the number of bytes this FixedBin would take in a byte[] array
  - toBytes
```
public byte[] toBytes()
```
    toBytes - generate a byte array of the internal data value of the variable of variable size, not including 0s or -1s indicating sign. result does not include all the info needed to reconstitute a FixedBin from this value, use digits() and scale() to get those criteria. use the static constructor FixedBin(byte[] data, int digits, int scale) to reconstruct
  - toByteArray
```
public byte[] toByteArray()
```
    toByteArray - synonym for toBytes()
    
    Returns:
    
    this FixedBin returned as a byte array
  - getSize
```
public int getSize()
```
    the size "if converted to an array of bytes" is calculated by converting it to bytes
    
    Returns:
    
    the int size of this FixedBin in bytes
  - fromBytes
```
public void fromBytes(byte[] bytes)
```
    fromBytes - convert a byte array (likely generated by toBytes()) back into a FixedBin
    
    Parameters:
    
    bytes - - the byte array to convert into this FixedBin
  - main
```
public static void main(java.lang.String[] args)
```
    main -- FixedBin unit test
    
    Parameters:
    
    args - - sequence of either decimal or binary numbers and operators, first determines the size 1011.011B + 1.5

Class FixedBin

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

ONE

TEN

Constructor Detail

FixedBin

FixedBin

FixedBin

FixedBin

FixedBin

FixedBin

FixedBin

FixedBin

FixedBin

FixedBin

FixedBin

FixedBin

Method Detail

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

digits

precision

scale

longValue

longValueExact

intValue

intValueExact

shortValue

shortValueExact

byteValue

byteValueExact

bigIntegerValue

doubleValue

floatValue

booleanValue

toString

toString

negate

add

subtract

multiply

divide

compareTo

compare

equals

size

toBytes

toByteArray

getSize

fromBytes

main