Decimal (QD Core API 3.342)

java.lang.Object
- java.lang.Number
- - com.devexperts.qd.util.Decimal

All Implemented Interfaces:

Serializable, Comparable
```
public class Decimal
extends Number
implements Comparable
```
The Decimal class contains a set of methods to work with floating-point numbers packed into int primitive type. Also, it can be used to wrap a single value in an object with interface like that of the Number class.
Unlike floating-point numbers represented by double and float primitive types, the Decimal uses exponent with base 10, allowing absolute precision for decimal fractions. It has the standard precision of 8 decimal digits and is able to represent numbers as large as 13,421,772,700,000,000 by absolute value or as precise as 0.000,001 (if precision permits). It uses variable of type int for representation, which is divided into two parts as follows:
- The lowest 4 bits are used to represent power of the exponent. The exact multipliers are (in order): Infinity (see "extra precision formats and special cases" below), 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1, 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001.
- The highest 28 bits are used to represent mantissa in a two's complement format. The mantissa may be from -134217727 to +134217727 (the possible value of -134217728 is not used because it does not have corresponding positive value).
To calculate described parts and the real value one may use following code: int mantissa = decimal >> 4; int power = decimal & 0x0F; double real_value = (double) mantissa * MULTIPLIERS[power];
The real formula in toDouble method is more complex, because it guarantees that the resulting double is the value closest to the true decimal number and it also supports extra precision formats.
All numbers have single canonical representation in this format which is defined as a number with smallest possible power without loss of precision. The Decimal supports Not-a-Number and Infinities in the same way as standard floating-point numbers do; these numbers also have appropriate canonical representations - see corresponding constants.
The Decimal format is so designed that canonical representation of Not-a-Number is numerical value of zero. Thus uninitialized fields with default numerical value of zero will be properly treated as Not-a-Numbers.
Extra precision formats and special cases
Zero in the lowest 4 bits indicates a special case, which includes NaN values, infinities, and extra precision formats. The interpretation of the number depends on the value of the lowest 7 bits. The highest 25 bits represent mantissa for extra precision formats.
- 0x00 - Not-a-Number (must have canonical representation).
- 0x10 - Positive Infinity (must have canonical representation).
- 0x20 - Extra precision with multiplier of 0.0000001 (1/10^7).
- 0x30 - Extra precision with multiplier of 0.00000001 (1/10^8).
- 0x40 - Reserved.
- 0x50 - Reserved.
- 0x60 - Extra precision with multiplier of 0.0078125 (1/128).
- 0x70 - Negative Infinity (must have canonical representation).
See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`decimal`
`static int`	`MAX_VALUE`
`static int`	`MIN_VALUE`
`static int`	`NaN`
`static String`	`NAN_STRING`
`static int`	`NEGATIVE_INFINITY`
`static String`	`NEGATIVE_INFINITY_STRING`
`static int`	`POSITIVE_INFINITY`
`static String`	`POSITIVE_INFINITY_STRING`
`static int`	`ZERO`

Constructor Summary

Constructors
Constructor and Description

Decimal(int decimal)

Decimal(String s)

Constructors
Constructor and Description
`Decimal(int decimal)`
`Decimal(String s)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`abs(int decimal)`
`static int`	`add(int d1, int d2)` Adds two specified decimals and returns result as decimal.
`static StringBuilder`	`appendTo(StringBuilder sb, int decimal)`
`static int`	`average(int d1, int d2)` Averages two specified decimals and returns result as decimal.
`byte`	`byteValue()`
`static int`	`compare(int d1, int d2)` Compares two specified decimals for order.
`int`	`compareTo(Object obj)`
`static int`	`compose(double value)` Returns decimal value for the corresponding `double`.
`static int`	`composeDecimal(long mantissa, int precision)` Returns decimal value that corresponds to `mantissa / 10^precision`.
`double`	`doubleValue()`
`boolean`	`equals(Object obj)`
`float`	`floatValue()`
`static long`	`getDecimalMantissa(int decimal)` Returns decimal mantissa of the decimal number.
`static int`	`getDecimalPrecision(int decimal)` Returns decimal precision of the decimal number.
`int`	`hashCode()`
`int`	`intValue()`
`static boolean`	`isInfinite(int decimal)`
`static boolean`	`isNaN(int decimal)`
`long`	`longValue()`
`static int`	`neg(int decimal)`
`static int`	`parseDecimal(char[] chars, int offset, int count)` The same as `parseDecimal(String)` but works directly with array of characters.
`static int`	`parseDecimal(String s)` Parses string into a packed decimal integer.
`short`	`shortValue()`
`static int`	`sign(int decimal)`
`static int`	`subtract(int d1, int d2)` Subtracts the second specified decimal from the first specified decimal and returns result as decimal.
`static long`	`tinyToWide(int tiny)`
`static double`	`toDouble(int decimal)` Returns `double` value of the corresponding decimal.
`String`	`toString()`
`static String`	`toString(int decimal)`
`static int`	`wideToTiny(long wide)`

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

- Field Detail
  - NaN
```
public static final int NaN
```
    See Also:
    
    Constant Field Values
  - POSITIVE_INFINITY
```
public static final int POSITIVE_INFINITY
```
    See Also:
    
    Constant Field Values
  - NEGATIVE_INFINITY
```
public static final int NEGATIVE_INFINITY
```
    See Also:
    
    Constant Field Values
  - ZERO
```
public static final int ZERO
```
    See Also:
    
    Constant Field Values
  - MAX_VALUE
```
public static final int MAX_VALUE
```
    See Also:
    
    Constant Field Values
  - MIN_VALUE
```
public static final int MIN_VALUE
```
    See Also:
    
    Constant Field Values
  - NAN_STRING
```
public static final String NAN_STRING
```
    See Also:
    
    Constant Field Values
  - POSITIVE_INFINITY_STRING
```
public static final String POSITIVE_INFINITY_STRING
```
    See Also:
    
    Constant Field Values
  - NEGATIVE_INFINITY_STRING
```
public static final String NEGATIVE_INFINITY_STRING
```
    See Also:
    
    Constant Field Values
  - decimal
```
protected final int decimal
```
- Constructor Detail
  - Decimal
```
public Decimal(int decimal)
```
  - Decimal
```
public Decimal(String s)
        throws NumberFormatException
```
    Throws:
    
    NumberFormatException
- Method Detail
  - isNaN
```
public static boolean isNaN(int decimal)
```
  - isInfinite
```
public static boolean isInfinite(int decimal)
```
  - sign
```
public static int sign(int decimal)
```
  - neg
```
public static int neg(int decimal)
```
  - abs
```
public static int abs(int decimal)
```
  - toDouble
```
public static double toDouble(int decimal)
```
    Returns double value of the corresponding decimal. The result is the double value closest to the true decimal number.
  - getDecimalMantissa
```
public static long getDecimalMantissa(int decimal)
```
    Returns decimal mantissa of the decimal number.
    
    See Also:
    
    composeDecimal(long, int)
  - getDecimalPrecision
```
public static int getDecimalPrecision(int decimal)
```
    Returns decimal precision of the decimal number.
    
    See Also:
    
    composeDecimal(long, int)
  - composeDecimal
```
public static int composeDecimal(long mantissa,
                                 int precision)
```
    Returns decimal value that corresponds to mantissa / 10^precision. The result is positive or negative infinity if the value is too large by absolute value to represent. The result is zero if value is too small to represent with extra precision format of decimal.
    Precision equal or smaller than -19 is considered to produce infinitely large multiplier, thus composeDecimal(0, -19) returns NaN.
    This method always returns decimal in a standard precision format if it can represent the value exactly. Extra precision is used only if the standard one does not have enough precision.
    Mantissa and precision of the decimal number can be retrieved with getDecimalMantissa(int) and getDecimalPrecision(int) methods. Generally, for well-formed decimal number:
```
composeDecimal(getDecimalMantissa(decimal), getDecimalPrecision(decimal)) == decimal
```
  - compose
```
public static int compose(double value)
```
    Returns decimal value for the corresponding double. The result is NaN if the value is not-a-number. The result is positive or negative infinity if the value is too large by absolute value to represent. The result is ZERO if value is too small to represent with extra precision format of decimal.
    This method always returns decimal in a standard precision format if it can represent the value exactly. Extra precision is used only if the standard one does not have enough precision.
  - parseDecimal
```
public static int parseDecimal(String s)
                        throws NumberFormatException
```
    Parses string into a packed decimal integer. It supports standard floating point representation and can parse any string that was produced by toString(int).
    - NaN
    - Infinity
    - -Infinity
    - [+|-][0-9]+
    - [+|-].[0-9]+
    - [+|-][0-9]+.[0-9]+
    This method shall support everything that Double.parseDouble(java.lang.String) supports with the exception of hexadecimal floating point notation and "f|d" suffixes, but currently there are certain other limitations:
    todo: support "e" notation, so that any string produced by Double.toString(double) can be parsed.
    
    Note:Use parseDecimal(char[],int,int) if you are parsing buffer of incoming characters and you want to avoid creation of new string objects.
    Throws:
    
    NumberFormatException
  - parseDecimal
```
public static int parseDecimal(char[] chars,
                               int offset,
                               int count)
                        throws NumberFormatException
```
    The same as parseDecimal(String) but works directly with array of characters.
    
    Parameters:
    
    chars - the character array.
    
    offset - the initial offset into the chars.
    
    count - the number of chars to parse.
    
    Throws:
    
    NumberFormatException
  - toString
```
public static String toString(int decimal)
```
  - appendTo
```
public static StringBuilder appendTo(StringBuilder sb,
                                     int decimal)
```
  - compare
```
public static int compare(int d1,
                          int d2)
```
    Compares two specified decimals for order. Returns a negative integer, zero, or positive integer as the first decimal is less than, equal to, or greater than the second decimal.
    Note: this method treats NaN as a largest value (even larger than POSITIVE_INFINITY) that is equal to itself.
  - subtract
```
public static int subtract(int d1,
                           int d2)
```
    Subtracts the second specified decimal from the first specified decimal and returns result as decimal.
  - add
```
public static int add(int d1,
                      int d2)
```
    Adds two specified decimals and returns result as decimal.
  - average
```
public static int average(int d1,
                          int d2)
```
    Averages two specified decimals and returns result as decimal.
  - wideToTiny
```
public static int wideToTiny(long wide)
```
  - tinyToWide
```
public static long tinyToWide(int tiny)
```
  - byteValue
```
public byte byteValue()
```
    Overrides:
    
    byteValue in class Number
  - shortValue
```
public short shortValue()
```
    Overrides:
    
    shortValue in class Number
  - intValue
```
public int intValue()
```
    Specified by:
    
    intValue in class Number
  - longValue
```
public long longValue()
```
    Specified by:
    
    longValue in class Number
  - floatValue
```
public float floatValue()
```
    Specified by:
    
    floatValue in class Number
  - doubleValue
```
public double doubleValue()
```
    Specified by:
    
    doubleValue in class Number
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - compareTo
```
public int compareTo(Object obj)
```
    Specified by:
    
    compareTo in interface Comparable

Class Decimal

Extra precision formats and special cases

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NaN

POSITIVE_INFINITY

NEGATIVE_INFINITY

ZERO

MAX_VALUE

MIN_VALUE

NAN_STRING

POSITIVE_INFINITY_STRING

NEGATIVE_INFINITY_STRING

decimal

Constructor Detail

Decimal

Decimal

Method Detail

isNaN

isInfinite

sign

neg

abs

toDouble

getDecimalMantissa

getDecimalPrecision

composeDecimal

compose

parseDecimal

parseDecimal

toString

appendTo

compare

subtract

add

average

wideToTiny

tinyToWide

byteValue

shortValue

intValue

longValue

floatValue

doubleValue

toString

hashCode

equals

compareTo