FastHiveDecimalImpl (Kyuubi Project Hive JDBC Client 1.9.1 API)

java.lang.Object
- org.apache.kyuubi.jdbc.hive.common.FastHiveDecimal
- - org.apache.kyuubi.jdbc.hive.common.FastHiveDecimalImpl

```
public class FastHiveDecimalImpl
extends FastHiveDecimal
```
This class is a companion to the FastHiveDecimal class that separates the essential of code out of FastHiveDecimal into static methods in this class so that they can be used directly by vectorization to implement decimals by storing the fast0, fast1, and fast2 longs and the fastSignum, fastScale, etc ints in the DecimalColumnVector class.

Nested Class Summary
- Nested classes/interfaces inherited from class org.apache.kyuubi.jdbc.hive.common.FastHiveDecimal
  FastHiveDecimal.FastCheckPrecisionScaleStatus

Field Summary

Fields
Modifier and Type	Field and Description
`static BigInteger`	`BIG_INTEGER_MAX_DECIMAL`
`static int`	`DECIMAL64_DECIMAL_DIGITS`
`static long`	`MAX_ABS_DECIMAL64`
`static int`	`MAX_DECIMAL_DIGITS`

Fields inherited from class org.apache.kyuubi.jdbc.hive.common.FastHiveDecimal
FAST_SCRATCH_BUFFER_LEN_BIG_INTEGER_BYTES, FAST_SCRATCH_BUFFER_LEN_SERIALIZATION_UTILS_READ, FAST_SCRATCH_BUFFER_LEN_TO_BYTES, FAST_SCRATCH_LONGS_LEN, fast0, fast1, fast2, fastIntegerDigitCount, fastScale, fastSerializationScale, fastSignum, SCRATCH_LONGS_LEN_FAST_SERIALIZATION_UTILS_WRITE, STRING_ENFORCE_PRECISION_OUT_OF_RANGE, STRING_ENFORCE_SCALE_LESS_THAN_EQUAL_PRECISION, STRING_ENFORCE_SCALE_OUT_OF_RANGE

Constructor Summary

Constructors
Constructor and Description

FastHiveDecimalImpl()

Constructors
Constructor and Description
`FastHiveDecimalImpl()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static String`	`displayBytes(byte[] bytes, int start, int length)`
`static boolean`	`doAddSameScaleSameSign(FastHiveDecimal fastLeft, FastHiveDecimal fastRight, FastHiveDecimal fastResult)`
`static boolean`	`doAddSameScaleSameSign(int resultSignum, long left0, long left1, long left2, long right0, long right1, long right2, FastHiveDecimal fastResult)`
`static boolean`	`doBinaryToDecimalConversion(long lowerWord, long middleWord, long highWord, FastHiveDecimal middleWordMultiplier, FastHiveDecimal highWordMultiplier, FastHiveDecimal fastResult)` Convert 3 binary words of N bits each to a fast decimal (scale 0).
`static boolean`	`doDecimalToBinaryDivisionRemainder(long dividendFast0, long dividendFast1, long dividendFast2, FastHiveDecimal fastInverseConst, int quotientIntegerWordNum, int quotientIntegerDigitNum, FastHiveDecimal fastMultiplierConst, long[] scratchLongs)` A helper method that produces a single binary word remainder from a fast decimal (and quotient).
`static boolean`	`doFastRound(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int roundPower, int roundingMode, FastHiveDecimal fastResult)`
`static void`	`doFastScaleDown(FastHiveDecimal fastDec, int scaleDown, FastHiveDecimal fastResult)`
`static void`	`doFastScaleDown(long fast0, long fast1, long fast2, int scaleDown, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with NO rounding.
`static int`	`doFastToFormatBytes(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int formatScale, byte[] scratchBuffer)`
`static boolean`	`doSubtractSameScaleNoUnderflow(int resultSignum, FastHiveDecimal fastLeft, FastHiveDecimal fastRight, FastHiveDecimal fastResult)`
`static boolean`	`doSubtractSameScaleNoUnderflow(int resultSignum, long left0, long left1, long left2, long right0, long right1, long right2, FastHiveDecimal fastResult)`
`static boolean`	`doSubtractSameScaleNoUnderflow(long left0, long left1, long left2, long right0, long right1, long right2, long[] result)`
`static boolean`	`fastAdd(FastHiveDecimal fastLeft, FastHiveDecimal fastRight, FastHiveDecimal fastResult)`
`static boolean`	`fastAdd(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftIntegerDigitCount, int leftScale, int rightSignum, long rightFast0, long rightFast1, long rightFast2, int rightIntegerDigitCount, int rightScale, FastHiveDecimal fastResult)` Add the two decimals.
`static BigDecimal`	`fastBigDecimalValue(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)` Return a BigDecimal representing the decimal.
`static int`	`fastBigIntegerBytes(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int fastSerializeScale, long[] scratchLongs, byte[] buffer)`
`static int`	`fastBigIntegerBytesScaled(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int serializeScale, long[] scratchLongs, byte[] buffer)` Convert decimal to BigInteger binary bytes with a serialize scale, similar to the formatScale for toFormatString.
`static int`	`fastBigIntegerBytesUnscaled(int fastSignum, long fast0, long fast1, long fast2, long[] scratchLongs, byte[] buffer)` Return binary representation of this decimal's BigInteger equivalent unscaled value using the format that the BigInteger's toByteArray method returns (and the BigInteger constructor accepts).
`static BigInteger`	`fastBigIntegerValue(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int fastSerializationScale)` Get a BigInteger representing the decimal's digits without a dot.
`static BigInteger`	`fastBigIntegerValueScaled(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int fastSerializationScale)`
`static BigInteger`	`fastBigIntegerValueUnscaled(int fastSignum, long fast0, long fast1, long fast2)`
`static byte`	`fastByteValueClip(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static FastHiveDecimal.FastCheckPrecisionScaleStatus`	`fastCheckPrecisionScale(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int maxPrecision, int maxScale)`
`static int`	`fastCompareTo(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftScale, FastHiveDecimal fastRight)`
`static int`	`fastCompareTo(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftScale, int rightSignum, long rightFast0, long rightFast1, long rightFast2, int rightScale)`
`static void`	`fastDeserialize64(long inputDecimal64Long, int inputScale, FastHiveDecimal fastResult)`
`static boolean`	`fastDivide(FastHiveDecimal fastLeft, FastHiveDecimal fastRight, FastHiveDecimal fastResult)`
`static boolean`	`fastDivide(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftIntegerDigitCount, int leftScale, int rightSignum, long rightFast0, long rightFast1, long rightFast2, int rightIntegerDigitCount, int rightScale, FastHiveDecimal fastResult)`
`static double`	`fastDoubleValue(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static boolean`	`fastEquals(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftScale, FastHiveDecimal fastRight)`
`static boolean`	`fastEquals(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftScale, int rightSignum, long rightFast0, long rightFast1, long rightFast2, int rightScale)`
`static boolean`	`fastExceedsPrecision(long fast0, long fast1, long fast2, int precision)`
`static float`	`fastFloatValue(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static void`	`fastFractionPortion(int fastSignum, long fast0, long fast1, long fast2, int fastScale, FastHiveDecimal fastResult)` Creates fast decimal from the fraction portion of a fast decimal.
`static int`	`fastHashCode(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)` This is the original hash code as returned by OldHiveDecimal.
`static int`	`fastHighWordPrecision(long longWord)`
`static int`	`fastHighWordTrailingZeroCount(long longWord)`
`static void`	`fastIntegerPortion(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, FastHiveDecimal fastResult)` Creates fast decimal from the integer portion.
`static int`	`fastIntValueClip(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static boolean`	`fastIsByte(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)` Is the decimal value a byte? Range -128 to 127.
`static boolean`	`fastIsInt(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)` Is the decimal value a int? Range -2,147,483,648 to 2,147,483,647.
`static boolean`	`fastIsLong(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)` Is the decimal value a long? Range -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
`static boolean`	`fastIsShort(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)` Is the decimal value a short? Range -32,768 to 32,767.
`static boolean`	`fastIsValid(FastHiveDecimal fastDec)`
`static boolean`	`fastIsValid(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static long`	`fastLongValueClip(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static int`	`fastLongWordPrecision(long longWord)`
`static int`	`fastLongWordTrailingZeroCount(long longWord)`
`static boolean`	`fastMultiply(FastHiveDecimal fastLeft, FastHiveDecimal fastRight, FastHiveDecimal fastResult)`
`static boolean`	`fastMultiply(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftIntegerDigitCount, int leftScale, int rightSignum, long rightFast0, long rightFast1, long rightFast2, int rightIntegerDigitCount, int rightScale, FastHiveDecimal fastResult)`
`static boolean`	`fastMultiply5x5HalfWords(FastHiveDecimal fastLeft, FastHiveDecimal fastRight, FastHiveDecimal fastResult)`
`static boolean`	`fastMultiply5x5HalfWords(long left0, long left1, long left2, long right0, long right1, long right2, FastHiveDecimal fastResult)` Fast decimal multiplication on two decimals that have been already scaled and whose results will fit in 38 digits.
`static boolean`	`fastMultiply5x5HalfWords(long left0, long left1, long left2, long right0, long right1, long right2, long[] result)` Fast decimal multiplication on two decimals that have been already scaled and whose results will fit in 38 digits.
`static boolean`	`fastMultiply5x6HalfWords(long left0, long left1, long left2, long right0, long right1, long right2, long[] result)` Fast decimal multiplication on two decimals whose results are permitted to go beyond 38 digits to the maximum possible 76 digits.
`static boolean`	`fastMultiplyFullInternal(FastHiveDecimal fastLeft, FastHiveDecimal fastRight, long[] result)`
`static boolean`	`fastMultiplyFullInternal(long left0, long left1, long left2, long right0, long right1, long right2, long[] result)` Fast decimal multiplication on two decimals whose results are permitted to go beyond 38 digits to the maximum possible 76 digits.
`static int`	`fastNewFasterHashCode(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)` Hash code based on (new) decimal representation.
`static boolean`	`fastPow(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int exponent, FastHiveDecimal fastResult)`
`static void`	`fastRaiseInvalidException(FastHiveDecimal fastResult)`
`static void`	`fastRaiseInvalidException(FastHiveDecimal fastResult, String parameters)`
`static int`	`fastRawPrecision(FastHiveDecimal fastDec)`
`static int`	`fastRawPrecision(int fastSignum, long fast0, long fast1, long fast2)`
`static boolean`	`fastRemainder(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftIntegerDigitCount, int leftScale, int rightSignum, long rightFast0, long rightFast1, long rightFast2, int rightIntegerDigitCount, int rightScale, FastHiveDecimal fastResult)`
`static boolean`	`fastRound(FastHiveDecimal fastDec, int newScale, int roundingMode, FastHiveDecimal fastResult)`
`static boolean`	`fastRound(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int newScale, int roundingMode, FastHiveDecimal fastResult)`
`static void`	`fastRoundFractionalDown(int fastSignum, long fast0, long fast1, long fast2, int scaleDown, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with rounding ROUND_DOWN.
`static boolean`	`fastRoundFractionalHalfEven(int fastSignum, long fast0, long fast1, long fast2, int scaleDown, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with rounding ROUND_HALF_EVEN.
`static boolean`	`fastRoundFractionalHalfUp(int fastSignum, long fast0, long fast1, long fast2, int scaleDown, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with rounding ROUND_HALF_UP.
`static boolean`	`fastRoundFractionalHalfUp5Words(int fastSignum, long fast0, long fast1, long fast2, long fast3, long fast4, int scaleDown, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with rounding ROUND_HALF_UP.
`static boolean`	`fastRoundFractionalUp(int fastSignum, long fast0, long fast1, long fast2, int scaleDown, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with rounding ROUND_UP.
`static boolean`	`fastRoundIntegerDown(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int roundPower, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with rounding ROUND_DOWN.
`static boolean`	`fastRoundIntegerHalfEven(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int roundPower, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with rounding ROUND_HALF_EVEN.
`static boolean`	`fastRoundIntegerHalfUp(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int roundPower, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 with rounding ROUND_HALF_UP.
`static boolean`	`fastRoundIntegerUp(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int roundPower, FastHiveDecimal fastResult)` Fast decimal integer part rounding ROUND_UP.
`static boolean`	`fastScaleByPowerOfTen(FastHiveDecimal fastDec, int power, FastHiveDecimal fastResult)`
`static boolean`	`fastScaleByPowerOfTen(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int power, FastHiveDecimal fastResult)`
`static boolean`	`fastScaleDownNoRound(int fastSignum, long fast0, long fast1, long fast2, int scaleDown, FastHiveDecimal fastResult)` Fast decimal scale down by factor of 10 and do not allow rounding.
`static boolean`	`fastScaleUp(FastHiveDecimal fastDec, int scaleUp, FastHiveDecimal fastResult)`
`static boolean`	`fastScaleUp(long fast0, long fast1, long fast2, int scaleUp, FastHiveDecimal fastResult)` Fast decimal scale up by factor of 10.
`static boolean`	`fastSerializationUtilsRead(InputStream inputStream, int scale, byte[] scratchBytes, FastHiveDecimal fastResult)` Deserialize data written in the format used by the SerializationUtils methods readBigInteger/writeBigInteger and create a decimal using the supplied scale.
`static boolean`	`fastSerializationUtilsWrite(OutputStream outputStream, int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, long[] scratchLongs)` Write the value of this decimal just like SerializationUtils.writeBigInteger.
`static long`	`fastSerialize64(int scale, int fastSignum, long fast1, long fast0, int fastScale)`
`static boolean`	`fastSetFromBigDecimal(BigDecimal bigDecimal, boolean allowRounding, FastHiveDecimal fastResult)` Create a fast decimal from a BigDecimal.
`static boolean`	`fastSetFromBigInteger(BigInteger bigInteger, FastHiveDecimal fastResult)` Creates a fast decimal from a BigInteger with scale 0.
`static boolean`	`fastSetFromBigInteger(BigInteger bigInteger, int scale, FastHiveDecimal fastResult)` Creates a fast decimal from a BigInteger with a specified scale.
`static boolean`	`fastSetFromBigInteger(BigInteger bigInteger, int scale, int precision, FastHiveDecimal fastResult)` Creates a fast decimal from a BigInteger with a specified scale.
`static boolean`	`fastSetFromBigIntegerBytesAndScale(byte[] bytes, int offset, int length, int scale, FastHiveDecimal fastResult)` Convert bytes in the format used by BigInteger's toByteArray format (and accepted by its constructor) into a decimal using the specified scale.
`static boolean`	`fastSetFromBytes(byte[] bytes, int offset, int length, boolean trimBlanks, FastHiveDecimal fastResult)` Scan a byte array slice for a decimal number in UTF-8 bytes.
`static boolean`	`fastSetFromDigitsOnlyBytesAndScale(boolean isNegative, byte[] bytes, int offset, int length, int scale, FastHiveDecimal fastResult)` Scans a byte array slice for UNSIGNED RAW DIGITS ONLY in UTF-8 (ASCII) characters and forms a decimal from the digits and a sign and scale.
`static boolean`	`fastSetFromDouble(double doubleValue, FastHiveDecimal fastResult)` Creates fast decimal from a double.
`static boolean`	`fastSetFromFloat(float floatValue, FastHiveDecimal fastResult)` Creates fast decimal from a float.
`static void`	`fastSetFromInt(int intValue, FastHiveDecimal fastResult)` Creates a scale 0 fast decimal from an int.
`static void`	`fastSetFromLong(long longValue, FastHiveDecimal fastResult)` Creates a scale 0 fast decimal from a long.
`static boolean`	`fastSetFromLongAndScale(long longValue, int scale, FastHiveDecimal fastResult)` Creates a fast decimal from a long with a specified scale.
`static boolean`	`fastSetFromString(String string, boolean trimBlanks, FastHiveDecimal result)` Scan a String for a decimal number in UTF-8 characters.
`static short`	`fastShortValueClip(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static int`	`fastSqlPrecision(FastHiveDecimal fastDec)`
`static int`	`fastSqlPrecision(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static boolean`	`fastSubtract(FastHiveDecimal fastLeft, FastHiveDecimal fastRight, FastHiveDecimal fastResult)`
`static boolean`	`fastSubtract(int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftIntegerDigitCount, int leftScale, int rightSignum, long rightFast0, long rightFast1, long rightFast2, int rightIntegerDigitCount, int rightScale, FastHiveDecimal fastResult)`
`static int`	`fastToBytes(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int fastTrailingZeroesScale, byte[] scratchBuffer)`
`static int`	`fastToDigitsOnlyBytes(long fast0, long fast1, long fast2, int fastIntegerDigitCount, byte[] scratchBuffer)`
`static String`	`fastToDigitsOnlyString(long fast0, long fast1, long fast2, int fastIntegerDigitCount)`
`static int`	`fastToFormatBytes(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int formatScale, byte[] scratchBuffer)`
`static String`	`fastToFormatString(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int formatScale)`
`static String`	`fastToFormatString(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int formatScale, byte[] scratchBuffer)`
`static String`	`fastToString(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int fastTrailingZeroesScale)`
`static String`	`fastToString(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int fastTrailingZeroesScale, byte[] scratchBuffer)`
`static int`	`fastTrailingDecimalZeroCount(long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale)`
`static boolean`	`fastUpdatePrecisionScale(int fastSignum, long fast0, long fast1, long fast2, int fastIntegerDigitCount, int fastScale, int maxPrecision, int maxScale, FastHiveDecimal.FastCheckPrecisionScaleStatus status, FastHiveDecimal fastResult)`
`static long`	`getDecimal64AbsMax(int precision)`
`static String`	`getStackTraceAsSingleLine(StackTraceElement[] stackTrace)`
`static boolean`	`isAllZeroesBelow(int fastSignum, long fast0, long fast1, long fast2, int power)`

Methods inherited from class org.apache.kyuubi.jdbc.hive.common.FastHiveDecimal
fastAbs, fastAdd, fastBigDecimalValue, fastBigIntegerBytes, fastBigIntegerBytesScaled, fastBigIntegerValue, fastByteValueClip, fastCheckPrecisionScale, fastCompareTo, fastCompareTo, fastDeserialize64, fastDivide, fastDoubleValue, fastEnforcePrecisionScale, fastEquals, fastFloatValue, fastFractionPortion, fastHashCode, fastIntegerDigitCount, fastIntegerPortion, fastIntValueClip, fastIsByte, fastIsInt, fastIsLong, fastIsShort, fastIsValid, fastLongValueClip, fastMultiply, fastNegate, fastNewFasterHashCode, fastPow, fastRaiseInvalidException, fastRaiseInvalidException, fastRawPrecision, fastRemainder, fastReset, fastRound, fastRoundingModeToString, fastScale, fastScaleByPowerOfTen, fastSerializationScale, fastSerializationUtilsRead, fastSerializationUtilsWrite, fastSerialize64, fastSet, fastSet, fastSetFromBigDecimal, fastSetFromBigInteger, fastSetFromBigIntegerAndScale, fastSetFromBigIntegerBytesAndScale, fastSetFromBytes, fastSetFromDigitsOnlyBytesAndScale, fastSetFromDouble, fastSetFromFloat, fastSetFromInt, fastSetFromLong, fastSetFromLongAndScale, fastSetFromString, fastSetSerializationScale, fastShortValueClip, fastSignum, fastSqlPrecision, fastSubtract, fastToBytes, fastToDigitsOnlyBytes, fastToDigitsOnlyString, fastToFormatBytes, fastToFormatString, fastToFormatString, fastToString, fastToString, fastUpdatePrecisionScale, isAllZeroesBelow, toString

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

Field Detail

MAX_DECIMAL_DIGITS
```
public static final int MAX_DECIMAL_DIGITS
```
See Also:

Constant Field Values

DECIMAL64_DECIMAL_DIGITS
```
public static final int DECIMAL64_DECIMAL_DIGITS
```
See Also:

Constant Field Values

MAX_ABS_DECIMAL64
```
public static final long MAX_ABS_DECIMAL64
```
See Also:

Constant Field Values

BIG_INTEGER_MAX_DECIMAL

public static final BigInteger BIG_INTEGER_MAX_DECIMAL

Constructor Detail
- FastHiveDecimalImpl
```
public FastHiveDecimalImpl()
```

Method Detail

fastSetFromBytes
```
public static boolean fastSetFromBytes(byte[] bytes,
                                       int offset,
                                       int length,
                                       boolean trimBlanks,
                                       FastHiveDecimal fastResult)
```
Scan a byte array slice for a decimal number in UTF-8 bytes.
Syntax: [+|-][integerPortion][.[fractionalDigits]][{E|e}[+|-]exponent] // Where at least one integer or fractional // digit is required...
We handle too many fractional digits by doing rounding ROUND_HALF_UP.
NOTE: The fastSetFromBytes method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

bytes - the bytes to copy from

offset - the starting location in bytes

length - the number of bytes to use from bytes

trimBlanks - should spaces be trimmed?

fastResult - True if the byte array slice was successfully converted to a decimal.

Returns:

Was a valid number found?

fastSetFromDigitsOnlyBytesAndScale
```
public static boolean fastSetFromDigitsOnlyBytesAndScale(boolean isNegative,
                                                         byte[] bytes,
                                                         int offset,
                                                         int length,
                                                         int scale,
                                                         FastHiveDecimal fastResult)
```
Scans a byte array slice for UNSIGNED RAW DIGITS ONLY in UTF-8 (ASCII) characters and forms a decimal from the digits and a sign and scale.
Designed for BinarySortable serialization format that separates the sign and scale from the raw digits.
NOTE: The fastSetFromDigitsOnlyBytesAndScale method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

isNegative - is the number negative

bytes - the bytes to read from

offset - the position to start at

length - the number of bytes to read

scale - the scale of the number

fastResult - an object it into

Returns:

True if the sign, digits, and scale were successfully converted to a decimal.

fastSetFromBigDecimal
```
public static boolean fastSetFromBigDecimal(BigDecimal bigDecimal,
                                            boolean allowRounding,
                                            FastHiveDecimal fastResult)
```
Create a fast decimal from a BigDecimal.
NOTE: The fastSetFromBigDecimal method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

bigDecimal - the big decimal to copy

allowRounding - is rounding allowed?

fastResult - an object to reuse

Returns:

True if the BigDecimal could be converted to our decimal representation.

fastSetFromString
```
public static boolean fastSetFromString(String string,
                                        boolean trimBlanks,
                                        FastHiveDecimal result)
```
Scan a String for a decimal number in UTF-8 characters.
NOTE: The fastSetFromString method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

string - the string to parse

trimBlanks - should the blanks be trimmed

result - an object to reuse

Returns:

True if the String was successfully converted to a decimal.

fastSetFromInt
```
public static void fastSetFromInt(int intValue,
                                  FastHiveDecimal fastResult)
```
Creates a scale 0 fast decimal from an int.
NOTE: The fastSetFromString method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

intValue - the value to set

fastResult - an object to reuse

fastSetFromLong
```
public static void fastSetFromLong(long longValue,
                                   FastHiveDecimal fastResult)
```
Creates a scale 0 fast decimal from a long.
NOTE: The fastSetFromLong method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

longValue - the value to set

fastResult - an object to reuse

fastSetFromLongAndScale
```
public static boolean fastSetFromLongAndScale(long longValue,
                                              int scale,
                                              FastHiveDecimal fastResult)
```
Creates a fast decimal from a long with a specified scale.
NOTE: The fastSetFromLongAndScale method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

longValue - the value to set as a long

scale - the scale to use

fastResult - an object to reuse

Returns:

was the conversion successful?

fastSetFromFloat
```
public static boolean fastSetFromFloat(float floatValue,
                                       FastHiveDecimal fastResult)
```
Creates fast decimal from a float.
NOTE: The fastSetFromFloat method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

floatValue - the value to set

fastResult - an object to reuse

Returns:

was the conversion successful?

fastSetFromDouble
```
public static boolean fastSetFromDouble(double doubleValue,
                                        FastHiveDecimal fastResult)
```
Creates fast decimal from a double.
NOTE: The fastSetFromDouble method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

doubleValue - the value to set

fastResult - an object to reuse

Returns:

was the conversion successful?

fastSetFromBigInteger
```
public static boolean fastSetFromBigInteger(BigInteger bigInteger,
                                            FastHiveDecimal fastResult)
```
Creates a fast decimal from a BigInteger with scale 0.
For efficiency, we assume that fastResult is fastReset. This method does not set the fastScale field.
NOTE: The fastSetFromBigInteger method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

bigInteger - the value to set

fastResult - an object to reuse

Returns:

Return true if the BigInteger value fit within HiveDecimal.MAX_PRECISION. Otherwise, false for overflow.

fastSetFromBigInteger
```
public static boolean fastSetFromBigInteger(BigInteger bigInteger,
                                            int scale,
                                            FastHiveDecimal fastResult)
```
Creates a fast decimal from a BigInteger with a specified scale.
NOTE: The fastSetFromBigInteger method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

bigInteger - the value to set as an integer

scale - the scale to use

fastResult - an object to reuse

Returns:

True if the BigInteger and scale were successfully converted to a decimal.

fastSetFromBigInteger
```
public static boolean fastSetFromBigInteger(BigInteger bigInteger,
                                            int scale,
                                            int precision,
                                            FastHiveDecimal fastResult)
```
Creates a fast decimal from a BigInteger with a specified scale.
NOTE: The fastSetFromBigInteger method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

bigInteger - the value to set as an integer

scale - the scale to use

precision - the precision to use

fastResult - an object to reuse

Returns:

True if the BigInteger and scale were successfully converted to a decimal.

fastFractionPortion
```
public static void fastFractionPortion(int fastSignum,
                                       long fast0,
                                       long fast1,
                                       long fast2,
                                       int fastScale,
                                       FastHiveDecimal fastResult)
```
Creates fast decimal from the fraction portion of a fast decimal.
NOTE: The fastFractionPortion method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:

fastSignum - the sign of the number (1, 0, or -1)

fast0 - high bits

fast1 - second word bits

fast2 - third word bits

fastScale - the scale

fastResult - an object to reuse

fastIntegerPortion

public static void fastIntegerPortion(int fastSignum,
                                      long fast0,
                                      long fast1,
                                      long fast2,
                                      int fastIntegerDigitCount,
                                      int fastScale,
                                      FastHiveDecimal fastResult)

Creates fast decimal from the integer portion.

NOTE: The fastFractionPortion method requires the caller to pass a fastResult parameter has been reset for better performance.

Parameters:: fastSignum - the sign of the number (1, 0, or -1); fast0 - high bits; fast1 - second word bits; fast2 - third word bits; fastIntegerDigitCount - the number of integer digits; fastScale - the scale; fastResult - an object to reuse

doBinaryToDecimalConversion
```
public static boolean doBinaryToDecimalConversion(long lowerWord,
                                                  long middleWord,
                                                  long highWord,
                                                  FastHiveDecimal middleWordMultiplier,
                                                  FastHiveDecimal highWordMultiplier,
                                                  FastHiveDecimal fastResult)
```
Convert 3 binary words of N bits each to a fast decimal (scale 0).
The 3 binary words highWord, middleWord, and lowerWord form a large binary value:
highWord * 2^(M+L) + middleWord * 2^L + lowerWord.
Where L is the number of bits in the lower word; M is the number of bits in the middle word. We let L and M be different to support the SerializationUtil serialization where the lower word is 62 bits and the remaining words are 63 bits...

Parameters:

lowerWord - the lower internal representation

middleWord - the middle internal representation

highWord - the high internal representation

middleWordMultiplier - 2^L

highWordMultiplier - 2^(M+L)

fastResult - an object to reuse

Returns:

True if the conversion of the 3 binary words to decimal was successful.

doDecimalToBinaryDivisionRemainder
```
public static boolean doDecimalToBinaryDivisionRemainder(long dividendFast0,
                                                         long dividendFast1,
                                                         long dividendFast2,
                                                         FastHiveDecimal fastInverseConst,
                                                         int quotientIntegerWordNum,
                                                         int quotientIntegerDigitNum,
                                                         FastHiveDecimal fastMultiplierConst,
                                                         long[] scratchLongs)
```
A helper method that produces a single binary word remainder from a fast decimal (and quotient).
The fast decimal is longwords of 16 digits each and we need binary words of 2^N. Since we are in decimal form, we have do work to get to convert to binary form.
We effectively need to produce on big binary value (i.e. greater than 64 bits since HiveDecimal needs 128 bits of binary which Java does not provide primitive support for) from the decimal long words and get the lower N binary bit remainder.
We could try and do decimal division by 2^N to get the (integer) quotient, multiply the quotient by 2^N decimal, and finally do a decimal subtract that from the original decimal. The resulting decimal can be used to easily get the binary remainder.
However, currently, we do not have fast decimal division.
The "trick" we do here is to remember from your Algebra in school than multiplication and division are inverses of each other.
So instead of doing decimal division by 2^N we multiply by the inverse: 2^-N.
We produce 1 binary word (remainder) and a decimal quotient for the higher portion.

Parameters:

dividendFast0 - The input decimal that will produce a single binary word remainder and decimal quotient.

dividendFast1 - second word

dividendFast2 - third word

fastInverseConst - the fast decimal inverse of 2^N = 2^-N

quotientIntegerWordNum - the word in the inverse multiplication result to find the quotient integer decimal portion

quotientIntegerDigitNum - the digit in the result to find the quotient integer decimal portion

fastMultiplierConst - The fast decimal multiplier for converting the quotient integer to the larger number to subtract from the input decimal to get the remainder.

scratchLongs - where to store the result remainder word (index 3) and result quotient decimal longwords (indices 0 .. 2)

Returns:

True if the results were produced without overflow.

fastSerializationUtilsRead
```
public static boolean fastSerializationUtilsRead(InputStream inputStream,
                                                 int scale,
                                                 byte[] scratchBytes,
                                                 FastHiveDecimal fastResult)
                                          throws IOException
```
Deserialize data written in the format used by the SerializationUtils methods readBigInteger/writeBigInteger and create a decimal using the supplied scale.
ORC uses those SerializationUtils methods for its serialization.
A scratch bytes array is necessary to do the binary to decimal conversion for better performance. Pass a FAST_SCRATCH_BUFFER_LEN_SERIALIZATION_UTILS_READ byte array for scratchBytes.

Parameters:

inputStream - the stream to read from

scale - the scale of the number

scratchBytes - An array for the binary to decimal conversion for better performance. Must have length of FAST_SCRATCH_BUFFER_LEN_SERIALIZATION_UTILS_READ.

fastResult - an object to reuse

Returns:

The deserialized decimal or null if the conversion failed.

Throws:

IOException - failures in reading the stream

fastSerializationUtilsWrite
```
public static boolean fastSerializationUtilsWrite(OutputStream outputStream,
                                                  int fastSignum,
                                                  long fast0,
                                                  long fast1,
                                                  long fast2,
                                                  int fastIntegerDigitCount,
                                                  int fastScale,
                                                  long[] scratchLongs)
                                           throws IOException
```
Write the value of this decimal just like SerializationUtils.writeBigInteger. It header comments are:
Write the arbitrarily sized signed BigInteger in vint format.
Signed integers are encoded using the low bit as the sign bit using zigzag encoding.
Each byte uses the low 7 bits for data and the high bit for stop/continue.
Bytes are stored LSB first.
NOTE: SerializationUtils.writeBigInteger sometimes pads the result with extra zeroes due to BigInteger.bitLength -- we do not emulate that. SerializationUtils.readBigInteger will produce the same result for both.

Parameters:

outputStream - the stream to write to

fastSignum - the sign digit (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1 of the internal representation

fast2 - word 2 of the internal representation

fastIntegerDigitCount - unused

fastScale - unused

scratchLongs - scratch space

Returns:

True if the decimal was successfully serialized into the output stream.

Throws:

IOException - for problems in writing

getDecimal64AbsMax

public static long getDecimal64AbsMax(int precision)

fastDeserialize64

public static void fastDeserialize64(long inputDecimal64Long,
                                     int inputScale,
                                     FastHiveDecimal fastResult)

fastSerialize64

public static long fastSerialize64(int scale,
                                   int fastSignum,
                                   long fast1,
                                   long fast0,
                                   int fastScale)

fastSetFromBigIntegerBytesAndScale
```
public static boolean fastSetFromBigIntegerBytesAndScale(byte[] bytes,
                                                         int offset,
                                                         int length,
                                                         int scale,
                                                         FastHiveDecimal fastResult)
```
Convert bytes in the format used by BigInteger's toByteArray format (and accepted by its constructor) into a decimal using the specified scale.
Our bigIntegerBytes methods create bytes in this format, too.
This method is designed for high performance and does not create an actual BigInteger during binary to decimal conversion.

Parameters:

bytes - the bytes to read from

offset - the starting position in the bytes array

length - the number of bytes to read from the bytes array

scale - the scale of the number

fastResult - an object to reused

Returns:

did the conversion succeed?

fastBigIntegerBytes

public static int fastBigIntegerBytes(int fastSignum,
                                      long fast0,
                                      long fast1,
                                      long fast2,
                                      int fastIntegerDigitCount,
                                      int fastScale,
                                      int fastSerializeScale,
                                      long[] scratchLongs,
                                      byte[] buffer)

fastBigIntegerBytesUnscaled
```
public static int fastBigIntegerBytesUnscaled(int fastSignum,
                                              long fast0,
                                              long fast1,
                                              long fast2,
                                              long[] scratchLongs,
                                              byte[] buffer)
```
Return binary representation of this decimal's BigInteger equivalent unscaled value using the format that the BigInteger's toByteArray method returns (and the BigInteger constructor accepts).
Used by LazyBinary, Avro, and Parquet serialization.
Scratch objects necessary to do the decimal to binary conversion without actually creating a BigInteger object are passed for better performance.

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

scratchLongs - scratch array of SCRATCH_LONGS_LEN longs

buffer - scratch array of SCRATCH_BUFFER_LEN_BIG_INTEGER_BYTES bytes

Returns:

The number of bytes used for the binary result in buffer. Otherwise, 0 if the conversion failed.

fastBigIntegerBytesScaled
```
public static int fastBigIntegerBytesScaled(int fastSignum,
                                            long fast0,
                                            long fast1,
                                            long fast2,
                                            int fastIntegerDigitCount,
                                            int fastScale,
                                            int serializeScale,
                                            long[] scratchLongs,
                                            byte[] buffer)
```
Convert decimal to BigInteger binary bytes with a serialize scale, similar to the formatScale for toFormatString. It adds trailing zeroes when a serializeScale is greater than current scale. Or, rounds if scale is less than current scale.
Used by Avro and Parquet serialization.
This emulates the OldHiveDecimal setScale / OldHiveDecimal getInternalStorage() behavior.

Parameters:

fastSignum - the sign number (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale

serializeScale - the scale to serialize

scratchLongs - a scratch array of longs

buffer - the buffer to serialize into

Returns:

the number of bytes used to serialize the number

fastIsByte
```
public static boolean fastIsByte(int fastSignum,
                                 long fast0,
                                 long fast1,
                                 long fast2,
                                 int fastIntegerDigitCount,
                                 int fastScale)
```
Is the decimal value a byte? Range -128 to 127. Byte.MIN_VALUE Byte.MAX_VALUE
Emulates testing for no value corruption: bigDecimalValue().setScale(0).equals(BigDecimal.valueOf(bigDecimalValue().byteValue()))
NOTE: Fractional digits are ignored in the test since fastByteValueClip() will remove them (round down).

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale of the number

Returns:

True when fastByteValueClip() will return a correct byte.

fastByteValueClip

public static byte fastByteValueClip(int fastSignum,
                                     long fast0,
                                     long fast1,
                                     long fast2,
                                     int fastIntegerDigitCount,
                                     int fastScale)

fastIsShort
```
public static boolean fastIsShort(int fastSignum,
                                  long fast0,
                                  long fast1,
                                  long fast2,
                                  int fastIntegerDigitCount,
                                  int fastScale)
```
Is the decimal value a short? Range -32,768 to 32,767. Short.MIN_VALUE Short.MAX_VALUE
Emulates testing for no value corruption: bigDecimalValue().setScale(0).equals(BigDecimal.valueOf(bigDecimalValue().shortValue()))
NOTE: Fractional digits are ignored in the test since fastShortValueClip() will remove them (round down).

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale of the number

Returns:

True when fastShortValueClip() will return a correct short.

fastShortValueClip

public static short fastShortValueClip(int fastSignum,
                                       long fast0,
                                       long fast1,
                                       long fast2,
                                       int fastIntegerDigitCount,
                                       int fastScale)

fastIsInt
```
public static boolean fastIsInt(int fastSignum,
                                long fast0,
                                long fast1,
                                long fast2,
                                int fastIntegerDigitCount,
                                int fastScale)
```
Is the decimal value a int? Range -2,147,483,648 to 2,147,483,647. Integer.MIN_VALUE Integer.MAX_VALUE
Emulates testing for no value corruption: bigDecimalValue().setScale(0).equals(BigDecimal.valueOf(bigDecimalValue().intValue()))
NOTE: Fractional digits are ignored in the test since fastIntValueClip() will remove them (round down).

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale of the number

Returns:

True when fastIntValueClip() will return a correct int.

fastIntValueClip

public static int fastIntValueClip(int fastSignum,
                                   long fast0,
                                   long fast1,
                                   long fast2,
                                   int fastIntegerDigitCount,
                                   int fastScale)

fastIsLong
```
public static boolean fastIsLong(int fastSignum,
                                 long fast0,
                                 long fast1,
                                 long fast2,
                                 int fastIntegerDigitCount,
                                 int fastScale)
```
Is the decimal value a long? Range -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. Long.MIN_VALUE Long.MAX_VALUE
Emulates testing for no value corruption: bigDecimalValue().setScale(0).equals(BigDecimal.valueOf(bigDecimalValue().longValue()))
NOTE: Fractional digits are ignored in the test since fastLongValueClip() will remove them (round down).

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale of the number

Returns:

True when fastLongValueClip() will return a correct long.

fastLongValueClip

public static long fastLongValueClip(int fastSignum,
                                     long fast0,
                                     long fast1,
                                     long fast2,
                                     int fastIntegerDigitCount,
                                     int fastScale)

fastFloatValue

public static float fastFloatValue(int fastSignum,
                                   long fast0,
                                   long fast1,
                                   long fast2,
                                   int fastIntegerDigitCount,
                                   int fastScale)

fastDoubleValue

public static double fastDoubleValue(int fastSignum,
                                     long fast0,
                                     long fast1,
                                     long fast2,
                                     int fastIntegerDigitCount,
                                     int fastScale)

fastBigIntegerValue

public static BigInteger fastBigIntegerValue(int fastSignum,
                                             long fast0,
                                             long fast1,
                                             long fast2,
                                             int fastIntegerDigitCount,
                                             int fastScale,
                                             int fastSerializationScale)

Get a BigInteger representing the decimal's digits without a dot.

Parameters:: fastSignum - the sign (-1, 0, or +1); fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; fastIntegerDigitCount - the number of integer digits; fastScale - the scale of the number; fastSerializationScale - the scale to serialize
Returns:: Returns a signed BigInteger.

fastBigIntegerValueUnscaled

public static BigInteger fastBigIntegerValueUnscaled(int fastSignum,
                                                     long fast0,
                                                     long fast1,
                                                     long fast2)

fastBigIntegerValueScaled

public static BigInteger fastBigIntegerValueScaled(int fastSignum,
                                                   long fast0,
                                                   long fast1,
                                                   long fast2,
                                                   int fastIntegerDigitCount,
                                                   int fastScale,
                                                   int fastSerializationScale)

fastBigDecimalValue
```
public static BigDecimal fastBigDecimalValue(int fastSignum,
                                             long fast0,
                                             long fast1,
                                             long fast2,
                                             int fastIntegerDigitCount,
                                             int fastScale)
```
Return a BigDecimal representing the decimal. The BigDecimal class is able to accurately represent the decimal.
NOTE: We are not representing our decimal as BigDecimal now as OldHiveDecimal did, so this is now slower.

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale of the number

Returns:

the BigDecimal equivalent

fastCompareTo

public static int fastCompareTo(int leftSignum,
                                long leftFast0,
                                long leftFast1,
                                long leftFast2,
                                int leftScale,
                                FastHiveDecimal fastRight)

fastCompareTo

public static int fastCompareTo(int leftSignum,
                                long leftFast0,
                                long leftFast1,
                                long leftFast2,
                                int leftScale,
                                int rightSignum,
                                long rightFast0,
                                long rightFast1,
                                long rightFast2,
                                int rightScale)

fastEquals

public static boolean fastEquals(int leftSignum,
                                 long leftFast0,
                                 long leftFast1,
                                 long leftFast2,
                                 int leftScale,
                                 FastHiveDecimal fastRight)

fastEquals

public static boolean fastEquals(int leftSignum,
                                 long leftFast0,
                                 long leftFast1,
                                 long leftFast2,
                                 int leftScale,
                                 int rightSignum,
                                 long rightFast0,
                                 long rightFast1,
                                 long rightFast2,
                                 int rightScale)

fastNewFasterHashCode
```
public static int fastNewFasterHashCode(int fastSignum,
                                        long fast0,
                                        long fast1,
                                        long fast2,
                                        int fastIntegerDigitCount,
                                        int fastScale)
```
Hash code based on (new) decimal representation.
Faster than fastHashCode().
Used by map join and other Hive internal purposes where performance is important.
IMPORTANT: See comments for fastHashCode(), too.

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale of the number

Returns:

the hash code

fastHashCode
```
public static int fastHashCode(int fastSignum,
                               long fast0,
                               long fast1,
                               long fast2,
                               int fastIntegerDigitCount,
                               int fastScale)
```
This is the original hash code as returned by OldHiveDecimal.
We need this when the OldHiveDecimal hash code has been exposed and and written or affected how data is written.
This method supports compatibility.
Examples: bucketing and the Hive hash() function.
NOTE: It is necessary to create a BigDecimal object and use its hash code, so this method is slow.

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale of the number

Returns:

the hash code

fastScaleByPowerOfTen

public static boolean fastScaleByPowerOfTen(FastHiveDecimal fastDec,
                                            int power,
                                            FastHiveDecimal fastResult)

fastScaleByPowerOfTen

public static boolean fastScaleByPowerOfTen(int fastSignum,
                                            long fast0,
                                            long fast1,
                                            long fast2,
                                            int fastIntegerDigitCount,
                                            int fastScale,
                                            int power,
                                            FastHiveDecimal fastResult)

doFastRound

public static boolean doFastRound(int fastSignum,
                                  long fast0,
                                  long fast1,
                                  long fast2,
                                  int fastIntegerDigitCount,
                                  int fastScale,
                                  int roundPower,
                                  int roundingMode,
                                  FastHiveDecimal fastResult)

fastRound

public static boolean fastRound(FastHiveDecimal fastDec,
                                int newScale,
                                int roundingMode,
                                FastHiveDecimal fastResult)

fastRound

public static boolean fastRound(int fastSignum,
                                long fast0,
                                long fast1,
                                long fast2,
                                int fastIntegerDigitCount,
                                int fastScale,
                                int newScale,
                                int roundingMode,
                                FastHiveDecimal fastResult)

fastRoundIntegerUp

public static boolean fastRoundIntegerUp(int fastSignum,
                                         long fast0,
                                         long fast1,
                                         long fast2,
                                         int fastIntegerDigitCount,
                                         int fastScale,
                                         int roundPower,
                                         FastHiveDecimal fastResult)

Fast decimal integer part rounding ROUND_UP.

ceiling(12400.8302, -2) = 12500 // E.g. Positive case FAST_ROUND_CEILING rr rrrr

Parameters:: fastSignum - the sign (-1, 0, or +1); fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; fastIntegerDigitCount - the number of integer digits; fastScale - the scale of the number; roundPower - the power to round to; fastResult - an object to reuse
Returns:: was the operation successful

fastRoundIntegerDown

public static boolean fastRoundIntegerDown(int fastSignum,
                                           long fast0,
                                           long fast1,
                                           long fast2,
                                           int fastIntegerDigitCount,
                                           int fastScale,
                                           int roundPower,
                                           FastHiveDecimal fastResult)

Fast decimal scale down by factor of 10 with rounding ROUND_DOWN.

The fraction being scaled away is thrown away.

The signum will be updated if the result is 0, otherwise the original sign is unchanged.

Parameters:: fastSignum - the sign (-1, 0, or +1); fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; fastIntegerDigitCount - the number of integer digits; fastScale - the scale of the number; roundPower - the power to round to; fastResult - an object to reuse
Returns:: was the operation successful?

fastRoundIntegerHalfUp

public static boolean fastRoundIntegerHalfUp(int fastSignum,
                                             long fast0,
                                             long fast1,
                                             long fast2,
                                             int fastIntegerDigitCount,
                                             int fastScale,
                                             int roundPower,
                                             FastHiveDecimal fastResult)

Fast decimal scale down by factor of 10 with rounding ROUND_HALF_UP.

When the fraction being scaled away is >= 0.5, the add 1.

Parameters:: fastSignum - the sign (-1, 0, or +1); fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; fastIntegerDigitCount - the number of integer digits; fastScale - the scale of the number; roundPower - the power to round to; fastResult - an object to reuse
Returns:: was the operation successful?

fastRoundIntegerHalfEven
```
public static boolean fastRoundIntegerHalfEven(int fastSignum,
                                               long fast0,
                                               long fast1,
                                               long fast2,
                                               int fastIntegerDigitCount,
                                               int fastScale,
                                               int roundPower,
                                               FastHiveDecimal fastResult)
```
Fast decimal scale down by factor of 10 with rounding ROUND_HALF_EVEN.
When the fraction being scaled away is exactly 0.5, then round and add 1 only if aaa. When fraction is not exactly 0.5, then if fraction > 0.5 then add 1. Otherwise, throw away fraction.
The signum will be updated if the result is 0, otherwise the original sign is unchanged.

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

fastIntegerDigitCount - the number of integer digits

fastScale - the scale of the number

roundPower - the power to round to

fastResult - an object to reuse

Returns:

was the operation successful?

fastScaleDownNoRound
```
public static boolean fastScaleDownNoRound(int fastSignum,
                                           long fast0,
                                           long fast1,
                                           long fast2,
                                           int scaleDown,
                                           FastHiveDecimal fastResult)
```
Fast decimal scale down by factor of 10 and do not allow rounding.
When the fraction being scaled away is non-zero, return false.
The signum will be updated if the result is 0, otherwise the original sign is unchanged.

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

scaleDown - the digits to scale down by

fastResult - an object to reuse

Returns:

was the operation successful?

fastRoundFractionalUp

public static boolean fastRoundFractionalUp(int fastSignum,
                                            long fast0,
                                            long fast1,
                                            long fast2,
                                            int scaleDown,
                                            FastHiveDecimal fastResult)

Fast decimal scale down by factor of 10 with rounding ROUND_UP.

When the fraction being scaled away is non-zero, the add 1.

Parameters:: fastSignum - the sign (-1, 0, or +1); fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; scaleDown - the number of integer digits to scale; fastResult - an object to reuse
Returns:: was the operation successfule?

fastRoundFractionalDown

public static void fastRoundFractionalDown(int fastSignum,
                                           long fast0,
                                           long fast1,
                                           long fast2,
                                           int scaleDown,
                                           FastHiveDecimal fastResult)

Fast decimal scale down by factor of 10 with rounding ROUND_DOWN.

The fraction being scaled away is thrown away.

Parameters:: fastSignum - the sign (-1, 0, or +1); fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; scaleDown - the number of integer digits to scale; fastResult - an object to reuse

fastRoundFractionalHalfUp

public static boolean fastRoundFractionalHalfUp(int fastSignum,
                                                long fast0,
                                                long fast1,
                                                long fast2,
                                                int scaleDown,
                                                FastHiveDecimal fastResult)

Fast decimal scale down by factor of 10 with rounding ROUND_HALF_UP.

When the fraction being scaled away is >= 0.5, the add 1.

Parameters:: fastSignum - the sign (-1, 0, or +1); fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; scaleDown - the number of integer digits to scale; fastResult - an object to reuse
Returns:: was the operation successfule?

fastRoundFractionalHalfUp5Words

public static boolean fastRoundFractionalHalfUp5Words(int fastSignum,
                                                      long fast0,
                                                      long fast1,
                                                      long fast2,
                                                      long fast3,
                                                      long fast4,
                                                      int scaleDown,
                                                      FastHiveDecimal fastResult)

Fast decimal scale down by factor of 10 with rounding ROUND_HALF_UP.

When the fraction being scaled away is >= 0.5, the add 1.

Parameters:: fastSignum - the sign (-1, 0, or +1); fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; fast3 - word 3; fast4 - word 4; scaleDown - the number of integer digits to scale; fastResult - an object to reuse
Returns:: was the operation successfule?

fastRoundFractionalHalfEven
```
public static boolean fastRoundFractionalHalfEven(int fastSignum,
                                                  long fast0,
                                                  long fast1,
                                                  long fast2,
                                                  int scaleDown,
                                                  FastHiveDecimal fastResult)
```
Fast decimal scale down by factor of 10 with rounding ROUND_HALF_EVEN.
When the fraction being scaled away is exactly 0.5, then round and add 1 only if aaa. When fraction is not exactly 0.5, then if fraction > 0.5 then add 1. Otherwise, throw away fraction.

Parameters:

fastSignum - the sign (-1, 0, or +1)

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

scaleDown - the number of integer digits to scale

fastResult - an object to reuse

Returns:

was the operation successfule?

doFastScaleDown

public static void doFastScaleDown(FastHiveDecimal fastDec,
                                   int scaleDown,
                                   FastHiveDecimal fastResult)

doFastScaleDown
```
public static void doFastScaleDown(long fast0,
                                   long fast1,
                                   long fast2,
                                   int scaleDown,
                                   FastHiveDecimal fastResult)
```
Fast decimal scale down by factor of 10 with NO rounding.
The signum will be updated if the result is 0, otherwise the original sign is unchanged.

Parameters:

fast0 - word 0 of the internal representation

fast1 - word 1

fast2 - word 2

scaleDown - the number of integer digits to scale

fastResult - an object to reuse

fastScaleUp

public static boolean fastScaleUp(FastHiveDecimal fastDec,
                                  int scaleUp,
                                  FastHiveDecimal fastResult)

fastScaleUp

public static boolean fastScaleUp(long fast0,
                                  long fast1,
                                  long fast2,
                                  int scaleUp,
                                  FastHiveDecimal fastResult)

Fast decimal scale up by factor of 10.

Parameters:: fast0 - word 0 of the internal representation; fast1 - word 1; fast2 - word 2; scaleUp - the number of integer digits to scale up by; fastResult - an object to reuse
Returns:: was the operation successfule?

fastLongWordTrailingZeroCount

public static int fastLongWordTrailingZeroCount(long longWord)

fastHighWordTrailingZeroCount

public static int fastHighWordTrailingZeroCount(long longWord)

fastLongWordPrecision

public static int fastLongWordPrecision(long longWord)

fastHighWordPrecision

public static int fastHighWordPrecision(long longWord)

fastSqlPrecision

public static int fastSqlPrecision(FastHiveDecimal fastDec)

fastSqlPrecision

public static int fastSqlPrecision(int fastSignum,
                                   long fast0,
                                   long fast1,
                                   long fast2,
                                   int fastIntegerDigitCount,
                                   int fastScale)

fastRawPrecision

public static int fastRawPrecision(FastHiveDecimal fastDec)

fastRawPrecision

public static int fastRawPrecision(int fastSignum,
                                   long fast0,
                                   long fast1,
                                   long fast2)

isAllZeroesBelow

public static boolean isAllZeroesBelow(int fastSignum,
                                       long fast0,
                                       long fast1,
                                       long fast2,
                                       int power)

fastExceedsPrecision

public static boolean fastExceedsPrecision(long fast0,
                                           long fast1,
                                           long fast2,
                                           int precision)

fastTrailingDecimalZeroCount

public static int fastTrailingDecimalZeroCount(long fast0,
                                               long fast1,
                                               long fast2,
                                               int fastIntegerDigitCount,
                                               int fastScale)

fastCheckPrecisionScale

public static FastHiveDecimal.FastCheckPrecisionScaleStatus fastCheckPrecisionScale(int fastSignum,
                                                                                    long fast0,
                                                                                    long fast1,
                                                                                    long fast2,
                                                                                    int fastIntegerDigitCount,
                                                                                    int fastScale,
                                                                                    int maxPrecision,
                                                                                    int maxScale)

fastUpdatePrecisionScale

public static boolean fastUpdatePrecisionScale(int fastSignum,
                                               long fast0,
                                               long fast1,
                                               long fast2,
                                               int fastIntegerDigitCount,
                                               int fastScale,
                                               int maxPrecision,
                                               int maxScale,
                                               FastHiveDecimal.FastCheckPrecisionScaleStatus status,
                                               FastHiveDecimal fastResult)

doAddSameScaleSameSign

public static boolean doAddSameScaleSameSign(FastHiveDecimal fastLeft,
                                             FastHiveDecimal fastRight,
                                             FastHiveDecimal fastResult)

doAddSameScaleSameSign

public static boolean doAddSameScaleSameSign(int resultSignum,
                                             long left0,
                                             long left1,
                                             long left2,
                                             long right0,
                                             long right1,
                                             long right2,
                                             FastHiveDecimal fastResult)

doSubtractSameScaleNoUnderflow

public static boolean doSubtractSameScaleNoUnderflow(int resultSignum,
                                                     FastHiveDecimal fastLeft,
                                                     FastHiveDecimal fastRight,
                                                     FastHiveDecimal fastResult)

doSubtractSameScaleNoUnderflow

public static boolean doSubtractSameScaleNoUnderflow(int resultSignum,
                                                     long left0,
                                                     long left1,
                                                     long left2,
                                                     long right0,
                                                     long right1,
                                                     long right2,
                                                     FastHiveDecimal fastResult)

doSubtractSameScaleNoUnderflow

public static boolean doSubtractSameScaleNoUnderflow(long left0,
                                                     long left1,
                                                     long left2,
                                                     long right0,
                                                     long right1,
                                                     long right2,
                                                     long[] result)

fastAdd

public static boolean fastAdd(FastHiveDecimal fastLeft,
                              FastHiveDecimal fastRight,
                              FastHiveDecimal fastResult)

fastAdd
```
public static boolean fastAdd(int leftSignum,
                              long leftFast0,
                              long leftFast1,
                              long leftFast2,
                              int leftIntegerDigitCount,
                              int leftScale,
                              int rightSignum,
                              long rightFast0,
                              long rightFast1,
                              long rightFast2,
                              int rightIntegerDigitCount,
                              int rightScale,
                              FastHiveDecimal fastResult)
```
Add the two decimals.
NOTE: Scale Determination for Addition/Subtraction
One could take the Math.min of the scales and adjust the operand with the lower scale have a scale = higher scale.
But this does not seem to work with decimals with widely varying scales as these:
598575157855521918987423259.94094 dec1 (int digits 27,scale 5) + 0.0000000000006711991169422033 dec2 (int digits 0, scale 28)
Trying to make dec1 to have a scale of 28 (i.e. by adding trailing zeroes) would exceed MAX_PRECISION (int digits 27 + 28 > 38).
In this example we need to make sure we have enough integer digit room in the result to handle dec1's digits. In order to maintain that, we will need to get rid of lower fractional digits of dec2. But when do we do that?
OldHiveDecimal.add does the full arithmetic add with all the digits using BigDecimal and then adjusts the result to fit in MAX_PRECISION, etc.
If we try to do pre-rounding dec2 it is problematic. We'd need to know if there is a carry in the arithmetic in order to know at which scale to do the rounding. This gets complicated.
So, the simplest thing is to emulate what OldHiveDecimal does and do the full digit addition and then fit the result afterwards.

Parameters:

leftSignum - The left sign (-1, 0, or +1)

leftFast0 - The left word 0 of reprentation

leftFast1 - word 1

leftFast2 - word 2

leftIntegerDigitCount - The left number of integer digits

leftScale - the left scale

rightSignum - The right sign (-1, 0, or +1)

rightFast0 - The right word 0 of reprentation

rightFast1 - word 1

rightFast2 - word 2

rightIntegerDigitCount - The right number of integer digits

rightScale - the right scale

fastResult - an object to reuse

Returns:

True if the addition was successful; Otherwise, false is returned on overflow.

fastSubtract

public static boolean fastSubtract(FastHiveDecimal fastLeft,
                                   FastHiveDecimal fastRight,
                                   FastHiveDecimal fastResult)

fastSubtract

public static boolean fastSubtract(int leftSignum,
                                   long leftFast0,
                                   long leftFast1,
                                   long leftFast2,
                                   int leftIntegerDigitCount,
                                   int leftScale,
                                   int rightSignum,
                                   long rightFast0,
                                   long rightFast1,
                                   long rightFast2,
                                   int rightIntegerDigitCount,
                                   int rightScale,
                                   FastHiveDecimal fastResult)

fastMultiply5x5HalfWords

public static boolean fastMultiply5x5HalfWords(FastHiveDecimal fastLeft,
                                               FastHiveDecimal fastRight,
                                               FastHiveDecimal fastResult)

fastMultiply5x5HalfWords

public static boolean fastMultiply5x5HalfWords(long left0,
                                               long left1,
                                               long left2,
                                               long right0,
                                               long right1,
                                               long right2,
                                               FastHiveDecimal fastResult)

Fast decimal multiplication on two decimals that have been already scaled and whose results will fit in 38 digits.

The caller is responsible checking for overflow within the highword and determining if scale down appropriate.

Returns:: Returns false if the multiplication resulted in large overflow. Values in result are undefined in that case.

fastMultiplyFullInternal

public static boolean fastMultiplyFullInternal(FastHiveDecimal fastLeft,
                                               FastHiveDecimal fastRight,
                                               long[] result)

fastMultiply5x5HalfWords

public static boolean fastMultiply5x5HalfWords(long left0,
                                               long left1,
                                               long left2,
                                               long right0,
                                               long right1,
                                               long right2,
                                               long[] result)

Fast decimal multiplication on two decimals that have been already scaled and whose results will fit in 38 digits.

The caller is responsible checking for overflow within the highword and determining if scale down appropriate.

Returns:: Returns false if the multiplication resulted in large overflow. Values in result are undefined in that case.

fastMultiplyFullInternal
```
public static boolean fastMultiplyFullInternal(long left0,
                                               long left1,
                                               long left2,
                                               long right0,
                                               long right1,
                                               long right2,
                                               long[] result)
```
Fast decimal multiplication on two decimals whose results are permitted to go beyond 38 digits to the maximum possible 76 digits. The caller is responsible for scaling and rounding the results back to 38 or fewer digits.
The caller is responsible for determining the signum.

Parameters:

left0 -

left1 -

left2 -

right0 -

right1 -

right2 -

result - This full result has 5 longs.

Returns:

Returns false if the multiplication resulted in an overflow. Values in result are undefined in that case.

fastMultiply5x6HalfWords
```
public static boolean fastMultiply5x6HalfWords(long left0,
                                               long left1,
                                               long left2,
                                               long right0,
                                               long right1,
                                               long right2,
                                               long[] result)
```
Fast decimal multiplication on two decimals whose results are permitted to go beyond 38 digits to the maximum possible 76 digits. The caller is responsible for scaling and rounding the results back to 38 or fewer digits.
The caller is responsible for determining the signum.

Parameters:

result - This full result has 5 longs.

Returns:

Returns false if the multiplication resulted in an overflow. Values in result are undefined in that case.

fastMultiply

public static boolean fastMultiply(FastHiveDecimal fastLeft,
                                   FastHiveDecimal fastRight,
                                   FastHiveDecimal fastResult)

fastMultiply

public static boolean fastMultiply(int leftSignum,
                                   long leftFast0,
                                   long leftFast1,
                                   long leftFast2,
                                   int leftIntegerDigitCount,
                                   int leftScale,
                                   int rightSignum,
                                   long rightFast0,
                                   long rightFast1,
                                   long rightFast2,
                                   int rightIntegerDigitCount,
                                   int rightScale,
                                   FastHiveDecimal fastResult)

fastDivide

public static boolean fastDivide(FastHiveDecimal fastLeft,
                                 FastHiveDecimal fastRight,
                                 FastHiveDecimal fastResult)

fastDivide

public static boolean fastDivide(int leftSignum,
                                 long leftFast0,
                                 long leftFast1,
                                 long leftFast2,
                                 int leftIntegerDigitCount,
                                 int leftScale,
                                 int rightSignum,
                                 long rightFast0,
                                 long rightFast1,
                                 long rightFast2,
                                 int rightIntegerDigitCount,
                                 int rightScale,
                                 FastHiveDecimal fastResult)

fastRemainder

public static boolean fastRemainder(int leftSignum,
                                    long leftFast0,
                                    long leftFast1,
                                    long leftFast2,
                                    int leftIntegerDigitCount,
                                    int leftScale,
                                    int rightSignum,
                                    long rightFast0,
                                    long rightFast1,
                                    long rightFast2,
                                    int rightIntegerDigitCount,
                                    int rightScale,
                                    FastHiveDecimal fastResult)

fastPow

public static boolean fastPow(int fastSignum,
                              long fast0,
                              long fast1,
                              long fast2,
                              int fastIntegerDigitCount,
                              int fastScale,
                              int exponent,
                              FastHiveDecimal fastResult)

fastToFormatString

public static String fastToFormatString(int fastSignum,
                                        long fast0,
                                        long fast1,
                                        long fast2,
                                        int fastIntegerDigitCount,
                                        int fastScale,
                                        int formatScale)

fastToFormatString

public static String fastToFormatString(int fastSignum,
                                        long fast0,
                                        long fast1,
                                        long fast2,
                                        int fastIntegerDigitCount,
                                        int fastScale,
                                        int formatScale,
                                        byte[] scratchBuffer)

fastToFormatBytes

public static int fastToFormatBytes(int fastSignum,
                                    long fast0,
                                    long fast1,
                                    long fast2,
                                    int fastIntegerDigitCount,
                                    int fastScale,
                                    int formatScale,
                                    byte[] scratchBuffer)

doFastToFormatBytes

public static int doFastToFormatBytes(int fastSignum,
                                      long fast0,
                                      long fast1,
                                      long fast2,
                                      int fastIntegerDigitCount,
                                      int fastScale,
                                      int formatScale,
                                      byte[] scratchBuffer)

fastToString

public static String fastToString(int fastSignum,
                                  long fast0,
                                  long fast1,
                                  long fast2,
                                  int fastIntegerDigitCount,
                                  int fastScale,
                                  int fastTrailingZeroesScale)

fastToString

public static String fastToString(int fastSignum,
                                  long fast0,
                                  long fast1,
                                  long fast2,
                                  int fastIntegerDigitCount,
                                  int fastScale,
                                  int fastTrailingZeroesScale,
                                  byte[] scratchBuffer)

fastToDigitsOnlyString

public static String fastToDigitsOnlyString(long fast0,
                                            long fast1,
                                            long fast2,
                                            int fastIntegerDigitCount)

fastToBytes

public static int fastToBytes(int fastSignum,
                              long fast0,
                              long fast1,
                              long fast2,
                              int fastIntegerDigitCount,
                              int fastScale,
                              int fastTrailingZeroesScale,
                              byte[] scratchBuffer)

fastToDigitsOnlyBytes

public static int fastToDigitsOnlyBytes(long fast0,
                                        long fast1,
                                        long fast2,
                                        int fastIntegerDigitCount,
                                        byte[] scratchBuffer)

fastIsValid

public static boolean fastIsValid(FastHiveDecimal fastDec)

fastIsValid

public static boolean fastIsValid(int fastSignum,
                                  long fast0,
                                  long fast1,
                                  long fast2,
                                  int fastIntegerDigitCount,
                                  int fastScale)

fastRaiseInvalidException

public static void fastRaiseInvalidException(FastHiveDecimal fastResult)

fastRaiseInvalidException

public static void fastRaiseInvalidException(FastHiveDecimal fastResult,
                                             String parameters)

getStackTraceAsSingleLine

public static String getStackTraceAsSingleLine(StackTraceElement[] stackTrace)

displayBytes

public static String displayBytes(byte[] bytes,
                                  int start,
                                  int length)

Class FastHiveDecimalImpl

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.kyuubi.jdbc.hive.common.FastHiveDecimal

Field Summary

Fields inherited from class org.apache.kyuubi.jdbc.hive.common.FastHiveDecimal

Constructor Summary

Method Summary

Methods inherited from class org.apache.kyuubi.jdbc.hive.common.FastHiveDecimal

Methods inherited from class java.lang.Object

Field Detail

MAX_DECIMAL_DIGITS

DECIMAL64_DECIMAL_DIGITS

MAX_ABS_DECIMAL64

BIG_INTEGER_MAX_DECIMAL

Constructor Detail

FastHiveDecimalImpl

Method Detail

fastSetFromBytes

fastSetFromDigitsOnlyBytesAndScale

fastSetFromBigDecimal

fastSetFromString

fastSetFromInt

fastSetFromLong

fastSetFromLongAndScale

fastSetFromFloat

fastSetFromDouble

fastSetFromBigInteger

fastSetFromBigInteger

fastSetFromBigInteger

fastFractionPortion

fastIntegerPortion

doBinaryToDecimalConversion

doDecimalToBinaryDivisionRemainder

fastSerializationUtilsRead

fastSerializationUtilsWrite

getDecimal64AbsMax

fastDeserialize64

fastSerialize64

fastSetFromBigIntegerBytesAndScale

fastBigIntegerBytes

fastBigIntegerBytesUnscaled

fastBigIntegerBytesScaled

fastIsByte

fastByteValueClip

fastIsShort

fastShortValueClip

fastIsInt

fastIntValueClip

fastIsLong

fastLongValueClip

fastFloatValue

fastDoubleValue

fastBigIntegerValue

fastBigIntegerValueUnscaled

fastBigIntegerValueScaled

fastBigDecimalValue

fastCompareTo

fastCompareTo

fastEquals

fastEquals

fastNewFasterHashCode

fastHashCode

fastScaleByPowerOfTen

fastScaleByPowerOfTen

doFastRound

fastRound

fastRound

fastRoundIntegerUp

fastRoundIntegerDown

fastRoundIntegerHalfUp

fastRoundIntegerHalfEven

fastScaleDownNoRound

fastRoundFractionalUp

fastRoundFractionalDown

fastRoundFractionalHalfUp

fastRoundFractionalHalfUp5Words

fastRoundFractionalHalfEven

doFastScaleDown

doFastScaleDown

fastScaleUp