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	bit_width

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 little_endian_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.
static int	bit_width()
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.
BasicDecimal256	getPointer(long i)
static BasicDecimal256	GetScaleMultiplier(int scale) \brief Scale multiplier for given scale value.
long	IsNegative()
Long4Array	little_endian_array() \brief Get the bits of the two's complement representation of the number.
BasicDecimal256	multiplyPut(BasicDecimal256 right) \brief Multiply this number by another number.
BasicDecimal256	Negate() \brief Negate the current value (in-place)
BasicDecimal256	position(long position)
arrow.DecimalStatus	Rescale(int original_scale, int new_scale, BasicDecimal256 out) \brief Convert BasicDecimal128 from one scale to another
BasicDecimal256	shiftLeftPut(int bits) \brief Shift left by the given number of bits.
long	Sign()
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, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, 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

bit_width

public static final int bit_width

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 little_endian_array)

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

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

bit_width

@MemberGetter
public static int bit_width()

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.

little_endian_array

@Const
 @ByRef
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. The bits within each uint64_t element are in native endian order. For example, BasicDecimal256(123).little_endian_array() = {123, 0, 0, 0}; BasicDecimal256(-2).little_endian_array() = {0xFF...FE, 0xFF...FF, 0xFF...FF, 0xFF...FF}.

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.

Rescale

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

\brief Convert BasicDecimal128 from one scale to another

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.