ColumnVector (cudfjni 0.14 API)

java.lang.Object
- ai.rapids.cudf.ColumnVector

All Implemented Interfaces:

BinaryOperable, AutoCloseable
```
public final class ColumnVector
extends Object
implements AutoCloseable, BinaryOperable
```
This class represents the immutable vector of data. This class holds references to device(GPU) memory and is reference counted to know when to release it. Call close to decrement the reference count when you are done with the column, and call incRefCount to increment the reference count.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`ColumnVector.OffHeapState` Holds the off heap state of the column vector so we can clean it up, even if it is leaked.

Constructor Summary

Constructors
Constructor and Description
`ColumnVector(DType type, long rows, Optional<Long> nullCount, DeviceMemoryBuffer dataBuffer, DeviceMemoryBuffer validityBuffer, DeviceMemoryBuffer offsetBuffer)` Create a new column vector based off of data already on the device.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ColumnVector`	`abs()` Calculate the abs, output is the same type as input.
`Scalar`	`all()` Returns a boolean scalar that is true if all of the elements in the column are true or non-zero otherwise false.
`Scalar`	`all(DType outType)` Returns a scalar is true or 1, depending on the specified type, if all of the elements in the column are true or non-zero otherwise false or 0.
`Scalar`	`any()` Returns a boolean scalar that is true if any of the elements in the column are true or non-zero otherwise false.
`Scalar`	`any(DType outType)` Returns a scalar is true or 1, depending on the specified type, if any of the elements in the column are true or non-zero otherwise false or 0.
`ColumnVector`	`arccos()` Calculate the arccos, output is the same type as input.
`ColumnVector`	`arccosh()` Calculate the hyperbolic arccos, output is the same type as input.
`ColumnVector`	`arcsin()` Calculate the arcsin, output is the same type as input.
`ColumnVector`	`arcsinh()` Calculate the hyperbolic arcsin, output is the same type as input.
`ColumnVector`	`arctan()` Calculate the arctan, output is the same type as input.
`ColumnVector`	`arctanh()` Calculate the hyperbolic arctan, output is the same type as input.
`ColumnVector`	`asBytes()` Cast to Byte - ColumnVector This method takes the value provided by the ColumnVector and casts to byte When casting from a Date, Timestamp, or Boolean to a byte type the underlying numerical representation of the data will be used for the cast.
`ColumnVector`	`asDoubles()` Cast to Double - ColumnVector This method takes the value provided by the ColumnVector and casts to double When casting from a Date, Timestamp, or Boolean to a double type the underlying numerical representation of the data will be used for the cast.
`ColumnVector`	`asFloats()` Cast to Float - ColumnVector This method takes the value provided by the ColumnVector and casts to float When casting from a Date, Timestamp, or Boolean to a float type the underlying numerical representatio of the data will be used for the cast.
`ColumnVector`	`asInts()` Cast to Int - ColumnVector This method takes the value provided by the ColumnVector and casts to int When casting from a Date, Timestamp, or Boolean to a int type the underlying numerical representation of the data will be used for the cast.
`ColumnVector`	`asLongs()` Cast to Long - ColumnVector This method takes the value provided by the ColumnVector and casts to long When casting from a Date, Timestamp, or Boolean to a long type the underlying numerical representation of the data will be used for the cast.
`ColumnVector`	`asShorts()` Cast to Short - ColumnVector This method takes the value provided by the ColumnVector and casts to short When casting from a Date, Timestamp, or Boolean to a short type the underlying numerical representation of the data will be used for the cast.
`ColumnVector`	`asStrings()` Cast to Strings.
`ColumnVector`	`asStrings(String format)` Method to parse and convert a timestamp column vector to string column vector.
`ColumnVector`	`asTimestamp(DType timestampType, String format)` Parse a string to a timestamp.
`ColumnVector`	`asTimestampDays()` Cast to TIMESTAMP_DAYS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_DAYS
`ColumnVector`	`asTimestampDays(String format)` Cast to TIMESTAMP_DAYS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_DAYS
`ColumnVector`	`asTimestampMicroseconds()` Cast to TIMESTAMP_MICROSECONDS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_MICROSECONDS
`ColumnVector`	`asTimestampMicroseconds(String format)` Cast to TIMESTAMP_MICROSECONDS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_MICROSECONDS
`ColumnVector`	`asTimestampMilliseconds()` Cast to TIMESTAMP_MILLISECONDS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_MILLISECONDS.
`ColumnVector`	`asTimestampMilliseconds(String format)` Cast to TIMESTAMP_MILLISECONDS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_MILLISECONDS.
`ColumnVector`	`asTimestampNanoseconds()` Cast to TIMESTAMP_NANOSECONDS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_NANOSECONDS.
`ColumnVector`	`asTimestampNanoseconds(String format)` Cast to TIMESTAMP_NANOSECONDS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_NANOSECONDS.
`ColumnVector`	`asTimestampSeconds()` Cast to TIMESTAMP_SECONDS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_SECONDS
`ColumnVector`	`asTimestampSeconds(String format)` Cast to TIMESTAMP_SECONDS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_SECONDS
`ColumnVector`	`binaryOp(BinaryOp op, BinaryOperable rhs, DType outType)` Multiple different binary operations.
`ColumnVector`	`bitInvert()` invert the bits, output is the same type as input.
`static ColumnVector`	`boolFromBytes(byte... values)` Create a new vector from the given values.
`static ColumnVector`	`build(DType type, int rows, java.util.function.Consumer<HostColumnVector.Builder> init)` Create a new vector.
`static ColumnVector`	`build(int rows, long stringBufferSize, java.util.function.Consumer<HostColumnVector.Builder> init)`
`ColumnVector`	`castTo(DType type)` Generic method to cast ColumnVector When casting from a Date, Timestamp, or Boolean to a numerical type the underlying numerical representation of the data will be used for the cast.
`ColumnVector`	`cbrt()` Calculate the cube root, output is the same type as input.
`ColumnVector`	`ceil()` Calculate the ceil, output is the same type as input.
`ColumnVector`	`clamp(Scalar lo, Scalar hi)` Replaces values less than `lo` in `input` with `lo`, and values greater than `hi` with `hi`.
`ColumnVector`	`clamp(Scalar lo, Scalar loReplace, Scalar hi, Scalar hiReplace)` Replaces values less than `lo` in `input` with `lo_replace`, and values greater than `hi` with `hi_replace`.
`void`	`close()` Close this Vector and free memory allocated for HostMemoryBuffer and DeviceMemoryBuffer
`static ColumnVector`	`concatenate(ColumnVector... columns)` Create a new vector by concatenating multiple columns together.
`ColumnVector`	`contains(ColumnVector needles)` Returns a new ColumnVector of `DType.BOOL8` elements containing true if the corresponding entry in haystack is contained in needles and false if it is not.
`boolean`	`contains(Scalar needle)` Find if the `needle` is present in this col example: Single Column: idx 0 1 2 3 4 col = { 10, 20, 20, 30, 50 } Scalar: value = { 20 } result = true
`ColumnVector`	`containsRe(String pattern)` Returns a boolean ColumnVector identifying rows which match the given regex pattern starting at any location.
`HostColumnVector`	`copyToHost()` Copy the data to the host.
`ColumnVector`	`cos()` Calculate the cos, output is the same type as input.
`ColumnVector`	`cosh()` Calculate the hyperbolic cos, output is the same type as input.
`ColumnVector`	`day()` Get day from a timestamp.
`static ColumnVector`	`daysFromInts(int... values)` Create a new vector from the given values.
`ColumnVector`	`endsWith(Scalar pattern)` Checks if each string in a column ends with a specified comparison string, resulting in a parallel column of the boolean results.
`ColumnVector`	`exp()` Calculate the exp, output is the same type as input.
`Table`	`extractRe(String pattern)` For each captured group specified in the given regular expression return a column in the table.
`ColumnVector`	`findAndReplaceAll(ColumnVector oldValues, ColumnVector newValues)` Returns a vector with all values "oldValues[i]" replaced with "newValues[i]".
`ColumnVector`	`floor()` Calculate the floor, output is the same type as input.
`static ColumnVector`	`fromBoxedBooleans(Boolean... values)` Create a new vector from the given values.
`static ColumnVector`	`fromBoxedBytes(Byte... values)` Create a new vector from the given values.
`static ColumnVector`	`fromBoxedDoubles(Double... values)` Create a new vector from the given values.
`static ColumnVector`	`fromBoxedFloats(Float... values)` Create a new vector from the given values.
`static ColumnVector`	`fromBoxedInts(Integer... values)` Create a new vector from the given values.
`static ColumnVector`	`fromBoxedLongs(Long... values)` Create a new vector from the given values.
`static ColumnVector`	`fromBoxedShorts(Short... values)` Create a new vector from the given values.
`static ColumnVector`	`fromBytes(byte... values)` Create a new vector from the given values.
`static ColumnVector`	`fromDoubles(double... values)` Create a new vector from the given values.
`static ColumnVector`	`fromFloats(float... values)` Create a new vector from the given values.
`static ColumnVector`	`fromInts(int... values)` Create a new vector from the given values.
`static ColumnVector`	`fromLongs(long... values)` Create a new vector from the given values.
`static ColumnVector`	`fromScalar(Scalar scalar, int rows)` Create a new vector of length rows, where each row is filled with the Scalar's value
`static ColumnVector`	`fromShorts(short... values)` Create a new vector from the given values.
`static ColumnVector`	`fromStrings(String... values)` Create a new string vector from the given values.
`ColumnVector`	`getByteCount()` Retrieve the number of bytes for each string.
`ColumnVector`	`getCharLengths()` Retrieve the number of characters in each string.
`BaseDeviceMemoryBuffer`	`getDeviceBufferFor(BufferType type)` Get access to the raw device buffer for this column.
`long`	`getDeviceMemorySize()` Returns the amount of device memory used.
`long`	`getNativeView()` USE WITH CAUTION: This method exposes the address of the native cudf::column_view.
`long`	`getNullCount()` Returns the number of nulls in the data.
`long`	`getRowCount()` Returns the number of rows in this vector.
`DType`	`getType()` Returns the type of this vector.
`boolean`	`hasNulls()` Returns if the vector has nulls.
`boolean`	`hasValidityVector()` Returns if the vector has a validity vector allocated or not.
`ColumnVector`	`hour()` Get hour from a timestamp with time resolution.
`ColumnVector`	`ifElse(ColumnVector trueValues, ColumnVector falseValues)` For a BOOL8 vector, computes a vector whose rows are selected from two other vectors based on the boolean value of this vector in the corresponding row.
`ColumnVector`	`ifElse(ColumnVector trueValues, Scalar falseValue)` For a BOOL8 vector, computes a vector whose rows are selected from two other inputs based on the boolean value of this vector in the corresponding row.
`ColumnVector`	`ifElse(Scalar trueValue, ColumnVector falseValues)` For a BOOL8 vector, computes a vector whose rows are selected from two other inputs based on the boolean value of this vector in the corresponding row.
`ColumnVector`	`ifElse(Scalar trueValue, Scalar falseValue)` For a BOOL8 vector, computes a vector whose rows are selected from two other inputs based on the boolean value of this vector in the corresponding row.
`ColumnVector`	`incRefCount()` Increment the reference count for this column.
`ColumnVector`	`isFloat()` Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is a float, and FALSE if its not a float.
`ColumnVector`	`isInteger()` Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is an integer, and FALSE if its not an integer.
`ColumnVector`	`isNan()` Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is NaN, and FALSE if null or a valid floating point value
`ColumnVector`	`isNotNan()` Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is null or a valid floating point value, FALSE otherwise
`ColumnVector`	`isNotNull()` Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is not null, and FALSE for any null entry (as per the validity mask)
`ColumnVector`	`isNull()` Returns a Boolean vector with the same number of rows as this instance, that has FALSE for any entry that is not null, and TRUE for any null entry (as per the validity mask)
`ColumnVector`	`log()` Calculate the log, output is the same type as input.
`ColumnVector`	`log10()` Calculate the log with base 10, output is the same type as input.
`ColumnVector`	`log2()` Calculate the log with base 2, output is the same type as input.
`ColumnVector`	`lower()` Convert a string to lower case.
`ColumnVector`	`lstrip()` Removes whitespace from the beginning of a string.
`ColumnVector`	`lstrip(Scalar toStrip)` Removes the specified characters from the beginning of each string.
`ColumnVector`	`matchesRe(String pattern)` Returns a boolean ColumnVector identifying rows which match the given regex pattern but only at the beginning of the string.
`Scalar`	`max()` Returns the maximum of all values in the column, returning a scalar of the same type as this column.
`Scalar`	`max(DType outType)` Returns the maximum of all values in the column, returning a scalar of the specified type.
`Scalar`	`mean()` Returns the arithmetic mean of all values in the column, returning a FLOAT64 scalar unless the column type is FLOAT32 then a FLOAT32 scalar is returned.
`Scalar`	`mean(DType outType)` Returns the arithmetic mean of all values in the column, returning a scalar of the specified type.
`Scalar`	`min()` Returns the minimum of all values in the column, returning a scalar of the same type as this column.
`Scalar`	`min(DType outType)` Returns the minimum of all values in the column, returning a scalar of the specified type.
`ColumnVector`	`minute()` Get minute from a timestamp with time resolution.
`ColumnVector`	`month()` Get month from a timestamp.
`ColumnVector`	`nansToNulls()` Returns a new ColumnVector with NaNs converted to nulls, preserving the existing null values.
`ColumnVector`	`normalizeNANsAndZeros()` Create a new vector of "normalized" values, where: 1.
`ColumnVector`	`not()` Returns a vector of the logical `not` of each value in the input column (this)
`void`	`noWarnLeakExpected()` This is a really ugly API, but it is possible that the lifecycle of a column of data may not have a clear lifecycle thanks to java and GC.
`Scalar`	`product()` Returns the product of all values in the column, returning a scalar of the same type as this column.
`Scalar`	`product(DType outType)` Returns the product of all values in the column, returning a scalar of the specified type.
`ColumnVector`	`quantile(QuantileMethod method, double[] quantiles)` Calculate various quantiles of this ColumnVector.
`Scalar`	`reduce(ai.rapids.cudf.AggregateOp op)` Computes the reduction of the values in all rows of a column.
`Scalar`	`reduce(ai.rapids.cudf.AggregateOp op, DType outType)` Computes the reduction of the values in all rows of a column.
`ColumnVector`	`replaceNulls(Scalar scalar)` Returns a ColumnVector with any null values replaced with a scalar.
`ColumnVector`	`rint()` Rounds a floating-point argument to the closest integer value, but returns it as a float.
`ColumnVector`	`rollingWindow(ai.rapids.cudf.AggregateOp op, WindowOptions options)` This function aggregates values in a window around each element i of the input column.
`ColumnVector`	`rstrip()` Removes whitespace from the end of a string.
`ColumnVector`	`rstrip(Scalar toStrip)` Removes the specified characters from the end of each string.
`ColumnVector`	`second()` Get second from a timestamp with time resolution.
`static ColumnVector`	`sequence(Scalar initialValue, int rows)` Create a new vector of length rows, starting at the initialValue and going by 1 each time.
`static ColumnVector`	`sequence(Scalar initialValue, Scalar step, int rows)` Create a new vector of length rows, starting at the initialValue and going by step each time.
`ColumnVector`	`sin()` Calculate the sin, output is the same type as input.
`ColumnVector`	`sinh()` Calculate the hyperbolic sin, output is the same type as input.
`ColumnVector[]`	`slice(int... indices)` Slices a column (including null values) into a set of columns according to a set of indices.
`ColumnVector[]`	`split(int... indices)` Splits a column (including null values) into a set of columns according to a set of indices.
`ColumnVector`	`sqrt()` Calculate the sqrt, output is the same type as input.
`Scalar`	`standardDeviation()` Returns the sample standard deviation of all values in the column, returning a FLOAT64 scalar unless the column type is FLOAT32 then a FLOAT32 scalar is returned.
`Scalar`	`standardDeviation(DType outType)` Returns the sample standard deviation of all values in the column, returning a scalar of the specified type.
`ColumnVector`	`startsWith(Scalar pattern)` Checks if each string in a column starts with a specified comparison string, resulting in a parallel column of the boolean results.
`ColumnVector`	`stringConcatenate(ColumnVector[] columns)` Concatenate columns of strings together, combining a corresponding row from each column into a single string row of a new column with no separator string inserted between each combined string and maintaining null values in combined rows.
`static ColumnVector`	`stringConcatenate(Scalar separator, Scalar narep, ColumnVector[] columns)` Concatenate columns of strings together, combining a corresponding row from each column into a single string row of a new column.
`ColumnVector`	`stringContains(Scalar compString)` Checks if each string in a column contains a specified comparison string, resulting in a parallel column of the boolean results.
`ColumnVector`	`stringLocate(Scalar substring)` Locates the starting index of the first instance of the given string in each row of a column.
`ColumnVector`	`stringLocate(Scalar substring, int start)` Locates the starting index of the first instance of the given string in each row of a column.
`ColumnVector`	`stringLocate(Scalar substring, int start, int end)` Locates the starting index of the first instance of the given string in each row of a column.
`ColumnVector`	`stringReplace(Scalar target, Scalar replace)` Returns a new strings column where target string within each string is replaced with the specified replacement string.
`ColumnVector`	`stringReplaceWithBackrefs(String pattern, String replace)` For each string, replaces any character sequence matching the given pattern using the replace template for back-references.
`Table`	`stringSplit()` Returns a list of columns by splitting each string using whitespace as the delimiter.
`Table`	`stringSplit(Scalar delimiter)` Returns a list of columns by splitting each string using the specified delimiter.
`ColumnVector`	`strip()` Removes whitespace from the beginning and end of a string.
`ColumnVector`	`strip(Scalar toStrip)` Removes the specified characters from the beginning and end of each string.
`ColumnVector`	`substring(ColumnVector start, ColumnVector end)` Returns a new strings column that contains substrings of the strings in the provided column which uses unique ranges for each string
`ColumnVector`	`substring(int start)` Returns a new strings column that contains substrings of the strings in the provided column.
`ColumnVector`	`substring(int start, int end)` Returns a new strings column that contains substrings of the strings in the provided column.
`ColumnVector`	`subVector(int start)` Return a subVector from start inclusive to the end of the vector.
`ColumnVector`	`subVector(int start, int end)` Return a subVector.
`Scalar`	`sum()` Computes the sum of all values in the column, returning a scalar of the same type as this column.
`Scalar`	`sum(DType outType)` Computes the sum of all values in the column, returning a scalar of the specified type.
`Scalar`	`sumOfSquares()` Returns the sum of squares of all values in the column, returning a scalar of the same type as this column.
`Scalar`	`sumOfSquares(DType outType)` Returns the sum of squares of all values in the column, returning a scalar of the specified type.
`ColumnVector`	`tan()` Calculate the tan, output is the same type as input.
`ColumnVector`	`tanh()` Calculate the hyperbolic tan, output is the same type as input.
`static ColumnVector`	`timestampDaysFromBoxedInts(Integer... values)` Create a new vector from the given values.
`static ColumnVector`	`timestampMicroSecondsFromBoxedLongs(Long... values)` Create a new vector from the given values.
`static ColumnVector`	`timestampMicroSecondsFromLongs(long... values)` Create a new vector from the given values.
`static ColumnVector`	`timestampMilliSecondsFromBoxedLongs(Long... values)` Create a new vector from the given values.
`static ColumnVector`	`timestampMilliSecondsFromLongs(long... values)` Create a new vector from the given values.
`static ColumnVector`	`timestampNanoSecondsFromBoxedLongs(Long... values)` Create a new vector from the given values.
`static ColumnVector`	`timestampNanoSecondsFromLongs(long... values)` Create a new vector from the given values.
`static ColumnVector`	`timestampSecondsFromBoxedLongs(Long... values)` Create a new vector from the given values.
`static ColumnVector`	`timestampSecondsFromLongs(long... values)` Create a new vector from the given values.
`String`	`toString()`
`ColumnVector`	`toTitle()` Returns a column of strings where, for each string row in the input, the first character after spaces is modified to upper-case, while all the remaining characters in a word are modified to lower-case.
`ColumnVector`	`transform(String udf, boolean isPtx)` Transform a vector using a custom function.
`ColumnVector`	`unaryOp(UnaryOp op)` Multiple different unary operations.
`ColumnVector`	`upper()` Convert a string to upper case.
`Scalar`	`variance()` Returns the variance of all values in the column, returning a FLOAT64 scalar unless the column type is FLOAT32 then a FLOAT32 scalar is returned.
`Scalar`	`variance(DType outType)` Returns the variance of all values in the column, returning a scalar of the specified type.
`ColumnVector`	`year()` Get year from a timestamp.

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

Methods inherited from interface ai.rapids.cudf.BinaryOperable
add, add, and, and, arctan2, arctan2, bitAnd, bitAnd, bitOr, bitOr, bitXor, bitXor, div, div, equalTo, equalTo, equalToNullAware, equalToNullAware, floorDiv, floorDiv, greaterOrEqualTo, greaterOrEqualTo, greaterThan, greaterThan, implicitConversion, lessOrEqualTo, lessOrEqualTo, lessThan, lessThan, log, log, maxNullAware, maxNullAware, minNullAware, minNullAware, mod, mod, mul, mul, notEqualTo, notEqualTo, or, or, pmod, pmod, pow, pow, shiftLeft, shiftLeft, shiftRight, shiftRight, shiftRightUnsigned, shiftRightUnsigned, sub, sub, trueDiv, trueDiv

- Constructor Detail
  - ColumnVector
```
public ColumnVector(DType type,
                    long rows,
                    Optional<Long> nullCount,
                    DeviceMemoryBuffer dataBuffer,
                    DeviceMemoryBuffer validityBuffer,
                    DeviceMemoryBuffer offsetBuffer)
```
    Create a new column vector based off of data already on the device.
    
    Parameters:
    
    type - the type of the vector
    
    rows - the number of rows in this vector.
    
    nullCount - the number of nulls in the dataset.
    
    dataBuffer - the data stored on the device. The column vector takes ownership of the buffer. Do not use the buffer after calling this.
    
    validityBuffer - an optional validity buffer. Must be provided if nullCount != 0. The column vector takes ownership of the buffer. Do not use the buffer after calling this.
    
    offsetBuffer - a host buffer required for strings and string categories. The column vector takes ownership of the buffer. Do not use the buffer after calling this.
- Method Detail
  - toTitle
```
public ColumnVector toTitle()
```
    Returns a column of strings where, for each string row in the input, the first character after spaces is modified to upper-case, while all the remaining characters in a word are modified to lower-case. Any null string entries return corresponding null output column entries
  - noWarnLeakExpected
```
public void noWarnLeakExpected()
```
    This is a really ugly API, but it is possible that the lifecycle of a column of data may not have a clear lifecycle thanks to java and GC. This API informs the leak tracking code that this is expected for this column, and big scary warnings should not be printed when this happens.
  - close
```
public void close()
```
    Close this Vector and free memory allocated for HostMemoryBuffer and DeviceMemoryBuffer
    
    Specified by:
    
    close in interface AutoCloseable
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - incRefCount
```
public ColumnVector incRefCount()
```
    Increment the reference count for this column. You need to call close on this to decrement the reference count again.
  - nansToNulls
```
public ColumnVector nansToNulls()
```
    Returns a new ColumnVector with NaNs converted to nulls, preserving the existing null values.
  - getRowCount
```
public long getRowCount()
```
    Returns the number of rows in this vector.
  - getDeviceMemorySize
```
public long getDeviceMemorySize()
```
    Returns the amount of device memory used.
  - getType
```
public DType getType()
```
    Returns the type of this vector.
    
    Specified by:
    
    getType in interface BinaryOperable
  - getNullCount
```
public long getNullCount()
```
    Returns the number of nulls in the data. Note that this might end up being a very expensive operation because if the null count is not known it will be calculated.
  - hasValidityVector
```
public boolean hasValidityVector()
```
    Returns if the vector has a validity vector allocated or not.
  - hasNulls
```
public boolean hasNulls()
```
    Returns if the vector has nulls. Note that this might end up being a very expensive operation because if the null count is not known it will be calculated.
  - copyToHost
```
public HostColumnVector copyToHost()
```
    Copy the data to the host.
  - getDeviceBufferFor
```
public BaseDeviceMemoryBuffer getDeviceBufferFor(BufferType type)
```
    Get access to the raw device buffer for this column. This is intended to be used with a lot of caution. The lifetime of the buffer is tied to the lifetime of the column (Do not close the buffer, as the column will take care of it). Do not modify the contents of the buffer or it might negatively impact what happens on the column. The data must be on the device for this to work. Strings and string categories do not currently work because their underlying device layout is currently hidden.
    
    Parameters:
    
    type - the type of buffer to get access to.
    
    Returns:
    
    the underlying buffer or null if no buffer is associated with it for this column. Please note that if the column is empty there may be no buffers at all associated with the column.
  - getCharLengths
```
public ColumnVector getCharLengths()
```
    Retrieve the number of characters in each string. Null strings will have value of null.
    
    Returns:
    
    ColumnVector holding length of string at index 'i' in the original vector
  - getByteCount
```
public ColumnVector getByteCount()
```
    Retrieve the number of bytes for each string. Null strings will have value of null.
    
    Returns:
    
    ColumnVector, where each element at i = byte count of string at index 'i' in the original vector
  - isNotNull
```
public ColumnVector isNotNull()
```
    Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is not null, and FALSE for any null entry (as per the validity mask)
    
    Returns:
    
    - Boolean vector
  - isNull
```
public ColumnVector isNull()
```
    Returns a Boolean vector with the same number of rows as this instance, that has FALSE for any entry that is not null, and TRUE for any null entry (as per the validity mask)
    
    Returns:
    
    - Boolean vector
  - isInteger
```
public ColumnVector isInteger()
```
    Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is an integer, and FALSE if its not an integer. A null will be returned for null entries NOTE: Integer doesn't mean a 32-bit integer. It means a number that is not a fraction. i.e. If this method returns true for a value it could still result in an overflow or underflow if you convert it to a Java integral type
    
    Returns:
    
    - Boolean vector
  - isFloat
```
public ColumnVector isFloat()
```
    Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is a float, and FALSE if its not a float. A null will be returned for null entries NOTE: Float doesn't mean a 32-bit float. It means a number that is a fraction or can be written as a fraction. i.e. This method will return true for integers as well as floats. Also note if this method returns true for a value it could still result in an overflow or underflow if you convert it to a Java float or double
    
    Returns:
    
    - Boolean vector
  - isNan
```
public ColumnVector isNan()
```
    Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is NaN, and FALSE if null or a valid floating point value
    
    Returns:
    
    - Boolean vector
  - isNotNan
```
public ColumnVector isNotNan()
```
    Returns a Boolean vector with the same number of rows as this instance, that has TRUE for any entry that is null or a valid floating point value, FALSE otherwise
    
    Returns:
    
    - Boolean vector
  - findAndReplaceAll
```
public ColumnVector findAndReplaceAll(ColumnVector oldValues,
                                      ColumnVector newValues)
```
    Returns a vector with all values "oldValues[i]" replaced with "newValues[i]". Warning: Currently this function doesn't work for Strings or StringCategories. NaNs can't be replaced in the original vector but regular values can be replaced with NaNs Nulls can't be replaced in the original vector but regular values can be replaced with Nulls Mixing of types isn't allowed, the resulting vector will be the same type as the original. e.g. You can't replace an integer vector with values from a long vector Usage: this = {1, 4, 5, 1, 5} oldValues = {1, 5, 7} newValues = {2, 6, 9} result = this.findAndReplaceAll(oldValues, newValues); result = {2, 4, 6, 2, 6} (1 and 5 replaced with 2 and 6 but 7 wasn't found so no change)
    
    Parameters:
    
    oldValues - - A vector containing values that should be replaced
    
    newValues - - A vector containing new values
    
    Returns:
    
    - A new vector containing the old values replaced with new values
  - replaceNulls
```
public ColumnVector replaceNulls(Scalar scalar)
```
    Returns a ColumnVector with any null values replaced with a scalar. The types of the input ColumnVector and Scalar must match, else an error is thrown.
    
    Parameters:
    
    scalar - - Scalar value to use as replacement
    
    Returns:
    
    - ColumnVector with nulls replaced by scalar
  - ifElse
```
public ColumnVector ifElse(ColumnVector trueValues,
                           ColumnVector falseValues)
```
    For a BOOL8 vector, computes a vector whose rows are selected from two other vectors based on the boolean value of this vector in the corresponding row. If the boolean value in a row is true, the corresponding row is selected from trueValues otherwise the corresponding row from falseValues is selected. Note that trueValues and falseValues vectors must be the same length as this vector, and trueValues and falseValues must have the same data type.
    
    Parameters:
    
    trueValues - the values to select if a row in this column is true
    
    falseValues - the values to select if a row in this column is not true
    
    Returns:
    
    the computed vector
  - ifElse
```
public ColumnVector ifElse(ColumnVector trueValues,
                           Scalar falseValue)
```
    For a BOOL8 vector, computes a vector whose rows are selected from two other inputs based on the boolean value of this vector in the corresponding row. If the boolean value in a row is true, the corresponding row is selected from trueValues otherwise the value from falseValue is selected. Note that trueValues must be the same length as this vector, and trueValues and falseValue must have the same data type. Note that the trueValues vector and falseValue scalar must have the same data type.
    
    Parameters:
    
    trueValues - the values to select if a row in this column is true
    
    falseValue - the value to select if a row in this column is not true
    
    Returns:
    
    the computed vector
  - ifElse
```
public ColumnVector ifElse(Scalar trueValue,
                           ColumnVector falseValues)
```
    For a BOOL8 vector, computes a vector whose rows are selected from two other inputs based on the boolean value of this vector in the corresponding row. If the boolean value in a row is true, the value from trueValue is selected otherwise the corresponding row from falseValues is selected. Note that falseValues must be the same length as this vector, and trueValue and falseValues must have the same data type. Note that the trueValue scalar and falseValues vector must have the same data type.
    
    Parameters:
    
    trueValue - the value to select if a row in this column is true
    
    falseValues - the values to select if a row in this column is not true
    
    Returns:
    
    the computed vector
  - ifElse
```
public ColumnVector ifElse(Scalar trueValue,
                           Scalar falseValue)
```
    For a BOOL8 vector, computes a vector whose rows are selected from two other inputs based on the boolean value of this vector in the corresponding row. If the boolean value in a row is true, the value from trueValue is selected otherwise the value from falseValue is selected. Note that the trueValue and falseValue scalars must have the same data type.
    
    Parameters:
    
    trueValue - the value to select if a row in this column is true
    
    falseValue - the value to select if a row in this column is not true
    
    Returns:
    
    the computed vector
  - slice
```
public ColumnVector[] slice(int... indices)
```
    Slices a column (including null values) into a set of columns according to a set of indices. The caller owns the ColumnVectors and is responsible closing them The "slice" function divides part of the input column into multiple intervals of rows using the indices values and it stores the intervals into the output columns. Regarding the interval of indices, a pair of values are taken from the indices array in a consecutive manner. The pair of indices are left-closed and right-open. The pairs of indices in the array are required to comply with the following conditions: a, b belongs to Range[0, input column size] a <= b, where the position of a is less or equal to the position of b. Exceptional cases for the indices array are: When the values in the pair are equal, the function returns an empty column. When the values in the pair are 'strictly decreasing', the outcome is undefined. When any of the values in the pair don't belong to the range[0, input column size), the outcome is undefined. When the indices array is empty, an empty vector of columns is returned. The caller owns the output ColumnVectors and is responsible for closing them.
    
    Parameters:
    
    indices -
    
    Returns:
    
    A new ColumnVector array with slices from the original ColumnVector
  - subVector
```
public ColumnVector subVector(int start)
```
    Return a subVector from start inclusive to the end of the vector.
    
    Parameters:
    
    start - the index to start at.
  - subVector
```
public ColumnVector subVector(int start,
                              int end)
```
    Return a subVector.
    
    Parameters:
    
    start - the index to start at (inclusive).
    
    end - the index to end at (exclusive).
  - split
```
public ColumnVector[] split(int... indices)
```
    Splits a column (including null values) into a set of columns according to a set of indices. The caller owns the ColumnVectors and is responsible closing them. The "split" function divides the input column into multiple intervals of rows using the splits indices values and it stores the intervals into the output columns. Regarding the interval of indices, a pair of values are taken from the indices array in a consecutive manner. The pair of indices are left-closed and right-open. The indices array ('splits') is require to be a monotonic non-decreasing set. The indices in the array are required to comply with the following conditions: a, b belongs to Range[0, input column size] a <= b, where the position of a is less or equal to the position of b. The split function will take a pair of indices from the indices array ('splits') in a consecutive manner. For the first pair, the function will take the value 0 and the first element of the indices array. For the last pair, the function will take the last element of the indices array and the size of the input column. Exceptional cases for the indices array are: When the values in the pair are equal, the function return an empty column. When the values in the pair are 'strictly decreasing', the outcome is undefined. When any of the values in the pair don't belong to the range[0, input column size), the outcome is undefined. When the indices array is empty, an empty vector of columns is returned. The input columns may have different sizes. The number of columns must be equal to the number of indices in the array plus one. Example: input: {10, 12, 14, 16, 18, 20, 22, 24, 26, 28} splits: {2, 5, 9} output: {{10, 12}, {14, 16, 18}, {20, 22, 24, 26}, {28}} Note that this is very similar to the output from a PartitionedTable.
    
    Parameters:
    
    indices - the indexes to split with
    
    Returns:
    
    A new ColumnVector array with slices from the original ColumnVector
  - fromScalar
```
public static ColumnVector fromScalar(Scalar scalar,
                                      int rows)
```
    Create a new vector of length rows, where each row is filled with the Scalar's value
    
    Parameters:
    
    scalar - - Scalar to use to fill rows
    
    rows - - Number of rows in the new ColumnVector
    
    Returns:
    
    - new ColumnVector
  - sequence
```
public static ColumnVector sequence(Scalar initialValue,
                                    Scalar step,
                                    int rows)
```
    Create a new vector of length rows, starting at the initialValue and going by step each time. Only numeric types are supported.
    
    Parameters:
    
    initialValue - the initial value to start at.
    
    step - the step to add to each subsequent row.
    
    rows - the total number of rows
    
    Returns:
    
    the new ColumnVector.
  - sequence
```
public static ColumnVector sequence(Scalar initialValue,
                                    int rows)
```
    Create a new vector of length rows, starting at the initialValue and going by 1 each time. Only numeric types are supported.
    
    Parameters:
    
    initialValue - the initial value to start at.
    
    rows - the total number of rows
    
    Returns:
    
    the new ColumnVector.
  - concatenate
```
public static ColumnVector concatenate(ColumnVector... columns)
```
    Create a new vector by concatenating multiple columns together. Note that all columns must have the same type.
  - normalizeNANsAndZeros
```
public ColumnVector normalizeNANsAndZeros()
```
    Create a new vector of "normalized" values, where: 1. All representations of NaN (and -NaN) are replaced with the normalized NaN value 2. All elements equivalent to 0.0 (including +0.0 and -0.0) are replaced with +0.0. 3. All elements that are not equivalent to NaN or 0.0 remain unchanged. The documentation for Double.longBitsToDouble(long) describes how equivalent values of NaN/-NaN might have different bitwise representations. This method may be used to compare different bitwise values of 0.0 or NaN as logically equivalent. For instance, if these values appear in a groupby key column, without normalization 0.0 and -0.0 would be erroneously treated as distinct groups, as will each representation of NaN.
    
    Returns:
    
    A new ColumnVector with all elements equivalent to NaN/0.0 replaced with a normalized equivalent.
  - year
```
public ColumnVector year()
```
    Get year from a timestamp.
    Postconditions - A new vector is allocated with the result. The caller owns the vector and is responsible for its lifecycle.
    
    Returns:
    
    - A new INT16 vector allocated on the GPU.
  - month
```
public ColumnVector month()
```
    Get month from a timestamp.
    Postconditions - A new vector is allocated with the result. The caller owns the vector and is responsible for its lifecycle.
    
    Returns:
    
    - A new INT16 vector allocated on the GPU.
  - day
```
public ColumnVector day()
```
    Get day from a timestamp.
    Postconditions - A new vector is allocated with the result. The caller owns the vector and is responsible for its lifecycle.
    
    Returns:
    
    - A new INT16 vector allocated on the GPU.
  - hour
```
public ColumnVector hour()
```
    Get hour from a timestamp with time resolution.
    Postconditions - A new vector is allocated with the result. The caller owns the vector and is responsible for its lifecycle.
    
    Returns:
    
    - A new INT16 vector allocated on the GPU.
  - minute
```
public ColumnVector minute()
```
    Get minute from a timestamp with time resolution.
    Postconditions - A new vector is allocated with the result. The caller owns the vector and is responsible for its lifecycle.
    
    Returns:
    
    - A new INT16 vector allocated on the GPU.
  - second
```
public ColumnVector second()
```
    Get second from a timestamp with time resolution.
    Postconditions - A new vector is allocated with the result. The caller owns the vector and is responsible for its lifecycle.
    
    Returns:
    
    - A new INT16 vector allocated on the GPU.
  - transform
```
public ColumnVector transform(String udf,
                              boolean isPtx)
```
    Transform a vector using a custom function. Be careful this is not simple to do. You need to be positive you know what type of data you are processing and how the data is laid out. This also only works on fixed length types.
    
    Parameters:
    
    udf - This function will be applied to every element in the vector
    
    isPtx - is the code of the function ptx? true or C/C++ false.
  - unaryOp
```
public ColumnVector unaryOp(UnaryOp op)
```
    Multiple different unary operations. The output is the same type as input.
    
    Parameters:
    
    op - the operation to perform
    
    Returns:
    
    the result
  - sin
```
public ColumnVector sin()
```
    Calculate the sin, output is the same type as input.
  - cos
```
public ColumnVector cos()
```
    Calculate the cos, output is the same type as input.
  - tan
```
public ColumnVector tan()
```
    Calculate the tan, output is the same type as input.
  - arcsin
```
public ColumnVector arcsin()
```
    Calculate the arcsin, output is the same type as input.
  - arccos
```
public ColumnVector arccos()
```
    Calculate the arccos, output is the same type as input.
  - arctan
```
public ColumnVector arctan()
```
    Calculate the arctan, output is the same type as input.
  - sinh
```
public ColumnVector sinh()
```
    Calculate the hyperbolic sin, output is the same type as input.
  - cosh
```
public ColumnVector cosh()
```
    Calculate the hyperbolic cos, output is the same type as input.
  - tanh
```
public ColumnVector tanh()
```
    Calculate the hyperbolic tan, output is the same type as input.
  - arcsinh
```
public ColumnVector arcsinh()
```
    Calculate the hyperbolic arcsin, output is the same type as input.
  - arccosh
```
public ColumnVector arccosh()
```
    Calculate the hyperbolic arccos, output is the same type as input.
  - arctanh
```
public ColumnVector arctanh()
```
    Calculate the hyperbolic arctan, output is the same type as input.
  - exp
```
public ColumnVector exp()
```
    Calculate the exp, output is the same type as input.
  - log
```
public ColumnVector log()
```
    Calculate the log, output is the same type as input.
  - log2
```
public ColumnVector log2()
```
    Calculate the log with base 2, output is the same type as input.
  - log10
```
public ColumnVector log10()
```
    Calculate the log with base 10, output is the same type as input.
  - sqrt
```
public ColumnVector sqrt()
```
    Calculate the sqrt, output is the same type as input.
  - cbrt
```
public ColumnVector cbrt()
```
    Calculate the cube root, output is the same type as input.
  - ceil
```
public ColumnVector ceil()
```
    Calculate the ceil, output is the same type as input.
  - floor
```
public ColumnVector floor()
```
    Calculate the floor, output is the same type as input.
  - abs
```
public ColumnVector abs()
```
    Calculate the abs, output is the same type as input.
  - rint
```
public ColumnVector rint()
```
    Rounds a floating-point argument to the closest integer value, but returns it as a float.
  - bitInvert
```
public ColumnVector bitInvert()
```
    invert the bits, output is the same type as input.
  - binaryOp
```
public ColumnVector binaryOp(BinaryOp op,
                             BinaryOperable rhs,
                             DType outType)
```
    Multiple different binary operations.
    
    Specified by:
    
    binaryOp in interface BinaryOperable
    
    Parameters:
    
    op - the operation to perform
    
    rhs - the rhs of the operation
    
    outType - the type of output you want.
    
    Returns:
    
    the result
  - sum
```
public Scalar sum()
```
    Computes the sum of all values in the column, returning a scalar of the same type as this column.
  - sum
```
public Scalar sum(DType outType)
```
    Computes the sum of all values in the column, returning a scalar of the specified type.
  - min
```
public Scalar min()
```
    Returns the minimum of all values in the column, returning a scalar of the same type as this column.
  - min
```
public Scalar min(DType outType)
```
    Returns the minimum of all values in the column, returning a scalar of the specified type.
  - max
```
public Scalar max()
```
    Returns the maximum of all values in the column, returning a scalar of the same type as this column.
  - max
```
public Scalar max(DType outType)
```
    Returns the maximum of all values in the column, returning a scalar of the specified type.
  - product
```
public Scalar product()
```
    Returns the product of all values in the column, returning a scalar of the same type as this column.
  - product
```
public Scalar product(DType outType)
```
    Returns the product of all values in the column, returning a scalar of the specified type.
  - sumOfSquares
```
public Scalar sumOfSquares()
```
    Returns the sum of squares of all values in the column, returning a scalar of the same type as this column.
  - sumOfSquares
```
public Scalar sumOfSquares(DType outType)
```
    Returns the sum of squares of all values in the column, returning a scalar of the specified type.
  - mean
```
public Scalar mean()
```
    Returns the arithmetic mean of all values in the column, returning a FLOAT64 scalar unless the column type is FLOAT32 then a FLOAT32 scalar is returned. Null values are skipped.
  - mean
```
public Scalar mean(DType outType)
```
    Returns the arithmetic mean of all values in the column, returning a scalar of the specified type. Null values are skipped.
  - variance
```
public Scalar variance()
```
    Returns the variance of all values in the column, returning a FLOAT64 scalar unless the column type is FLOAT32 then a FLOAT32 scalar is returned. Null values are skipped.
  - variance
```
public Scalar variance(DType outType)
```
    Returns the variance of all values in the column, returning a scalar of the specified type. Null values are skipped.
  - standardDeviation
```
public Scalar standardDeviation()
```
    Returns the sample standard deviation of all values in the column, returning a FLOAT64 scalar unless the column type is FLOAT32 then a FLOAT32 scalar is returned. Nulls are not counted as an element of the column when calculating the standard deviation.
  - standardDeviation
```
public Scalar standardDeviation(DType outType)
```
    Returns the sample standard deviation of all values in the column, returning a scalar of the specified type. Null's are not counted as an element of the column when calculating the standard deviation.
  - any
```
public Scalar any()
```
    Returns a boolean scalar that is true if any of the elements in the column are true or non-zero otherwise false. Null values are skipped.
  - any
```
public Scalar any(DType outType)
```
    Returns a scalar is true or 1, depending on the specified type, if any of the elements in the column are true or non-zero otherwise false or 0. Null values are skipped.
  - all
```
public Scalar all()
```
    Returns a boolean scalar that is true if all of the elements in the column are true or non-zero otherwise false. Null values are skipped.
  - all
```
public Scalar all(DType outType)
```
    Returns a scalar is true or 1, depending on the specified type, if all of the elements in the column are true or non-zero otherwise false or 0. Null values are skipped.
  - reduce
```
public Scalar reduce(ai.rapids.cudf.AggregateOp op)
```
    Computes the reduction of the values in all rows of a column. Overflows in reductions are not detected. Specifying a higher precision output type may prevent overflow. Only the MIN and MAX ops are The null values are skipped for the operation.
    
    Parameters:
    
    op - The reduction operation to perform
    
    Returns:
    
    The scalar result of the reduction operation. If the column is empty or the reduction operation fails then the Scalar.isValid() method of the result will return false.
  - reduce
```
public Scalar reduce(ai.rapids.cudf.AggregateOp op,
                     DType outType)
```
    Computes the reduction of the values in all rows of a column. Overflows in reductions are not detected. Specifying a higher precision output type may prevent overflow. Only the MIN and MAX ops are supported for reduction of non-arithmetic types (TIMESTAMP...) The null values are skipped for the operation.
    
    Parameters:
    
    op - The reduction operation to perform
    
    outType - The type of scalar value to return
    
    Returns:
    
    The scalar result of the reduction operation. If the column is empty or the reduction operation fails then the Scalar.isValid() method of the result will return false.
  - quantile
```
public ColumnVector quantile(QuantileMethod method,
                             double[] quantiles)
```
    Calculate various quantiles of this ColumnVector. It is assumed that this is already sorted in the desired order.
    
    Parameters:
    
    method - the method used to calculate the quantiles
    
    quantiles - the quantile values [0,1]
    
    Returns:
    
    the quantiles as doubles, in the same order passed in. The type can be changed in future
  - rollingWindow
```
public ColumnVector rollingWindow(ai.rapids.cudf.AggregateOp op,
                                  WindowOptions options)
```
    This function aggregates values in a window around each element i of the input column. Please refer to WindowsOptions for various options that can be passed. Note: Only rows-based windows are supported.
    
    Parameters:
    
    op - the operation to perform.
    
    options - various window function arguments.
    
    Returns:
    
    Column containing aggregate function result.
    
    Throws:
    
    IllegalArgumentException - if unsupported window specification * (i.e. other than WindowOptions.FrameType.ROWS is used.
  - not
```
public ColumnVector not()
```
    Returns a vector of the logical `not` of each value in the input column (this)
  - contains
```
public boolean contains(Scalar needle)
```
    Find if the `needle` is present in this col example: Single Column: idx 0 1 2 3 4 col = { 10, 20, 20, 30, 50 } Scalar: value = { 20 } result = true
    
    Parameters:
    
    needle -
    
    Returns:
    
    true if needle is present else false
  - contains
```
public ColumnVector contains(ColumnVector needles)
```
    Returns a new ColumnVector of DType.BOOL8 elements containing true if the corresponding entry in haystack is contained in needles and false if it is not. The caller will be responsible for the lifecycle of the new vector. example: haystack = { 10, 20, 30, 40, 50 } needles = { 20, 40, 60, 80 } result = { false, true, false, true, false }
    
    Parameters:
    
    needles -
    
    Returns:
    
    A new ColumnVector of type DType.BOOL8
  - castTo
```
public ColumnVector castTo(DType type)
```
    Generic method to cast ColumnVector When casting from a Date, Timestamp, or Boolean to a numerical type the underlying numerical representation of the data will be used for the cast. For Strings: Casting strings from/to timestamp isn't supported atm. Please look at asTimestamp(DType, String) and asStrings(String) for casting string to timestamp when the format is known Float values when converted to String could be different from the expected default behavior in Java e.g. 12.3 => "12.30000019" instead of "12.3" Double.POSITIVE_INFINITY => "Inf" instead of "INFINITY" Double.NEGATIVE_INFINITY => "-Inf" instead of "-INFINITY"
    
    Parameters:
    
    type - type of the resulting ColumnVector
    
    Returns:
    
    A new vector allocated on the GPU
  - asBytes
```
public ColumnVector asBytes()
```
    Cast to Byte - ColumnVector This method takes the value provided by the ColumnVector and casts to byte When casting from a Date, Timestamp, or Boolean to a byte type the underlying numerical representation of the data will be used for the cast.
    
    Returns:
    
    A new vector allocated on the GPU
  - asShorts
```
public ColumnVector asShorts()
```
    Cast to Short - ColumnVector This method takes the value provided by the ColumnVector and casts to short When casting from a Date, Timestamp, or Boolean to a short type the underlying numerical representation of the data will be used for the cast.
    
    Returns:
    
    A new vector allocated on the GPU
  - asInts
```
public ColumnVector asInts()
```
    Cast to Int - ColumnVector This method takes the value provided by the ColumnVector and casts to int When casting from a Date, Timestamp, or Boolean to a int type the underlying numerical representation of the data will be used for the cast.
    
    Returns:
    
    A new vector allocated on the GPU
  - asLongs
```
public ColumnVector asLongs()
```
    Cast to Long - ColumnVector This method takes the value provided by the ColumnVector and casts to long When casting from a Date, Timestamp, or Boolean to a long type the underlying numerical representation of the data will be used for the cast.
    
    Returns:
    
    A new vector allocated on the GPU
  - asFloats
```
public ColumnVector asFloats()
```
    Cast to Float - ColumnVector This method takes the value provided by the ColumnVector and casts to float When casting from a Date, Timestamp, or Boolean to a float type the underlying numerical representatio of the data will be used for the cast.
    
    Returns:
    
    A new vector allocated on the GPU
  - asDoubles
```
public ColumnVector asDoubles()
```
    Cast to Double - ColumnVector This method takes the value provided by the ColumnVector and casts to double When casting from a Date, Timestamp, or Boolean to a double type the underlying numerical representation of the data will be used for the cast.
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampDays
```
public ColumnVector asTimestampDays()
```
    Cast to TIMESTAMP_DAYS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_DAYS
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampDays
```
public ColumnVector asTimestampDays(String format)
```
    Cast to TIMESTAMP_DAYS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_DAYS
    
    Parameters:
    
    format - timestamp string format specifier, ignored if the column type is not string
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampSeconds
```
public ColumnVector asTimestampSeconds()
```
    Cast to TIMESTAMP_SECONDS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_SECONDS
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampSeconds
```
public ColumnVector asTimestampSeconds(String format)
```
    Cast to TIMESTAMP_SECONDS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_SECONDS
    
    Parameters:
    
    format - timestamp string format specifier, ignored if the column type is not string
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampMicroseconds
```
public ColumnVector asTimestampMicroseconds()
```
    Cast to TIMESTAMP_MICROSECONDS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_MICROSECONDS
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampMicroseconds
```
public ColumnVector asTimestampMicroseconds(String format)
```
    Cast to TIMESTAMP_MICROSECONDS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_MICROSECONDS
    
    Parameters:
    
    format - timestamp string format specifier, ignored if the column type is not string
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampMilliseconds
```
public ColumnVector asTimestampMilliseconds()
```
    Cast to TIMESTAMP_MILLISECONDS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_MILLISECONDS.
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampMilliseconds
```
public ColumnVector asTimestampMilliseconds(String format)
```
    Cast to TIMESTAMP_MILLISECONDS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_MILLISECONDS.
    
    Parameters:
    
    format - timestamp string format specifier, ignored if the column type is not string
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampNanoseconds
```
public ColumnVector asTimestampNanoseconds()
```
    Cast to TIMESTAMP_NANOSECONDS - ColumnVector This method takes the value provided by the ColumnVector and casts to TIMESTAMP_NANOSECONDS.
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestampNanoseconds
```
public ColumnVector asTimestampNanoseconds(String format)
```
    Cast to TIMESTAMP_NANOSECONDS - ColumnVector This method takes the string value provided by the ColumnVector and casts to TIMESTAMP_NANOSECONDS.
    
    Parameters:
    
    format - timestamp string format specifier, ignored if the column type is not string
    
    Returns:
    
    A new vector allocated on the GPU
  - asTimestamp
```
public ColumnVector asTimestamp(DType timestampType,
                                String format)
```
    Parse a string to a timestamp. Strings that fail to parse will default to 0, corresponding to 1970-01-01 00:00:00.000.
    
    Parameters:
    
    timestampType - timestamp DType that includes the time unit to parse the timestamp into.
    
    format - strptime format specifier string of the timestamp. Used to parse and convert the timestamp with. Supports %Y,%y,%m,%d,%H,%I,%p,%M,%S,%f,%z format specifiers. See https://github.com/rapidsai/custrings/blob/branch-0.10/docs/source/datetime.md for full parsing format specification and documentation.
    
    Returns:
    
    A new ColumnVector containing the long representations of the timestamps in the original column vector.
  - asStrings
```
public ColumnVector asStrings()
```
    Cast to Strings. Negative timestamp values are not currently supported and will yield undesired results. See github issue https://github.com/rapidsai/cudf/issues/3116 for details In case of timestamps it follows the following formats DType.TIMESTAMP_DAYS - "%Y-%m-%d" DType.TIMESTAMP_SECONDS - "%Y-%m-%d %H:%M:%S" DType.TIMESTAMP_MICROSECONDS - "%Y-%m-%d %H:%M:%S.%f" DType.TIMESTAMP_MILLISECONDS - "%Y-%m-%d %H:%M:%S.%f" DType.TIMESTAMP_NANOSECONDS - "%Y-%m-%d %H:%M:%S.%f"
    
    Returns:
    
    A new vector allocated on the GPU.
  - asStrings
```
public ColumnVector asStrings(String format)
```
    Method to parse and convert a timestamp column vector to string column vector. A unix timestamp is a long value representing how many units since 1970-01-01 00:00:00:000 in either positive or negative direction. No checking is done for invalid formats or invalid timestamp units. Negative timestamp values are not currently supported and will yield undesired results. See github issue https://github.com/rapidsai/cudf/issues/3116 for details
    
    Parameters:
    
    format - - strftime format specifier string of the timestamp. Its used to parse and convert the timestamp with. Supports %m,%j,%d,%H,%M,%S,%y,%Y,%f format specifiers. %d Day of the month: 01-31 %m Month of the year: 01-12 %y Year without century: 00-99c %Y Year with century: 0001-9999 %H 24-hour of the day: 00-23 %M Minute of the hour: 00-59 %S Second of the minute: 00-59 %f 6-digit microsecond: 000000-999999 See https://github.com/rapidsai/custrings/blob/branch-0.10/docs/source/datetime.md Reported bugs https://github.com/rapidsai/cudf/issues/4160 after the bug is fixed this method should also support %I 12-hour of the day: 01-12 %p Only 'AM', 'PM' %j day of the year
    
    Returns:
    
    A new vector allocated on the GPU
  - upper
```
public ColumnVector upper()
```
    Convert a string to upper case.
  - lower
```
public ColumnVector lower()
```
    Convert a string to lower case.
  - stringConcatenate
```
public ColumnVector stringConcatenate(ColumnVector[] columns)
```
    Concatenate columns of strings together, combining a corresponding row from each column into a single string row of a new column with no separator string inserted between each combined string and maintaining null values in combined rows.
    
    Parameters:
    
    columns - array of columns containing strings.
    
    Returns:
    
    A new java column vector containing the concatenated strings.
  - stringConcatenate
```
public static ColumnVector stringConcatenate(Scalar separator,
                                             Scalar narep,
                                             ColumnVector[] columns)
```
    Concatenate columns of strings together, combining a corresponding row from each column into a single string row of a new column.
    
    Parameters:
    
    separator - string scalar inserted between each string being merged.
    
    narep - string scalar indicating null behavior. If set to null and any string in the row is null the resulting string will be null. If not null, null values in any column will be replaced by the specified string.
    
    columns - array of columns containing strings, must be more than 2 columns
    
    Returns:
    
    A new java column vector containing the concatenated strings.
  - stringLocate
```
public ColumnVector stringLocate(Scalar substring)
```
    Locates the starting index of the first instance of the given string in each row of a column. 0 indexing, returns -1 if the substring is not found. Overloading stringLocate to support default values for start (0) and end index.
    
    Parameters:
    
    substring - scalar containing the string to locate within each row.
  - stringLocate
```
public ColumnVector stringLocate(Scalar substring,
                                 int start)
```
    Locates the starting index of the first instance of the given string in each row of a column. 0 indexing, returns -1 if the substring is not found. Overloading stringLocate to support default value for end index (-1, the end of each string).
    
    Parameters:
    
    substring - scalar containing the string to locate within each row.
    
    start - character index to start the search from (inclusive).
  - stringLocate
```
public ColumnVector stringLocate(Scalar substring,
                                 int start,
                                 int end)
```
    Locates the starting index of the first instance of the given string in each row of a column. 0 indexing, returns -1 if the substring is not found. Can be be configured to start or end the search mid string.
    
    Parameters:
    
    substring - scalar containing the string scalar to locate within each row.
    
    start - character index to start the search from (inclusive).
    
    end - character index to end the search on (exclusive).
  - stringSplit
```
public Table stringSplit(Scalar delimiter)
```
    Returns a list of columns by splitting each string using the specified delimiter. The number of rows in the output columns will be the same as the input column. Null entries are added for a row where split results have been exhausted. Null string entries return corresponding null output columns.
    
    Parameters:
    
    delimiter - UTF-8 encoded string identifying the split points in each string. Default of empty string indicates split on whitespace.
    
    Returns:
    
    New table of strings columns.
  - stringSplit
```
public Table stringSplit()
```
    Returns a list of columns by splitting each string using whitespace as the delimiter. The number of rows in the output columns will be the same as the input column. Null entries are added for a row where split results have been exhausted. Null string entries return corresponding null output columns.
    
    Returns:
    
    New table of strings columns.
  - substring
```
public ColumnVector substring(int start)
```
    Returns a new strings column that contains substrings of the strings in the provided column. Overloading subString to support if end index is not provided. Appending -1 to indicate to read until end of string.
    
    Parameters:
    
    start - first character index to begin the substring(inclusive).
  - substring
```
public ColumnVector substring(int start,
                              int end)
```
    Returns a new strings column that contains substrings of the strings in the provided column. 0-based indexing, If the stop position is past end of a string's length, then end of string is used as stop position for that string.
    
    Parameters:
    
    start - first character index to begin the substring(inclusive).
    
    end - last character index to stop the substring(exclusive)
    
    Returns:
    
    A new java column vector containing the substrings.
  - substring
```
public ColumnVector substring(ColumnVector start,
                              ColumnVector end)
```
    Returns a new strings column that contains substrings of the strings in the provided column which uses unique ranges for each string
    
    Parameters:
    
    start - Vector containing start indices of each string
    
    end - Vector containing end indices of each string. -1 indicated to read until end of string.
    
    Returns:
    
    A new java column vector containing the substrings/
  - stringReplace
```
public ColumnVector stringReplace(Scalar target,
                                  Scalar replace)
```
    Returns a new strings column where target string within each string is replaced with the specified replacement string. The replacement proceeds from the beginning of the string to the end, for example, replacing "aa" with "b" in the string "aaa" will result in "ba" rather than "ab". Specifing an empty string for replace will essentially remove the target string if found in each string. Null string entries will return null output string entries. target Scalar should be string and should not be empty or null.
    
    Parameters:
    
    target - String to search for within each string.
    
    replace - Replacement string if target is found.
    
    Returns:
    
    A new java column vector containing replaced strings
  - stringReplaceWithBackrefs
```
public ColumnVector stringReplaceWithBackrefs(String pattern,
                                              String replace)
```
    For each string, replaces any character sequence matching the given pattern using the replace template for back-references. Any null string entries return corresponding null output column entries.
    
    Parameters:
    
    pattern - The regular expression patterns to search within each string.
    
    replace - The replacement template for creating the output string.
    
    Returns:
    
    A new java column vector containing the string results.
  - startsWith
```
public ColumnVector startsWith(Scalar pattern)
```
    Checks if each string in a column starts with a specified comparison string, resulting in a parallel column of the boolean results.
    
    Parameters:
    
    pattern - scalar containing the string being searched for at the beginning of the column's strings.
    
    Returns:
    
    A new java column vector containing the boolean results.
  - endsWith
```
public ColumnVector endsWith(Scalar pattern)
```
    Checks if each string in a column ends with a specified comparison string, resulting in a parallel column of the boolean results.
    
    Parameters:
    
    pattern - scalar containing the string being searched for at the end of the column's strings.
    
    Returns:
    
    A new java column vector containing the boolean results.
  - strip
```
public ColumnVector strip()
```
    Removes whitespace from the beginning and end of a string.
    
    Returns:
    
    A new java column vector containing the stripped strings.
  - strip
```
public ColumnVector strip(Scalar toStrip)
```
    Removes the specified characters from the beginning and end of each string.
    
    Parameters:
    
    toStrip - UTF-8 encoded characters to strip from each string.
    
    Returns:
    
    A new java column vector containing the stripped strings.
  - lstrip
```
public ColumnVector lstrip()
```
    Removes whitespace from the beginning of a string.
    
    Returns:
    
    A new java column vector containing the stripped strings.
  - lstrip
```
public ColumnVector lstrip(Scalar toStrip)
```
    Removes the specified characters from the beginning of each string.
    
    Parameters:
    
    toStrip - UTF-8 encoded characters to strip from each string.
    
    Returns:
    
    A new java column vector containing the stripped strings.
  - rstrip
```
public ColumnVector rstrip()
```
    Removes whitespace from the end of a string.
    
    Returns:
    
    A new java column vector containing the stripped strings.
  - rstrip
```
public ColumnVector rstrip(Scalar toStrip)
```
    Removes the specified characters from the end of each string.
    
    Parameters:
    
    toStrip - UTF-8 encoded characters to strip from each string.
    
    Returns:
    
    A new java column vector containing the stripped strings.
  - stringContains
```
public ColumnVector stringContains(Scalar compString)
```
    Checks if each string in a column contains a specified comparison string, resulting in a parallel column of the boolean results.
    
    Parameters:
    
    compString - scalar containing the string being searched for.
    
    Returns:
    
    A new java column vector containing the boolean results.
  - clamp
```
public ColumnVector clamp(Scalar lo,
                          Scalar hi)
```
    Replaces values less than `lo` in `input` with `lo`, and values greater than `hi` with `hi`. if `lo` is invalid, then lo will not be considered while evaluating the input (Essentially considered minimum value of that type). if `hi` is invalid, then hi will not be considered while evaluating the input (Essentially considered maximum value of that type). ``` Example: input: {1, 2, 3, NULL, 5, 6, 7} valid lo and hi lo: 3, hi: 5, lo_replace : 0, hi_replace : 16 output:{0, 0, 3, NULL, 5, 16, 16} invalid lo lo: NULL, hi: 5, lo_replace : 0, hi_replace : 16 output:{1, 2, 3, NULL, 5, 16, 16} invalid hi lo: 3, hi: NULL, lo_replace : 0, hi_replace : 16 output:{0, 0, 3, NULL, 5, 6, 7} ```
    
    Parameters:
    
    lo - - Minimum clamp value. All elements less than `lo` will be replaced by `lo`. Ignored if null.
    
    hi - - Maximum clamp value. All elements greater than `hi` will be replaced by `hi`. Ignored if null.
    
    Returns:
    
    Returns a new clamped column as per `lo` and `hi` boundaries
  - clamp
```
public ColumnVector clamp(Scalar lo,
                          Scalar loReplace,
                          Scalar hi,
                          Scalar hiReplace)
```
    Replaces values less than `lo` in `input` with `lo_replace`, and values greater than `hi` with `hi_replace`. if `lo` is invalid, then lo will not be considered while evaluating the input (Essentially considered minimum value of that type). if `hi` is invalid, then hi will not be considered while evaluating the input (Essentially considered maximum value of that type).
    
    Parameters:
    
    lo - - Minimum clamp value. All elements less than `lo` will be replaced by `loReplace`. Ignored if null.
    
    loReplace - - All elements less than `lo` will be replaced by `loReplace`.
    
    hi - - Maximum clamp value. All elements greater than `hi` will be replaced by `hiReplace`. Ignored if null.
    
    hiReplace - - All elements greater than `hi` will be replaced by `hiReplace`.
    
    Returns:
    
    - a new clamped column as per `lo` and `hi` boundaries
  - matchesRe
```
public ColumnVector matchesRe(String pattern)
```
    Returns a boolean ColumnVector identifying rows which match the given regex pattern but only at the beginning of the string. ``` cv = ["abc","123","def456"] result = cv.matches_re("\\d+") r is now [false, true, false] ``` Any null string entries return corresponding null output column entries. For supported regex patterns refer to:
    
    Parameters:
    
    pattern - Regex pattern to match to each string.
    
    Returns:
    
    New ColumnVector of boolean results for each string.
  - containsRe
```
public ColumnVector containsRe(String pattern)
```
    Returns a boolean ColumnVector identifying rows which match the given regex pattern starting at any location. ``` cv = ["abc","123","def456"] result = cv.matches_re("\\d+") r is now [false, true, true] ``` Any null string entries return corresponding null output column entries. For supported regex patterns refer to:
    
    Parameters:
    
    pattern - Regex pattern to match to each string.
    
    Returns:
    
    New ColumnVector of boolean results for each string.
  - extractRe
```
public Table extractRe(String pattern)
                throws CudfException
```
    For each captured group specified in the given regular expression return a column in the table. Null entries are added if the string does not match. Any null inputs also result in null output entries. For supported regex patterns refer to:
    
    Parameters:
    
    pattern - the pattern to use
    
    Returns:
    
    the table of extracted matches
    
    Throws:
    
    CudfException - if any error happens including if the RE does not contain any capture groups.
  - getNativeView
```
public long getNativeView()
```
    USE WITH CAUTION: This method exposes the address of the native cudf::column_view. This allows writing custom kernels or other cuda operations on the data. DO NOT close this column vector until you are completely done using the native column_view. DO NOT modify the column in any way. This should be treated as a read only data structure. This API is unstable as the underlying C/C++ API is still not stabilized. If the underlying data structure is renamed this API may be replaced. The underlying data structure can change from release to release (it is not stable yet) so be sure that your native code is complied against the exact same version of libcudf as this is released for.
  - build
```
public static ColumnVector build(DType type,
                                 int rows,
                                 java.util.function.Consumer<HostColumnVector.Builder> init)
```
    Create a new vector.
    
    Parameters:
    
    type - the type of vector to build.
    
    rows - maximum number of rows that the vector can hold.
    
    init - what will initialize the vector.
    
    Returns:
    
    the created vector.
  - build
```
public static ColumnVector build(int rows,
                                 long stringBufferSize,
                                 java.util.function.Consumer<HostColumnVector.Builder> init)
```
  - boolFromBytes
```
public static ColumnVector boolFromBytes(byte... values)
```
    Create a new vector from the given values.
  - fromBytes
```
public static ColumnVector fromBytes(byte... values)
```
    Create a new vector from the given values.
  - fromShorts
```
public static ColumnVector fromShorts(short... values)
```
    Create a new vector from the given values.
  - fromInts
```
public static ColumnVector fromInts(int... values)
```
    Create a new vector from the given values.
  - fromLongs
```
public static ColumnVector fromLongs(long... values)
```
    Create a new vector from the given values.
  - fromFloats
```
public static ColumnVector fromFloats(float... values)
```
    Create a new vector from the given values.
  - fromDoubles
```
public static ColumnVector fromDoubles(double... values)
```
    Create a new vector from the given values.
  - daysFromInts
```
public static ColumnVector daysFromInts(int... values)
```
    Create a new vector from the given values.
  - timestampSecondsFromLongs
```
public static ColumnVector timestampSecondsFromLongs(long... values)
```
    Create a new vector from the given values.
  - timestampMilliSecondsFromLongs
```
public static ColumnVector timestampMilliSecondsFromLongs(long... values)
```
    Create a new vector from the given values.
  - timestampMicroSecondsFromLongs
```
public static ColumnVector timestampMicroSecondsFromLongs(long... values)
```
    Create a new vector from the given values.
  - timestampNanoSecondsFromLongs
```
public static ColumnVector timestampNanoSecondsFromLongs(long... values)
```
    Create a new vector from the given values.
  - fromStrings
```
public static ColumnVector fromStrings(String... values)
```
    Create a new string vector from the given values. This API supports inline nulls. This is really intended to be used only for testing as it is slow and memory intensive to translate between java strings and UTF8 strings.
  - fromBoxedBooleans
```
public static ColumnVector fromBoxedBooleans(Boolean... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - fromBoxedBytes
```
public static ColumnVector fromBoxedBytes(Byte... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - fromBoxedShorts
```
public static ColumnVector fromBoxedShorts(Short... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - fromBoxedInts
```
public static ColumnVector fromBoxedInts(Integer... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - fromBoxedLongs
```
public static ColumnVector fromBoxedLongs(Long... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - fromBoxedFloats
```
public static ColumnVector fromBoxedFloats(Float... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - fromBoxedDoubles
```
public static ColumnVector fromBoxedDoubles(Double... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - timestampDaysFromBoxedInts
```
public static ColumnVector timestampDaysFromBoxedInts(Integer... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - timestampSecondsFromBoxedLongs
```
public static ColumnVector timestampSecondsFromBoxedLongs(Long... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - timestampMilliSecondsFromBoxedLongs
```
public static ColumnVector timestampMilliSecondsFromBoxedLongs(Long... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - timestampMicroSecondsFromBoxedLongs
```
public static ColumnVector timestampMicroSecondsFromBoxedLongs(Long... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.
  - timestampNanoSecondsFromBoxedLongs
```
public static ColumnVector timestampNanoSecondsFromBoxedLongs(Long... values)
```
    Create a new vector from the given values. This API supports inline nulls, but is much slower than using a regular array and should really only be used for tests.

Class ColumnVector

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface ai.rapids.cudf.BinaryOperable

Constructor Detail

ColumnVector

Method Detail

toTitle

noWarnLeakExpected

close

toString

incRefCount

nansToNulls

getRowCount

getDeviceMemorySize

getType

getNullCount

hasValidityVector

hasNulls

copyToHost

getDeviceBufferFor

getCharLengths

getByteCount

isNotNull

isNull

isInteger

isFloat

isNan

isNotNan

findAndReplaceAll

replaceNulls

ifElse

ifElse

ifElse

ifElse

slice

subVector

subVector

split

fromScalar

sequence

sequence

concatenate

normalizeNANsAndZeros

year

month

day

hour

minute

second

transform

unaryOp

sin

cos

tan

arcsin

arccos

arctan

sinh

cosh

tanh

arcsinh

arccosh

arctanh

exp

log

log2

log10

sqrt

cbrt

ceil

floor

abs

rint

bitInvert

binaryOp

sum

sum