org.bytedeco.arrow

Class BasicDecimal128

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.arrow.BasicDecimal128

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

Decimal128

@Namespace(value="arrow")
 @NoOffset
 @Properties(inherit=arrow.class)
public class BasicDecimal128
extends Pointer

Represents a signed 128-bit integer in two's complement. This class is also compiled into LLVM IR - so, it should not have cpp references like streams and boost.

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields

Modifier and Type	Field and Description
static int	kBitWidth
static int	kMaxPrecision
static int	kMaxScale

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
BasicDecimal128() \brief Empty constructor creates a BasicDecimal128 with a value of 0.
BasicDecimal128(byte[] bytes)
BasicDecimal128(ByteBuffer bytes)
BasicDecimal128(BytePointer bytes) \brief Create a BasicDecimal128 from an array of bytes.
BasicDecimal128(long size) Native array allocator.
BasicDecimal128(Long2Array array) \brief Create a BasicDecimal256 from the two's complement representation.
BasicDecimal128(long high, long low) \brief Create a BasicDecimal128 from the two's complement representation.
BasicDecimal128(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
BasicDecimal128	Abs() \brief Absolute value (in-place)
static BasicDecimal128	Abs(BasicDecimal128 left) \brief Absolute value
BasicDecimal128	addPut(BasicDecimal128 right) \brief Add a number to this one.
BasicDecimal128	andPut(BasicDecimal128 right) \brief Bitwise "and" between two BasicDecimal128.
int	CountLeadingBinaryZeros() \brief count the number of leading binary zeroes.
arrow.DecimalStatus	Divide(BasicDecimal128 divisor, BasicDecimal128 result, BasicDecimal128 remainder) Divide this number by right and return the result.
BasicDecimal128	dividePut(BasicDecimal128 right) \brief In-place division.
boolean	FitsInPrecision(int precision) \brief Whether this number fits in the given precision Return true if the number of significant digits is less or equal to precision.
static BasicDecimal128	GetHalfScaleMultiplier(int scale) \brief Half-scale multiplier for given scale value.
static BasicDecimal128	GetMaxSentinel() \brief Get the maximum decimal value (is not a valid value).
static BasicDecimal128	GetMaxValue() \brief Get the maximum valid unscaled decimal value.
static BasicDecimal128	GetMinSentinel() \brief Get the minimum decimal value (is not a valid value).
BasicDecimal128	getPointer(long i)
static BasicDecimal128	GetScaleMultiplier(int scale) \brief Scale multiplier for given scale value.
void	GetWholeAndFraction(int scale, BasicDecimal128 whole, BasicDecimal128 fraction) \brief separate the integer and fractional parts for the given scale.
long	high_bits() \brief Get the high bits of the two's complement representation of the number.
BasicDecimal128	IncreaseScaleBy(int increase_by) \brief Scale up.
static int	kBitWidth()
static int	kMaxPrecision()
static int	kMaxScale()
Long2Array	little_endian_array() \brief Get the bits of the two's complement representation of the number.
long	low_bits() \brief Get the low bits of the two's complement representation of the number.
BasicDecimal128	multiplyPut(BasicDecimal128 right) \brief Multiply this number by another number.
BytePointer	mutable_native_endian_bytes()
Long2Array	native_endian_array() \brief Get the bits of the two's complement representation of the number.
BytePointer	native_endian_bytes()
BasicDecimal128	Negate() \brief Negate the current value (in-place)
BasicDecimal128	orPut(BasicDecimal128 right) \brief Bitwise "or" between two BasicDecimal128.
BasicDecimal128	position(long position)
BasicDecimal128	ReduceScaleBy(int reduce_by)
BasicDecimal128	ReduceScaleBy(int reduce_by, boolean round) \brief Scale down.
arrow.DecimalStatus	Rescale(int original_scale, int new_scale, BasicDecimal128 out) \brief Convert BasicDecimal128 from one scale to another
BasicDecimal128	shiftLeftPut(int bits) \brief Shift left by the given number of bits.
BasicDecimal128	shiftRightPut(int bits) \brief Shift right by the given number of bits.
long	Sign()
BasicDecimal128	subtractPut(BasicDecimal128 right) \brief Subtract a number from this one.
Byte16Array	ToBytes() \brief Return the raw bytes of the value in native-endian byte order.
void	ToBytes(byte[] out)
void	ToBytes(ByteBuffer out)
void	ToBytes(BytePointer out)

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, getDirectBufferAddress, getPointer, getPointer, getPointer, hashCode, interruptDeallocatorThread, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetAddress, offsetof, offsetof, parseBytes, physicalBytes, physicalBytesInaccurate, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, sizeof, toString, totalBytes, totalCount, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

kBitWidth

public static final int kBitWidth

kMaxPrecision

public static final int kMaxPrecision

kMaxScale

public static final int kMaxScale

Constructor Detail

BasicDecimal128

public BasicDecimal128(Pointer p)

Pointer cast constructor. Invokes Pointer(Pointer).

BasicDecimal128

public BasicDecimal128(long size)

Native array allocator. Access with Pointer.position(long).

BasicDecimal128

public BasicDecimal128(@Cast(value="int64_t")
                       long high,
                       @Cast(value="uint64_t")
                       long low)

\brief Create a BasicDecimal128 from the two's complement representation.

BasicDecimal128

public BasicDecimal128(@Const @ByRef
                       Long2Array array)

\brief Create a BasicDecimal256 from the two's complement representation. Input array is assumed to be in native endianness.

BasicDecimal128

public BasicDecimal128()

\brief Empty constructor creates a BasicDecimal128 with a value of 0.

BasicDecimal128

public BasicDecimal128(@Cast(value="const uint8_t*")
                       BytePointer bytes)

\brief Create a BasicDecimal128 from an array of bytes. Bytes are assumed to be in native-endian byte order.

BasicDecimal128

public BasicDecimal128(@Cast(value="const uint8_t*")
                       ByteBuffer bytes)

BasicDecimal128

public BasicDecimal128(@Cast(value="const uint8_t*")
                       byte[] bytes)

Method Detail

position

public BasicDecimal128 position(long position)

Overrides:

position in class Pointer

getPointer

public BasicDecimal128 getPointer(long i)

Overrides:

getPointer in class Pointer

kBitWidth

@MemberGetter
public static int kBitWidth()

kMaxPrecision

@MemberGetter
public static int kMaxPrecision()

kMaxScale

@MemberGetter
public static int kMaxScale()

Negate

@ByRef
public BasicDecimal128 Negate()

\brief Negate the current value (in-place)

Abs

@ByRef
public BasicDecimal128 Abs()

\brief Absolute value (in-place)

Abs

@ByVal
public static BasicDecimal128 Abs(@Const @ByRef
                                          BasicDecimal128 left)

\brief Absolute value

addPut

@ByRef
 @Name(value="operator +=")
public BasicDecimal128 addPut(@Const @ByRef
                                                                   BasicDecimal128 right)

\brief Add a number to this one. The result is truncated to 128 bits.

subtractPut

@ByRef
 @Name(value="operator -=")
public BasicDecimal128 subtractPut(@Const @ByRef
                                                                        BasicDecimal128 right)

\brief Subtract a number from this one. The result is truncated to 128 bits.

multiplyPut

@ByRef
 @Name(value="operator *=")
public BasicDecimal128 multiplyPut(@Const @ByRef
                                                                        BasicDecimal128 right)

\brief Multiply this number by another number. The result is truncated to 128 bits.

Divide

public arrow.DecimalStatus Divide(@Const @ByRef
                                  BasicDecimal128 divisor,
                                  BasicDecimal128 result,
                                  BasicDecimal128 remainder)

Divide this number by right and return the result. This operation is not destructive. The answer rounds to zero. Signs work like: 21 / 5 -> 4, 1 -21 / 5 -> -4, -1 21 / -5 -> -4, 1 -21 / -5 -> 4, -1

Parameters:

divisor - [in] the number to divide by

result - [out] the quotient

remainder - [out] the remainder after the division

dividePut

@ByRef
 @Name(value="operator /=")
public BasicDecimal128 dividePut(@Const @ByRef
                                                                      BasicDecimal128 right)

\brief In-place division.

orPut

@ByRef
 @Name(value="operator |=")
public BasicDecimal128 orPut(@Const @ByRef
                                                                  BasicDecimal128 right)

\brief Bitwise "or" between two BasicDecimal128.

andPut

@ByRef
 @Name(value="operator &=")
public BasicDecimal128 andPut(@Const @ByRef
                                                                   BasicDecimal128 right)

\brief Bitwise "and" between two BasicDecimal128.

shiftLeftPut

@ByRef
 @Name(value="operator <<=")
public BasicDecimal128 shiftLeftPut(@Cast(value="uint32_t")
                                                                          int bits)

\brief Shift left by the given number of bits.

shiftRightPut

@ByRef
 @Name(value="operator >>=")
public BasicDecimal128 shiftRightPut(@Cast(value="uint32_t")
                                                                           int bits)

\brief Shift right by the given number of bits. Negative values will

high_bits

@Cast(value="const int64_t")
public long high_bits()

\brief Get the high bits of the two's complement representation of the number.

low_bits

@Cast(value="const uint64_t")
public long low_bits()

\brief Get the low bits of the two's complement representation of the number.

native_endian_array

@ByVal
public Long2Array native_endian_array()

\brief Get the bits of the two's complement representation of the number. The 2 elements are in native endian order. The bits within each uint64_t element are in native endian order. For example, on a little endian machine, BasicDecimal128(123).native_endian_array() = {123, 0}; but on a big endian machine, BasicDecimal128(123).native_endian_array() = {0, 123};

little_endian_array

@ByVal
public Long2Array little_endian_array()

\brief Get the bits of the two's complement representation of the number. The 2 elements are in little endian order. However, the bits within each uint64_t element are in native endian order. For example, BasicDecimal128(123).little_endian_array() = {123, 0};

native_endian_bytes

@Cast(value="const uint8_t*")
public BytePointer native_endian_bytes()

mutable_native_endian_bytes

@Cast(value="uint8_t*")
public BytePointer mutable_native_endian_bytes()

ToBytes

@ByVal
public Byte16Array ToBytes()

\brief Return the raw bytes of the value in native-endian byte order.

ToBytes

public void ToBytes(@Cast(value="uint8_t*")
                    BytePointer out)

ToBytes

public void ToBytes(@Cast(value="uint8_t*")
                    ByteBuffer out)

ToBytes

public void ToBytes(@Cast(value="uint8_t*")
                    byte[] out)

GetWholeAndFraction

public void GetWholeAndFraction(int scale,
                                BasicDecimal128 whole,
                                BasicDecimal128 fraction)

\brief separate the integer and fractional parts for the given scale.

GetScaleMultiplier

@Const
 @ByRef
public static BasicDecimal128 GetScaleMultiplier(int scale)

\brief Scale multiplier for given scale value.

GetHalfScaleMultiplier

@Const
 @ByRef
public static BasicDecimal128 GetHalfScaleMultiplier(int scale)

\brief Half-scale multiplier for given scale value.

Rescale

public arrow.DecimalStatus Rescale(int original_scale,
                                   int new_scale,
                                   BasicDecimal128 out)

\brief Convert BasicDecimal128 from one scale to another

IncreaseScaleBy

@ByVal
public BasicDecimal128 IncreaseScaleBy(int increase_by)

\brief Scale up.

ReduceScaleBy

@ByVal
public BasicDecimal128 ReduceScaleBy(int reduce_by,
                                             @Cast(value="bool")
                                             boolean round)

\brief Scale down. - If 'round' is true, the right-most digits are dropped and the result value is rounded up (+1 for +ve, -1 for -ve) based on the value of the dropped digits (>= 10^reduce_by / 2). - If 'round' is false, the right-most digits are simply dropped.

ReduceScaleBy

@ByVal
public BasicDecimal128 ReduceScaleBy(int reduce_by)

FitsInPrecision

@Cast(value="bool")
public boolean FitsInPrecision(int precision)

\brief Whether this number fits in the given precision Return true if the number of significant digits is less or equal to precision.

Sign

@Cast(value="int64_t")
public long Sign()

CountLeadingBinaryZeros

public int CountLeadingBinaryZeros()

\brief count the number of leading binary zeroes.

GetMaxValue

@Const
 @ByRef
public static BasicDecimal128 GetMaxValue()

\brief Get the maximum valid unscaled decimal value.

GetMaxSentinel

@Const
 @ByVal
public static BasicDecimal128 GetMaxSentinel()

\brief Get the maximum decimal value (is not a valid value).

GetMinSentinel

@Const
 @ByVal
public static BasicDecimal128 GetMinSentinel()

\brief Get the minimum decimal value (is not a valid value).