Decimal128 (Hive 1.2.2 API)

java.lang.Object
- java.lang.Number
- - org.apache.hadoop.hive.common.type.Decimal128

All Implemented Interfaces:

Serializable, Comparable<Decimal128>
```
public final class Decimal128
extends Number
implements Comparable<Decimal128>
```
This code was based on code from Microsoft's PolyBase.
A 128-bit fixed-length Decimal value in the ANSI SQL Numeric semantics, representing unscaledValue / 10**scale where scale is 0 or positive.

This class is similar to BigDecimal, but a few things differ to conform to the SQL Numeric semantics.

Scale of this object is specified by the user, not automatically determined like BigDecimal. This means that underflow is possible depending on the scale. BigDecimal controls rounding behaviors by MathContext, possibly throwing errors. But, underflow is NOT an error in ANSI SQL Numeric. "CAST(0.000000000....0001 AS DECIMAL(38,1))" is "0.0" without an error.

Because this object is fixed-length, overflow is also possible. Overflow IS an error in ANSI SQL Numeric. "CAST(10000 AS DECIMAL(38,38))" throws overflow error.

Each arithmetic operator takes scale as a parameter to control its behavior. It's user's (or query optimizer's) responsibility to give an appropriate scale parameter.

Finally, this class performs MUCH faster than java.math.BigDecimal for a few reasons. Its behavior is simple because of the designs above. This class is fixed-length without array expansion and re-allocation. This class is mutable, allowing reuse of the same object without re-allocation. This class and UnsignedInt128 are designed such that minimal heap-object allocations are required for most operations. The only exception is division. Even this class requires a few object allocations for division, though much fewer than BigDecimal.

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static short`	`MAX_SCALE` Maximum value for #scale.
`static Decimal128`	`MAX_VALUE` Maximum value that can be represented in this class.
`static short`	`MIN_SCALE` Minimum value for #scale.
`static Decimal128`	`MIN_VALUE` Minimum value that can be represented in this class.
`static Decimal128`	`ONE`

Constructor Summary

Constructors
Constructor and Description
`Decimal128()` Construct a zero.
`Decimal128(char[] str, int offset, int length, short scale)` Constructs from the given string with given offset and length.
`Decimal128(Decimal128 o)` Copy constructor.
`Decimal128(double val, short scale)` Translates a `double` into a `Decimal128` in the given scaling.
`Decimal128(long val)` Translates a `long` into a `Decimal128`.
`Decimal128(long val, short scale)` Translates a `long` into a `Decimal128` with the given scaling.
`Decimal128(String str, short scale)` Constructs from the given string.
`Decimal128(UnsignedInt128 unscaledVal, short scale, boolean negative)` Translates a `UnsignedInt128` unscaled value, an `int` scale, and sign flag into a `Decimal128` .

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`absDestructive()` Makes this `Decimal128` a positive number.
`static void`	`add(Decimal128 left, Decimal128 right, Decimal128 result, short scale)` Calculates addition and puts the result into the given object.
`Decimal128`	`addDestructive(Decimal128 right, short scale)` Calculates addition and stores the result into this object.
`void`	`changeScaleDestructive(short scale)` Changes the scaling of this `Decimal128`, preserving the represented value.
`void`	`checkPrecisionOverflow(int precision)` Throws an exception if the value of this object exceeds the maximum value for the given precision.
`int`	`compareTo(Decimal128 val)` Compares this `Decimal128` with the specified `Decimal128`.
`static void`	`divide(Decimal128 left, Decimal128 right, Decimal128 quotient, short scale)` Performs division and puts the result into the given object.
`void`	`divideDestructive(Decimal128 right, short newScale)` Divide the target object by right, and scale the result to newScale.
`void`	`divideDestructiveNativeDecimal128(Decimal128 right, short newScale, Decimal128 remainder)` As of 1/20/2014 this has a known bug in division.
`double`	`doubleValue()` Converts this `Decimal128` to a `double`.
`boolean`	`equals(Object x)` Compares this `Decimal128` with the specified `Object` for equality.
`int`	`fastSerializeForHiveDecimal(Decimal128FastBuffer scratch)` Serializes the value in a format compatible with the BigDecimal's own representation
`Decimal128`	`fastUpdateFromInternalStorage(byte[] internalStorage, short scale)` Fats update from BigInteger two's complement representation
`float`	`floatValue()` Converts this `Decimal128` to a `float`.
`String`	`getHiveDecimalString()` Returns the string representation of this value.
`static int`	`getIntsPerElement(int precision)` Determines the number of ints to store one value.
`short`	`getScale()` Returns the scale of this `Decimal128`.
`byte`	`getSignum()` Returns the signum of this `Decimal128`.
`UnsignedInt128`	`getUnscaledValue()` Returns unscaled value of this `Decimal128`.
`int`	`hashCode()` Returns the hash code for this `Decimal128`.
`int`	`intValue()` Converts this `Decimal128` to an `int`.
`boolean`	`isZero()`
`long`	`longValue()` Converts this `Decimal128` to a `long`.
`static void`	`modulo(Decimal128 left, Decimal128 right, Decimal128 result, short scale)` Performs decimal modulo
`static void`	`multiply(Decimal128 left, Decimal128 right, Decimal128 result, short scale)` Calculates multiplication and puts the result into the given object.
`void`	`multiplyDestructive(Decimal128 right, short newScale)` Performs multiplication, changing the scale of this object to the specified value.
`void`	`multiplyDestructiveNativeDecimal128(Decimal128 right, short newScale)` As of 2/11/2014 this has a known bug in multiplication.
`void`	`negateDestructive()` Reverses the sign of this `Decimal128`.
`double`	`powAsDouble(double n)` Calculate the power of this value in double precision.
`void`	`serializeTo(int[] array, int offset, int precision)` Serialize this object to the given array, putting the required number of ints for the given precision.
`void`	`serializeTo(IntBuffer buf, int precision)` Serialize this object to the given ByteBuffer, putting the required number of ints for the given precision.
`void`	`serializeTo128(int[] array, int offset)` Serialize this object to the given integers, putting 128+32 bits of data (full range).
`void`	`serializeTo128(IntBuffer buf)` Serialize this object to the given ByteBuffer, putting 128+32 bits of data (full range).
`void`	`serializeTo32(int[] array, int offset)` Serialize this object to the given integers, putting only 32+32 bits of data.
`void`	`serializeTo32(IntBuffer buf)` Serialize this object to the given ByteBuffer, putting only 32+32 bits of data.
`void`	`serializeTo64(int[] array, int offset)` Serialize this object to the given integers, putting only 64+32 bits of data.
`void`	`serializeTo64(IntBuffer buf)` Serialize this object to the given ByteBuffer, putting only 64+32 bits of data.
`void`	`serializeTo96(int[] array, int offset)` Serialize this object to the given integers, putting only 96+32 bits of data.
`void`	`serializeTo96(IntBuffer buf)` Serialize this object to the given ByteBuffer, putting only 96+32 bits of data.
`void`	`setNullDataValue()` Vectorized execution uses the smallest possible positive non-zero value to prevent possible later zero-divide exceptions.
`void`	`setScale(short scale)` This setter is only for de-serialization, should not be used otherwise.
`void`	`setSignum(byte signum)` This setter is only for de-serialization, should not be used otherwise.
`void`	`setUnscaledValue(UnsignedInt128 unscaledValue)` This setter is only for de-serialization, should not be used otherwise.
`double`	`sqrtAsDouble()` Calculate the square root of this value in double precision.
`Decimal128`	`squareDestructive()` Multiplies this with this, updating this
`static void`	`subtract(Decimal128 left, Decimal128 right, Decimal128 result, short scale)` Calculates subtraction and puts the result into the given object.
`Decimal128`	`subtractDestructive(Decimal128 right, short scale)` Calculates subtraction and stores the result into this object.
`BigDecimal`	`toBigDecimal()` Converts this object to `BigDecimal`.
`String`	`toFormalString()` Returns the formal string representation of this value.
`String`	`toString()`
`Decimal128`	`update(BigDecimal bigDecimal)` Updates the value of this object with the given `BigDecimal`.
`Decimal128`	`update(BigInteger bigInt, short scale)` Updates the value of this object with the given `BigInteger` and scale.
`Decimal128`	`update(char[] str, int offset, int length, short scale)` Updates the value of this object from the given string with given offset and length.
`Decimal128`	`update(Decimal128 o)` Copy the value of given object.
`Decimal128`	`update(Decimal128 o, short scale)` Copy the value of given object and assigns a custom scale.
`Decimal128`	`update(double val, short scale)` Update the value of this object with the given `double`.
`Decimal128`	`update(int[] array, int offset, int precision)` Updates the value of this object by reading from the given array, using the required number of ints for the given precision.
`Decimal128`	`update(IntBuffer buf, int precision)` Updates the value of this object by reading from ByteBuffer, using the required number of ints for the given precision.
`Decimal128`	`update(long val)` Update the value of this object with the given `long`.
`Decimal128`	`update(long val, short scale)` Update the value of this object with the given `long` with the given scal.
`Decimal128`	`update(String str, short scale)` Updates the value of this object with the given string.
`Decimal128`	`update128(int[] array, int offset)` Updates the value of this object by reading from the given integers, receiving 128+32 bits of data (full range).
`Decimal128`	`update128(IntBuffer buf)` Updates the value of this object by reading from ByteBuffer, receiving 128+32 bits data (full ranges).
`Decimal128`	`update32(int[] array, int offset)` Updates the value of this object by reading from the given integers, receiving only 32+32 bits data.
`Decimal128`	`update32(IntBuffer buf)` Updates the value of this object by reading from ByteBuffer, receiving only 32+32 bits data.
`Decimal128`	`update64(int[] array, int offset)` Updates the value of this object by reading from the given integers, receiving only 64+32 bits data.
`Decimal128`	`update64(IntBuffer buf)` Updates the value of this object by reading from ByteBuffer, receiving only 64+32 bits data.
`Decimal128`	`update96(int[] array, int offset)` Updates the value of this object by reading from the given integers, receiving only 96+32 bits data.
`Decimal128`	`update96(IntBuffer buf)` Updates the value of this object by reading from ByteBuffer, receiving only 96+32 bits data.
`void`	`updateFixedPoint(long val, short scale)` Update the value to a decimal value with the decimal point equal to val but with the decimal point inserted scale digits from the right.
`Decimal128`	`updateVarianceDestructive(Decimal128 scratch, Decimal128 value, Decimal128 sum, long count)` For UDAF variance we use the algorithm described by Chan, Golub, and LeVeque in "Algorithms for computing the sample variance: analysis and recommendations" The American Statistician, 37 (1983) pp.
`Decimal128`	`zeroClear()` Reset the value of this object to zero.
`void`	`zeroFractionPart()`
`void`	`zeroFractionPart(UnsignedInt128 scratch)` Zero the fractional part of value.

Methods inherited from class java.lang.Number
byteValue, shortValue

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

- Field Detail
  - MAX_SCALE
```
public static final short MAX_SCALE
```
    Maximum value for #scale.
    
    See Also:
    Constant Field Values
  - MIN_SCALE
```
public static final short MIN_SCALE
```
    Minimum value for #scale.
    
    See Also:
    Constant Field Values
  - ONE
```
public static final Decimal128 ONE
```
  - MAX_VALUE
```
public static final Decimal128 MAX_VALUE
```
    Maximum value that can be represented in this class.
  - MIN_VALUE
```
public static final Decimal128 MIN_VALUE
```
    Minimum value that can be represented in this class.
- Constructor Detail
  - Decimal128
```
public Decimal128()
```
    Construct a zero.
  - Decimal128
```
public Decimal128(Decimal128 o)
```
    Copy constructor.
    
    Parameters:
    o - object to copy from
  - Decimal128
```
public Decimal128(double val,
          short scale)
```
    Translates a double into a Decimal128 in the given scaling. Note that, unlike java.math.BigDecimal, the scaling is given as the parameter, not automatically detected. This is one of the differences between ANSI SQL Numeric and Java's BigDecimal. See class comments for more details.
    Unchecked exceptions: ArithmeticException if val overflows in the scaling. NumberFormatException if val is infinite or NaN.
    
    Parameters:
    val - double value to be converted to Decimal128.
    scale - scale of the Decimal128.
  - Decimal128
```
public Decimal128(UnsignedInt128 unscaledVal,
          short scale,
          boolean negative)
```
    Translates a UnsignedInt128 unscaled value, an int scale, and sign flag into a Decimal128 . The value of the Decimal128 is (unscaledVal × 10^-scale).
    
    Parameters:
    unscaledVal - unscaled value of the Decimal128.
    scale - scale of the Decimal128.
    negative - whether the value is negative
  - Decimal128
```
public Decimal128(long val)
```
    Translates a long into a Decimal128. The scale of the Decimal128 is zero.
    
    Parameters:
    val - long value to be converted to Decimal128.
  - Decimal128
```
public Decimal128(long val,
          short scale)
```
    Translates a long into a Decimal128 with the given scaling.
    
    Parameters:
    val - long value to be converted to Decimal128.
    scale - scale of the Decimal128.
  - Decimal128
```
public Decimal128(String str,
          short scale)
```
    Constructs from the given string.
    
    Parameters:
    str - string
    scale - scale of the Decimal128.
  - Decimal128
```
public Decimal128(char[] str,
          int offset,
          int length,
          short scale)
```
    Constructs from the given string with given offset and length.
    
    Parameters:
    str - string
    offset - offset
    length - length
    scale - scale of the Decimal128.
- Method Detail
  - getIntsPerElement
```
public static int getIntsPerElement(int precision)
```
    Determines the number of ints to store one value.
    
    Parameters:
    precision - precision (0-38)
    
    Returns:
    the number of ints to store one value
  - zeroClear
```
public Decimal128 zeroClear()
```
    Reset the value of this object to zero.
  - isZero
```
public boolean isZero()
```
    Returns:
    whether this value represents zero.
  - update
```
public Decimal128 update(Decimal128 o)
```
    Copy the value of given object.
    
    Parameters:
    o - object to copy from
  - update
```
public Decimal128 update(Decimal128 o,
                short scale)
```
    Copy the value of given object and assigns a custom scale.
    
    Parameters:
    o - object to copy from
  - update
```
public Decimal128 update(long val)
```
    Update the value of this object with the given long. The scale of the Decimal128 is zero.
    
    Parameters:
    val - long value to be set to Decimal128.
  - update
```
public Decimal128 update(long val,
                short scale)
```
    Update the value of this object with the given long with the given scal.
    
    Parameters:
    val - long value to be set to Decimal128.
    scale - scale of the Decimal128.
  - update
```
public Decimal128 update(double val,
                short scale)
```
    Update the value of this object with the given double. in the given scaling. Note that, unlike java.math.BigDecimal, the scaling is given as the parameter, not automatically detected. This is one of the differences between ANSI SQL Numeric and Java's BigDecimal. See class comments for more details.
    Unchecked exceptions: ArithmeticException if val overflows in the scaling. NumberFormatException if val is infinite or NaN.
    
    Parameters:
    val - double value to be converted to Decimal128.
    scale - scale of the Decimal128.
  - update
```
public Decimal128 update(IntBuffer buf,
                int precision)
```
    Updates the value of this object by reading from ByteBuffer, using the required number of ints for the given precision.
    
    Parameters:
    buf - ByteBuffer to read values from
    precision - 0 to 38. Decimal digits.
  - update128
```
public Decimal128 update128(IntBuffer buf)
```
    Updates the value of this object by reading from ByteBuffer, receiving 128+32 bits data (full ranges).
    
    Parameters:
    buf - ByteBuffer to read values from
  - update96
```
public Decimal128 update96(IntBuffer buf)
```
    Updates the value of this object by reading from ByteBuffer, receiving only 96+32 bits data.
    
    Parameters:
    buf - ByteBuffer to read values from
  - update64
```
public Decimal128 update64(IntBuffer buf)
```
    Updates the value of this object by reading from ByteBuffer, receiving only 64+32 bits data.
    
    Parameters:
    buf - ByteBuffer to read values from
  - update32
```
public Decimal128 update32(IntBuffer buf)
```
    Updates the value of this object by reading from ByteBuffer, receiving only 32+32 bits data.
    
    Parameters:
    buf - ByteBuffer to read values from
  - update
```
public Decimal128 update(int[] array,
                int offset,
                int precision)
```
    Updates the value of this object by reading from the given array, using the required number of ints for the given precision.
    
    Parameters:
    array - array to read values from
    offset - offset of the long array
    precision - 0 to 38. Decimal digits.
  - update128
```
public Decimal128 update128(int[] array,
                   int offset)
```
    Updates the value of this object by reading from the given integers, receiving 128+32 bits of data (full range).
    
    Parameters:
    array - array to read from
    offset - offset of the int array
  - update96
```
public Decimal128 update96(int[] array,
                  int offset)
```
    Updates the value of this object by reading from the given integers, receiving only 96+32 bits data.
    
    Parameters:
    array - array to read from
    offset - offset of the int array
  - update64
```
public Decimal128 update64(int[] array,
                  int offset)
```
    Updates the value of this object by reading from the given integers, receiving only 64+32 bits data.
    
    Parameters:
    array - array to read from
    offset - offset of the int array
  - update32
```
public Decimal128 update32(int[] array,
                  int offset)
```
    Updates the value of this object by reading from the given integers, receiving only 32+32 bits data.
    
    Parameters:
    array - array to read from
    offset - offset of the int array
  - update
```
public Decimal128 update(BigDecimal bigDecimal)
```
    Updates the value of this object with the given BigDecimal.
    
    Parameters:
    bigDecimal - BigDecimal
  - update
```
public Decimal128 update(BigInteger bigInt,
                short scale)
```
    Updates the value of this object with the given BigInteger and scale.
    
    Parameters:
    bigInt - BigInteger
    scale -
  - update
```
public Decimal128 update(String str,
                short scale)
```
    Updates the value of this object with the given string.
    
    Parameters:
    str - string
    scale - scale of the Decimal128.
  - update
```
public Decimal128 update(char[] str,
                int offset,
                int length,
                short scale)
```
    Updates the value of this object from the given string with given offset and length.
    
    Parameters:
    str - string
    offset - offset
    length - length
    scale - scale of the Decimal128.
  - fastSerializeForHiveDecimal
```
public int fastSerializeForHiveDecimal(Decimal128FastBuffer scratch)
```
    Serializes the value in a format compatible with the BigDecimal's own representation
    
    Parameters:
    scratch -
  - serializeTo
```
public void serializeTo(int[] array,
               int offset,
               int precision)
```
    Serialize this object to the given array, putting the required number of ints for the given precision.
    
    Parameters:
    array - array to write values to
    offset - offset of the int array
    precision - 0 to 38. Decimal digits.
  - serializeTo128
```
public void serializeTo128(int[] array,
                  int offset)
```
    Serialize this object to the given integers, putting 128+32 bits of data (full range).
    
    Parameters:
    array - array to write values to
    offset - offset of the int array
  - serializeTo96
```
public void serializeTo96(int[] array,
                 int offset)
```
    Serialize this object to the given integers, putting only 96+32 bits of data.
    
    Parameters:
    array - array to write values to
    offset - offset of the int array
  - serializeTo64
```
public void serializeTo64(int[] array,
                 int offset)
```
    Serialize this object to the given integers, putting only 64+32 bits of data.
    
    Parameters:
    array - array to write values to
    offset - offset of the int array
  - serializeTo32
```
public void serializeTo32(int[] array,
                 int offset)
```
    Serialize this object to the given integers, putting only 32+32 bits of data.
    
    Parameters:
    array - array to write values to
    offset - offset of the int array
  - serializeTo
```
public void serializeTo(IntBuffer buf,
               int precision)
```
    Serialize this object to the given ByteBuffer, putting the required number of ints for the given precision.
    
    Parameters:
    buf - ByteBuffer to write values to
    precision - 0 to 38. Decimal digits.
  - serializeTo128
```
public void serializeTo128(IntBuffer buf)
```
    Serialize this object to the given ByteBuffer, putting 128+32 bits of data (full range).
    
    Parameters:
    buf - ByteBuffer to write values to
  - serializeTo96
```
public void serializeTo96(IntBuffer buf)
```
    Serialize this object to the given ByteBuffer, putting only 96+32 bits of data.
    
    Parameters:
    buf - ByteBuffer to write values to
  - serializeTo64
```
public void serializeTo64(IntBuffer buf)
```
    Serialize this object to the given ByteBuffer, putting only 64+32 bits of data.
    
    Parameters:
    buf - ByteBuffer to write values to
  - serializeTo32
```
public void serializeTo32(IntBuffer buf)
```
    Serialize this object to the given ByteBuffer, putting only 32+32 bits of data.
    
    Parameters:
    buf - ByteBuffer to write values to
  - changeScaleDestructive
```
public void changeScaleDestructive(short scale)
```
    Changes the scaling of this Decimal128, preserving the represented value. This method is destructive.
    This method is NOT just a setter for #scale. It also adjusts the unscaled value to preserve the represented value.
    
    When the given scaling is larger than the current scaling, this method shrinks the unscaled value accordingly. It will NOT throw any error even if underflow happens.
    
    When the given scaling is smaller than the current scaling, this method expands the unscaled value accordingly. It does throw an error if overflow happens.
    
    Unchecked exceptions: ArithmeticException a negative value is specified or overflow.
    
    Parameters:
    scale - new scale. must be 0 or positive.
  - add
```
public static void add(Decimal128 left,
       Decimal128 right,
       Decimal128 result,
       short scale)
```
    Calculates addition and puts the result into the given object. Both operands are first scaled up/down to the specified scale, then this method performs the operation. This method is static and not destructive (except the result object).
    Unchecked exceptions: ArithmeticException an invalid scale is specified or overflow.
    
    Parameters:
    left - left operand
    right - right operand
    scale - scale of the result. must be 0 or positive.
    result - object to receive the calculation result
  - addDestructive
```
public Decimal128 addDestructive(Decimal128 right,
                        short scale)
```
    Calculates addition and stores the result into this object. This method is destructive.
    Unchecked exceptions: ArithmeticException an invalid scale is specified or overflow.
    
    Parameters:
    right - right operand
    scale - scale of the result. must be 0 or positive.
  - subtract
```
public static void subtract(Decimal128 left,
            Decimal128 right,
            Decimal128 result,
            short scale)
```
    Calculates subtraction and puts the result into the given object. Both operands are first scaled up/down to the specified scale, then this method performs the operation. This method is static and not destructive (except the result object).
    Unchecked exceptions: ArithmeticException an invalid scale is specified or overflow.
    
    Parameters:
    left - left operand
    right - right operand
    result - object to receive the calculation result
    scale - scale of the result. must be 0 or positive.
  - subtractDestructive
```
public Decimal128 subtractDestructive(Decimal128 right,
                             short scale)
```
    Calculates subtraction and stores the result into this object. This method is destructive.
    Unchecked exceptions: ArithmeticException an invalid scale is specified or overflow.
    
    Parameters:
    right - right operand
    scale - scale of the result. must be 0 or positive.
  - multiply
```
public static void multiply(Decimal128 left,
            Decimal128 right,
            Decimal128 result,
            short scale)
```
    Calculates multiplication and puts the result into the given object. Both operands are first scaled up/down to the specified scale, then this method performs the operation. This method is static and not destructive (except the result object).
    Unchecked exceptions: ArithmeticException an invalid scale is specified or overflow.
    
    Parameters:
    left - left operand
    right - right operand
    result - object to receive the calculation result
    scale - scale of the result. must be 0 or positive.
  - multiplyDestructiveNativeDecimal128
```
public void multiplyDestructiveNativeDecimal128(Decimal128 right,
                                       short newScale)
```
    As of 2/11/2014 this has a known bug in multiplication. See TestDecimal128.testKnownPriorErrors(). Keeping this source code available since eventually it is better to fix this. The fix employed now is to replace this code with code that uses Java BigDecimal multiply. Performs multiplication, changing the scale of this object to the specified value.
    
    Parameters:
    right - right operand. this object is not modified.
    newScale - scale of the result. must be 0 or positive.
  - multiplyDestructive
```
public void multiplyDestructive(Decimal128 right,
                       short newScale)
```
    Performs multiplication, changing the scale of this object to the specified value.
    
    Parameters:
    right - right operand. this object is not modified.
    newScale - scale of the result. must be 0 or positive.
  - divide
```
public static void divide(Decimal128 left,
          Decimal128 right,
          Decimal128 quotient,
          short scale)
```
    Performs division and puts the result into the given object. Both operands are first scaled up/down to the specified scale, then this method performs the operation. This method is static and not destructive (except the result object).
    Unchecked exceptions: ArithmeticException an invalid scale is specified or overflow.
    
    Parameters:
    left - left operand
    right - right operand
    quotient - result object to receive the calculation result
    scale - scale of the result. must be 0 or positive.
  - divideDestructiveNativeDecimal128
```
public void divideDestructiveNativeDecimal128(Decimal128 right,
                                     short newScale,
                                     Decimal128 remainder)
```
    As of 1/20/2014 this has a known bug in division. See TestDecimal128.testKnownPriorErrors(). Keeping this source code available since eventually it is better to fix this. The fix employed now is to replace this code with code that uses Java BigDecimal divide. Performs division, changing the scale of this object to the specified value.
    Unchecked exceptions: ArithmeticException an invalid scale is specified or overflow.
    
    Parameters:
    right - right operand. this object is not modified.
    newScale - scale of the result. must be 0 or positive.
    remainder - object to receive remainder
  - divideDestructive
```
public void divideDestructive(Decimal128 right,
                     short newScale)
```
    Divide the target object by right, and scale the result to newScale. This uses HiveDecimal to get a correct answer with the same rounding behavior as HiveDecimal, but it is expensive. In the future, a native implementation could be faster.
  - modulo
```
public static void modulo(Decimal128 left,
          Decimal128 right,
          Decimal128 result,
          short scale)
```
    Performs decimal modulo
    The definition of modulo (x % p) is: x - IntegerPart(x / p, resultScale) * p
  - absDestructive
```
public void absDestructive()
```
    Makes this Decimal128 a positive number. Unlike java.math.BigDecimal, this method is destructive.
  - negateDestructive
```
public void negateDestructive()
```
    Reverses the sign of this Decimal128. Unlike java.math.BigDecimal, this method is destructive.
  - sqrtAsDouble
```
public double sqrtAsDouble()
```
    Calculate the square root of this value in double precision.
    Note that this does NOT perform the calculation in infinite accuracy. Although this sounds weird, it's at least how SQLServer does it. The SQL below demonstrates that SQLServer actually converts it into FLOAT (Java's double).
    create table bb (col1 DECIMAL(38,36), col2 DECIMAL (38,36)); insert into bb values(1.00435134913958923485982394892384,1.00345982739817298323423423); select sqrt(col1) as cola,sqrt(col2) colb into asdasd from bb; sp_columns asdasd;
    This SQL tells that the result is in FLOAT data type. One justification is that, because DECIMAL is at most 38 digits, double precision is enough for sqrt/pow.
    
    This method does not modify this object.
    
    This method throws exception if this value is negative rather than returning NaN. This is the SQL semantics (at least in SQLServer).
    
    Returns:
    square root of this value
  - powAsDouble
```
public double powAsDouble(double n)
```
    Calculate the power of this value in double precision. Note that this does NOT perform the calculation in infinite accuracy. Although this sounds weird, it's at least how SQLServer does it. The SQL below demonstrates that SQLServer actually converts it into FLOAT (Java's double).
    create table bb (col1 DECIMAL(38,36), col2 DECIMAL (38,36)); insert into bb values(1.00435134913958923485982394892384,1.00345982739817298323423423); select power(col1, col2);
    This SQL returns '1.004366436877081000000000000000000000', which is merely a power calculated in double precision ( "java.lang.Math.pow(1.00435134913958923485982394892384d, 1.00345982739817298323423423d)" returns 1.0043664368770813), and then scaled into DECIMAL. The same thing happens even when "n" is a positive integer. One justification is that, because DECIMAL is at most 38 digits, double precision is enough for sqrt/pow.
    
    This method does not modify this object.
    
    This method throws exception if the calculated value is Infinite. This is the SQL semantics (at least in SQLServer).
    
    Parameters:
    n - power to raise this object. Unlike BigDecimal.pow(int), this can receive a fractional number. Instead, this method calculates the value in double precision.
    
    Returns:
    power of this value
  - getSignum
```
public byte getSignum()
```
    Returns the signum of this Decimal128.
    
    Returns:
    -1, 0, or 1 as the value of this Decimal128 is negative, zero, or positive.
  - getScale
```
public short getScale()
```
    Returns the scale of this Decimal128. The scale is the positive number of digits to the right of the decimal point.
    
    Returns:
    the scale of this Decimal128.
  - getUnscaledValue
```
public UnsignedInt128 getUnscaledValue()
```
    Returns unscaled value of this Decimal128. Be careful because changes on the returned object will affect the object. It is not recommended to modify the object this method returns.
    
    Returns:
    the unscaled value of this Decimal128.
  - compareTo
```
public int compareTo(Decimal128 val)
```
    Compares this Decimal128 with the specified Decimal128. Two Decimal128 objects that are equal in value but have a different scale (like 2.0 and 2.00) are considered equal by this method. This method is provided in preference to individual methods for each of the six boolean comparison operators (<, ==, >, >=, !=, <=). The suggested idiom for performing these comparisons is: (x.compareTo(y) <op> 0), where <op> is one of the six comparison operators.
    
    Specified by:
    
    compareTo in interface Comparable<Decimal128>
    
    Parameters:
    val - Decimal128 to which this Decimal128 is to be compared.
    
    Returns:
    a negative integer, zero, or a positive integer as this Decimal128 is numerically less than, equal to, or greater than val.
  - equals
```
public boolean equals(Object x)
```
    Compares this Decimal128 with the specified Object for equality. Unlike compareTo, this method considers two Decimal128 objects equal only if they are equal in value and scale (thus 2.0 is not equal to 2.00 when compared by this method). This somewhat confusing behavior is, however, same as java.math.BigDecimal.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    x - Object to which this Decimal128 is to be compared.
    
    Returns:
    true if and only if the specified Object is a Decimal128 whose value and scale are equal to this Decimal128's.
    See Also:
    compareTo(Decimal128), hashCode()
  - hashCode
```
public int hashCode()
```
    Returns the hash code for this Decimal128. Note that two Decimal128 objects that are numerically equal but differ in scale (like 2.0 and 2.00) will generally not have the same hash code. This somewhat confusing behavior is, however, same as java.math.BigDecimal.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    hash code for this Decimal128.
    See Also:
    equals(Object)
  - longValue
```
public long longValue()
```
    Converts this Decimal128 to a long. This conversion is analogous to the narrowing primitive conversion from double to short as defined in section 5.1.3 of The Java™ Language Specification: any fractional part of this Decimal128 will be discarded, and if the resulting " UnsignedInt128" is too big to fit in a long, only the low-order 64 bits are returned. Note that this conversion can lose information about the overall magnitude and precision of this Decimal128 value.
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    this Decimal128 converted to a long.
  - intValue
```
public int intValue()
```
    Converts this Decimal128 to an int. This conversion is analogous to the narrowing primitive conversion from double to short as defined in section 5.1.3 of The Java™ Language Specification: any fractional part of this Decimal128 will be discarded, and if the resulting " UnsignedInt128" is too big to fit in an int, only the low-order 32 bits are returned. Note that this conversion can lose information about the overall magnitude and precision of this Decimal128 value.
    
    Specified by:
    
    intValue in class Number
    
    Returns:
    this Decimal128 converted to an int.
  - floatValue
```
public float floatValue()
```
    Converts this Decimal128 to a float. This conversion is similar to the narrowing primitive conversion from double to float as defined in section 5.1.3 of The Java™ Language Specification: if this Decimal128 has too great a magnitude to represent as a float, it will be converted to Float.NEGATIVE_INFINITY or Float.POSITIVE_INFINITY as appropriate. Note that even when the return value is finite, this conversion can lose information about the precision of the Decimal128 value.
    
    Specified by:
    
    floatValue in class Number
    
    Returns:
    this Decimal128 converted to a float.
  - doubleValue
```
public double doubleValue()
```
    Converts this Decimal128 to a double. This conversion is similar to the narrowing primitive conversion from double to float as defined in section 5.1.3 of The Java™ Language Specification: if this Decimal128 has too great a magnitude represent as a double, it will be converted to Double.NEGATIVE_INFINITY or Double.POSITIVE_INFINITY as appropriate. Note that even when the return value is finite, this conversion can lose information about the precision of the Decimal128 value.
    
    Specified by:
    
    doubleValue in class Number
    
    Returns:
    this Decimal128 converted to a double.
  - toBigDecimal
```
public BigDecimal toBigDecimal()
```
    Converts this object to BigDecimal. This method is not supposed to be used in a performance-sensitive place.
    
    Returns:
    BigDecimal object equivalent to this object.
  - checkPrecisionOverflow
```
public void checkPrecisionOverflow(int precision)
```
    Throws an exception if the value of this object exceeds the maximum value for the given precision. Remember that underflow is not an error, but overflow is an immediate error.
    
    Parameters:
    precision - maximum precision
  - getHiveDecimalString
```
public String getHiveDecimalString()
```
    Returns the string representation of this value. It discards the trailing zeros in the fractional part to match the HiveDecimal's string representation. However, don't use this string representation for the reconstruction of the object.
    
    Returns:
    string representation of this value
  - toFormalString
```
public String toFormalString()
```
    Returns the formal string representation of this value. Unlike the debug string returned by toString(), this method returns a string that can be used to re-construct this object. Remember, toString() is only for debugging.
    
    Returns:
    string representation of this value
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - setNullDataValue
```
public void setNullDataValue()
```
    Vectorized execution uses the smallest possible positive non-zero value to prevent possible later zero-divide exceptions. Set the field to this value (1 in the internal unsigned 128 bit int).
  - updateFixedPoint
```
public void updateFixedPoint(long val,
                    short scale)
```
    Update the value to a decimal value with the decimal point equal to val but with the decimal point inserted scale digits from the right. Behavior is undefined if scale is > 38 or < 0. For example, updateFixedPoint(123456789L, (short) 3) changes the target to the value 123456.789 with scale 3.
  - zeroFractionPart
```
public void zeroFractionPart(UnsignedInt128 scratch)
```
    Zero the fractional part of value. Argument scratch is needed to hold unused remainder output, to avoid need to create a new object.
  - zeroFractionPart
```
public void zeroFractionPart()
```
  - squareDestructive
```
public Decimal128 squareDestructive()
```
    Multiplies this with this, updating this
    
    Returns:
    self
  - updateVarianceDestructive
```
public Decimal128 updateVarianceDestructive(Decimal128 scratch,
                                   Decimal128 value,
                                   Decimal128 sum,
                                   long count)
```
    For UDAF variance we use the algorithm described by Chan, Golub, and LeVeque in "Algorithms for computing the sample variance: analysis and recommendations" The American Statistician, 37 (1983) pp. 242--247. variance = variance1 + variance2 + n/(m*(m+n)) * pow(((m/n)*t1 - t2),2) where: - variance is sum[x-avg^2] (this is actually n times the variance) and is updated at every step. - n is the count of elements in chunk1 - m is the count of elements in chunk2 - t1 = sum of elements in chunk1, t2 = sum of elements in chunk2. This is a helper function doing the intermediate computation: t = myagg.count*value - myagg.sum; myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1));
    
    Returns:
    self
  - fastUpdateFromInternalStorage
```
public Decimal128 fastUpdateFromInternalStorage(byte[] internalStorage,
                                       short scale)
```
    Fats update from BigInteger two's complement representation
    
    Parameters:
    internalStorage - BigInteger two's complement representation of the unscaled value
    scale -
  - setUnscaledValue
```
public void setUnscaledValue(UnsignedInt128 unscaledValue)
```
    This setter is only for de-serialization, should not be used otherwise.
  - setScale
```
public void setScale(short scale)
```
    This setter is only for de-serialization, should not be used otherwise.
  - setSignum
```
public void setSignum(byte signum)
```
    This setter is only for de-serialization, should not be used otherwise.

Class Decimal128

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Field Detail

MAX_SCALE

MIN_SCALE

ONE

MAX_VALUE

MIN_VALUE

Constructor Detail

Decimal128

Decimal128

Decimal128

Decimal128

Decimal128

Decimal128

Decimal128

Decimal128

Method Detail

getIntsPerElement

zeroClear

isZero

update

update

update

update

update

update

update128

update96

update64

update32

update

update128

update96

update64

update32

update

update

update

update

fastSerializeForHiveDecimal

serializeTo

serializeTo128

serializeTo96

serializeTo64

serializeTo32

serializeTo

serializeTo128

serializeTo96

serializeTo64

serializeTo32

changeScaleDestructive

add

addDestructive

subtract

subtractDestructive

multiply

multiplyDestructiveNativeDecimal128

multiplyDestructive

divide

divideDestructiveNativeDecimal128

divideDestructive

modulo

absDestructive

negateDestructive

sqrtAsDouble

powAsDouble

getSignum

getScale

getUnscaledValue

compareTo

equals

hashCode

longValue

intValue

floatValue