org.bytedeco.arrow

Class BasicDecimal256

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.arrow.BasicDecimal256

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

Decimal256

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

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
BasicDecimal256() \brief Empty constructor creates a BasicDecimal256 with a value of 0.
BasicDecimal256(BasicDecimal128 value) \brief Convert any integer value into a BasicDecimal256.
BasicDecimal256(byte[] bytes)
BasicDecimal256(ByteBuffer bytes)
BasicDecimal256(BytePointer bytes) \brief Create a BasicDecimal256 from an array of bytes.
BasicDecimal256(long size) Native array allocator.
BasicDecimal256(Long4Array array) \brief Create a BasicDecimal256 from the two's complement representation.
BasicDecimal256(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
BasicDecimal256	Abs() \brief Absolute value (in-place)
static BasicDecimal256	Abs(BasicDecimal256 left) \brief Absolute value
BasicDecimal256	addPut(BasicDecimal256 right) \brief Add a number to this one.
arrow.DecimalStatus	Divide(BasicDecimal256 divisor, BasicDecimal256 result, BasicDecimal256 remainder) Divide this number by right and return the result.
BasicDecimal256	dividePut(BasicDecimal256 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 BasicDecimal256	GetHalfScaleMultiplier(int scale) \brief Half-scale multiplier for given scale value.
static BasicDecimal256	GetMaxSentinel() \brief Get the maximum decimal value (is not a valid value).
static BasicDecimal256	GetMinSentinel() \brief Get the minimum decimal value (is not a valid value).
BasicDecimal256	getPointer(long i)
static BasicDecimal256	GetScaleMultiplier(int scale) \brief Scale multiplier for given scale value.
BasicDecimal256	IncreaseScaleBy(int increase_by) \brief Scale up.
long	IsNegative()
static int	kBitWidth()
static int	kMaxPrecision()
static int	kMaxScale()
Long4Array	little_endian_array() \brief Get the bits of the two's complement representation of the number.
long	low_bits() \brief Get the lowest bits of the two's complement representation of the number.
BasicDecimal256	multiplyPut(BasicDecimal256 right) \brief Multiply this number by another number.
BytePointer	mutable_native_endian_bytes()
Long4Array	native_endian_array() \brief Get the bits of the two's complement representation of the number.
BytePointer	native_endian_bytes()
BasicDecimal256	Negate() \brief Negate the current value (in-place)
BasicDecimal256	position(long position)
BasicDecimal256	ReduceScaleBy(int reduce_by)
BasicDecimal256	ReduceScaleBy(int reduce_by, boolean round) \brief Scale down.
arrow.DecimalStatus	Rescale(int original_scale, int new_scale, BasicDecimal256 out) \brief Convert BasicDecimal256 from one scale to another
BasicDecimal256	shiftLeftPut(int bits) \brief Shift left by the given number of bits.
long	Sign()
BasicDecimal256	subtractPut(BasicDecimal256 right) \brief Subtract a number from this one.
Byte32Array	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, getPointer, getPointer, getPointer, hashCode, interruptDeallocatorThread, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetAddress, offsetof, offsetof, parseBytes, physicalBytes, 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

BasicDecimal256

public BasicDecimal256(Pointer p)

Pointer cast constructor. Invokes Pointer(Pointer).

BasicDecimal256

public BasicDecimal256(long size)

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

BasicDecimal256

public BasicDecimal256(@Const @ByRef
                       Long4Array array)

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

BasicDecimal256

public BasicDecimal256()

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

BasicDecimal256

public BasicDecimal256(@Const @ByRef
                       BasicDecimal128 value)

\brief Convert any integer value into a BasicDecimal256.

BasicDecimal256

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

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

BasicDecimal256

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

BasicDecimal256

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

Method Detail

position

public BasicDecimal256 position(long position)

Overrides:

position in class Pointer

getPointer

public BasicDecimal256 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 BasicDecimal256 Negate()

\brief Negate the current value (in-place)

Abs

@ByRef
public BasicDecimal256 Abs()

\brief Absolute value (in-place)

Abs

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

\brief Absolute value

addPut

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

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

subtractPut

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

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

native_endian_array

@Const
 @ByRef
public Long4Array native_endian_array()

\brief Get the bits of the two's complement representation of the number. The 4 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, BasicDecimal256(123).native_endian_array() = {123, 0, 0, 0}; BasicDecimal256(-2).native_endian_array() = {0xFF...FE, 0xFF...FF, 0xFF...FF, 0xFF...FF}. while on a big endian machine, BasicDecimal256(123).native_endian_array() = {0, 0, 0, 123}; BasicDecimal256(-2).native_endian_array() = {0xFF...FF, 0xFF...FF, 0xFF...FF, 0xFF...FE}.

little_endian_array

@Const
 @ByVal
public Long4Array little_endian_array()

\brief Get the bits of the two's complement representation of the number. The 4 elements are in little endian order. However, the bits within each uint64_t element are in native endian order. For example, BasicDecimal256(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()

low_bits

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

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

ToBytes

@ByVal
public Byte32Array 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)

GetScaleMultiplier

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

\brief Scale multiplier for given scale value.

GetHalfScaleMultiplier

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

\brief Half-scale multiplier for given scale value.

Rescale

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

\brief Convert BasicDecimal256 from one scale to another

IncreaseScaleBy

@ByVal
public BasicDecimal256 IncreaseScaleBy(int increase_by)

\brief Scale up.

ReduceScaleBy

@ByVal
public BasicDecimal256 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 positive, -1 for negative) 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 BasicDecimal256 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()

IsNegative

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

multiplyPut

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

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

Divide

public arrow.DecimalStatus Divide(@Const @ByRef
                                  BasicDecimal256 divisor,
                                  BasicDecimal256 result,
                                  BasicDecimal256 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

shiftLeftPut

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

\brief Shift left by the given number of bits.

dividePut

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

\brief In-place division.

GetMaxSentinel

@Const
 @ByVal
public static BasicDecimal256 GetMaxSentinel()

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

GetMinSentinel

@Const
 @ByVal
public static BasicDecimal256 GetMinSentinel()

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