Series containing the utf8 characters of each string
Whether the Series contains null elements.
The number of elements in this Series.
The DeviceBuffer for for the validity bitmask in GPU memory.
A boolean indicating whether a validity bitmask exists.
The number of null elements in this Series.
The number of child columns in this Series.
The offset of elements in this Series underlying Column.
Series of integer offsets for each string
The data type of elements in the underlying data.
Optional_memoryResource: MemoryResourceOptionalmemoryResource: MemoryResourceCopy the underlying device memory to host, and return an Iterator of the values.
Returns an Int32 series the number of bytes of each string in the Series.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
Casts the values to a new dtype (similar to static_cast in C++).
The new dtype.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
Series of same size as the current Series containing result of the cast operation.
Concat a Series to the end of the caller, returning a new Series of a common dtype.
The Series to concat to the end of the caller.
OptionalmemoryResource: MemoryResourceReturns a boolean series identifying rows which match the given regex pattern.
Regex pattern to match to each string.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
The regex pattern strings accepted are described here:
https://docs.rapids.ai/api/libcudf/stable/md_regex.html
A RegExp may also be passed, however all flags are ignored (only pattern.source is used)
import {Series} from '@rapidsai/cudf';
const a = Series.new(['Finland','Colombia','Florida', 'Russia','france']);
// items starting with F (only upper case)
a.containsRe(/^F/) // [true, false, true, false, false]
// items starting with F or f
a.containsRe(/^[Ff]/) // [true, false, true, false, true]
// items ending with a
a.containsRe("a$") // [false, true, true, true, false]
// items containing "us"
a.containsRe("us") // [false, false, false, true, false]
Returns an Int32 series the number of times the given regex pattern matches in each string.
Regex pattern to match to each string.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
The regex pattern strings accepted are described here:
https://docs.rapids.ai/api/libcudf/stable/md_regex.html
A RegExp may also be passed, however all flags are ignored (only pattern.source is used)
import {Series} from '@rapidsai/cudf';
const a = Series.new(['Finland','Colombia','Florida', 'Russia','france']);
// count occurences of "o"
a.countRe(/o/) // [0, 2, 1, 0, 0]
// count occurences of "an"
a.countRe('an') // [1, 0, 0, 0, 1]
// get number of countries starting with F or f
a.countRe(/^[fF]).count() // 3
Returns a new Series with duplicate values from the original removed
Determines whether or not to keep the duplicate items.
Determines whether nulls are handled as equal values.
Determines whether null values are inserted before or after non-null values.
OptionalmemoryResource: MemoryResourceMemory resource used to allocate the result Column's device memory.
series without duplicate values
drop Null values from the series
OptionalmemoryResource: MemoryResourceMemory resource used to allocate the result Column's device memory.
series without Null values
import {Series} from '@rapidsai/cudf';
// Float64Series
Series.new([1, undefined, 3]).dropNulls() // [1, 3]
Series.new([1, null, 3]).dropNulls() // [1, 3]
Series.new([1, , 3]).dropNulls() // [1, 3]
// StringSeries
Series.new(["foo", "bar", undefined]).dropNulls() // ["foo", "bar"]
Series.new(["foo", "bar", null]).dropNulls() // ["foo", "bar"]
Series.new(["foo", "bar", ,]).dropNulls() // ["foo", "bar"]
// Bool8Series
Series.new([true, true, undefined]).dropNulls() // [true, true]
Series.new([true, true, null]).dropNulls() // [true, true]
Series.new([true, true, ,]).dropNulls() // [true, true]
Encode the Series values into integer labels.
The optional Series of values to encode into integers. Defaults to the unique elements in this Series.
The optional integer DataType to use for the returned Series. Defaults to Int32.
The optional value used to indicate missing category. Defaults to -1.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
A sequence of encoded integer labels with values between 0 and n-1
categories, and nullSentinel for any null values
Fills a range of elements in a column out-of-place with a scalar value.
The scalar value to fill.
The starting index of the fill range (inclusive).
The index of the last element in the fill range (exclusive), default this.length .
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
Fills a range of elements in-place in a column with a scalar value.
The scalar value to fill
The starting index of the fill range (inclusive)
The index of the last element in the fill range (exclusive)
import {Series} from '@rapidsai/cudf';
// Float64Series
Series.new([1, 2, 3]).fillInPlace(0) // [0, 0, 0]
// StringSeries
Series.new(["foo", "bar", "test"]).fillInPlace("rplc", 0, 1) // ["rplc", "bar", "test"]
// Bool8Series
Series.new([true, true, true]).fillInPlace(false, 1) // [true, false, false]
Return a sub-selection of this Series using the specified boolean mask.
A Series of boolean values for whose corresponding element in this Series will be selected or ignored.
OptionalmemoryResource: MemoryResourceAn optional MemoryResource used to allocate the result's device memory.
import {Series} from "@rapidsai/cudf";
const mask = Series.new([true, false, true]);
// Float64Series
Series.new([1, 2, 3]).filter(mask) // [1, 3]
// StringSeries
Series.new(["foo", "bar", "test"]).filter(mask) // ["foo", "test"]
// Bool8Series
Series.new([false, true, true]).filter(mask) // [false, true]
A Series of 8/16/32-bit signed or unsigned integer indices to gather.
If true, coerce rows that corresponds to out-of-bounds indices
in the selection to null. If false, skips all bounds checking for selection values. Pass
false if you are certain that the selection contains only valid indices for better
performance. If false and there are out-of-bounds indices in the selection, the behavior
is undefined. Defaults to false.
OptionalmemoryResource: MemoryResourceAn optional MemoryResource used to allocate the result's device memory.
Gathers the rows of the source columns according to selection, such that row "i"
in the resulting Series's columns will contain row selection[i] from the source columns. The
number of rows in the result series will be equal to the number of elements in selection. A
negative value i in the selection is interpreted as i+n, where n is the number of rows in
the source series.
For dictionary columns, the keys column component is copied and not trimmed if the gather results in abandoned key elements.
import {Series, Int32} from '@rapidsai/cudf';
const a = Series.new([1,2,3]);
const b = Series.new(["foo", "bar", "test"]);
const c = Series.new([true, false, true]);
const selection = Series.new({type: new Int32, data: [0,2]});
a.gather(selection) // Float64Series [1,3]
b.gather(selection) // StringSeries ["foo", "test"]
c.gather(selection) // Bool8Series [true, true]
Applies a JSONPath(string) where each row in the series is a valid json string. Returns New StringSeries containing the retrieved json object strings
The JSONPath string to be applied to each row of the input column
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
import {Series} from '@rapidsai/cudf';
const a = const lines = Series.new([
{foo: {bar: "baz"}},
{foo: {baz: "bar"}},
].map(JSON.stringify)); // StringSeries ['{"foo":{"bar":"baz"}}', '{"foo":{"baz":"bar"}}']
a.getJSONObject("$.foo") // StringSeries ['{"bar":"baz"}', '{"baz":"bar"}']
a.getJSONObject("$.foo.bar") // StringSeries ["baz", null]
// parse the resulting strings using JSON.parse
[...a.getJSONObject("$.foo").map(JSON.parse)] // object [{ bar: 'baz' }, { baz: 'bar' }]
Return a value at the specified index to host memory
the index in this Series to return a value for
Returns a new integer numeric series parsing hexadecimal values.
Any null entries will result in corresponding null entries in the output series.
Only characters [0-9] and [A-F] are recognized. When any other character is encountered, the parsing ends for that string. No interpretation is made on the sign of the integer.
Overflow of the resulting integer type is not checked. Each string is converted using an int64 type and then cast to the target integer type before storing it into the output series. If the resulting integer type is too small to hold the value, the stored value will be undefined.
Type of integer numeric series to return.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series' device memory.
Converts IPv4 addresses into integers.
The IPv4 format is 1-3 character digits [0-9] between 3 dots (e.g. 123.45.67.890). Each section can have a value between [0-255].
The four sets of digits are converted to integers and placed in 8-bit fields inside the resulting integer.
i0.i1.i2.i3 -> (i0 << 24) | (i1 << 16) | (i2 << 8) | (i3)
No checking is done on the format. If a string is not in IPv4 format, the resulting integer is undefined.
The resulting 32-bit integer is placed in an int64_t to avoid setting the sign-bit in an int32_t type. This could be changed if cudf supported a UINT32 type in the future.
Any null entries will result in corresponding null entries in the output column.Returns a new Int64 numeric series parsing hexadecimal values from the provided string series.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series' device memory.
Returns a boolean column identifying strings in which all characters are valid for conversion to integers from hex.
The output row entry will be set to true if the corresponding string element has at least one character in [0-9A-Za-z]. Also, the string may start with '0x'.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
Returns a boolean column identifying strings in which all characters are valid for conversion to integers from IPv4 format.
The output row entry will be set to true if the corresponding string element has the following format xxx.xxx.xxx.xxx where xxx is integer digits between 0-255.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
Creates a Series of BOOL8 elements where true indicates the value is valid and
false indicates the value is null.
OptionalmemoryResource: MemoryResourceMemory resource used to allocate the result Column's device memory.
A non-nullable Series of BOOL8 elements with false representing null
values.
Creates a Series of BOOL8 elements where true indicates the value is null and false
indicates the value is valid.
OptionalmemoryResource: MemoryResourceMemory resource used to allocate the result Column's device memory.
A non-nullable Series of BOOL8 elements with true representing null
values.
Returns an Int32 series the length of each string in the Series.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
Returns a boolean series identifying rows which match the given regex pattern only at the beginning of the string
Regex pattern to match to each string.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Series's device memory.
The regex pattern strings accepted are described here:
https://docs.rapids.ai/api/libcudf/stable/md_regex.html
A RegExp may also be passed, however all flags are ignored (only pattern.source is used)
import {Series} from '@rapidsai/cudf';
const a = Series.new(['Finland','Colombia','Florida', 'Russia','france']);
// start of item contains "C"
a.matchesRe(/C/) // [false, true, false, false, false]
// start of item contains "us", returns false since none of the items start with "us"
a.matchesRe('us') // [false, false, false, false, false]
Returns the n largest element(s).
The number of values to retrieve.
Determines whether to keep the first or last of any duplicate values.
Returns the n smallest element(s).
The number of values to retrieve.
Determines whether to keep the first or last of any duplicate values.
Generate an ordering that sorts the Series in a specified way.
whether to sort ascending (true) or descending (false)
whether nulls should sort before or after other values
OptionalmemoryResource: MemoryResourceAn optional MemoryResource used to allocate the result's device memory.
Series containting the permutation indices for the desired sort order
import {Series, NullOrder} from '@rapidsai/cudf';
// Float64Series
Series.new([50, 40, 30, 20, 10, 0]).orderBy(false) // [0, 1, 2, 3, 4, 5]
Series.new([50, 40, 30, 20, 10, 0]).orderBy(true) // [5, 4, 3, 2, 1, 0]
// StringSeries
Series.new(["a", "b", "c", "d", "e"]).orderBy(false) // [4, 3, 2, 1, 0]
Series.new(["a", "b", "c", "d", "e"]).orderBy(true) // [0, 1, 2, 3, 4]
// Bool8Series
Series.new([true, false, true, true, false]).orderBy(true) // [1, 4, 0, 2, 3]
Series.new([true, false, true, true, false]).orderBy(false) // [0, 2, 3, 1, 4]
// NullOrder usage
Series.new([50, 40, 30, 20, 10, null]).orderBy(false, 'before') // [0, 1, 2, 3, 4, 5]
Series.new([50, 40, 30, 20, 10, null]).orderBy(false, 'after') // [5, 0, 1, 2, 3, 4]
Add padding to each string using a provided character.
If the string is already width or more characters, no padding is performed. No strings are truncated.
Null string entries result in null entries in the output column.
The minimum number of characters for each string.
Where to place the padding characters. Default is pad right (left justify).
Single UTF-8 character to use for padding. Default is the space character.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
Returns a set of 3 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. The first column will contain the first tokens of each string as a result of the split. The second column will contain the delimiter. The third column will contain the remaining characters of each string after the delimiter.
Any null string entries return corresponding null output columns.
UTF-8 encoded string indicating where to split each string. Default of empty string indicates split on whitespace.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
3 new string columns representing before the delimiter, the delimiter, and after the delimiter.
Replace null values with a scalar value.
The scalar value to use in place of nulls.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
Replace null values with the corresponding elements from another Series.
The Series to use in place of nulls.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
import {Series} from '@rapidsai/cudf';
const replace = Series.new([10, 10, 10]);
const replaceBool = Series.new([false, false, false]);
// Float64Series
Series.new([1, null, 3]).replaceNulls(replace) // [1, 10, 3]
// StringSeries
Series.new(["foo", "bar", null]).replaceNulls(replace) // ["foo", "bar", "10"]
// Bool8Series
Series.new([null, true, true]).replaceNulls(replaceBool) // [false, true, true]
Replace null values with the non-null value following the null value in the same series.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
import {Series} from '@rapidsai/cudf';
// Float64Series
Series.new([1, null, 3]).replaceNullsFollowing() // [1, 3, 3]
// StringSeries
Series.new(["foo", "bar", null]).replaceNullsFollowing() // ["foo", "bar", null]
Series.new(["foo", null, "bar"]).replaceNullsFollowing() // ["foo", "bar", "bar"]
// Bool8Series
Series.new([null, true, true]).replaceNullsFollowing() // [true, true, true]
Replace null values with the non-null value preceding the null value in the same series.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
import {Series} from '@rapidsai/cudf';
// Float64Series
Series.new([1, null, 3]).replaceNullsPreceding() // [1, 1, 3]
// StringSeries
Series.new([null, "foo", "bar"]).replaceNullsPreceding() // [null, "foo", "bar"]
Series.new(["foo", null, "bar"]).replaceNullsPreceding() // ["foo", "foo", "bar"]
// Bool8Series
Series.new([true, null, false]).replaceNullsPreceding() // [true, true, false]
For each string in the column, replaces any character sequence matching the given pattern with the provided replacement string.
Null string entries will return null output string entries.
Position values are 0-based meaning position 0 is the first character of each string.
This function can be used to insert a string into specific position by specifying the same position value for start and stop. The repl string can be appended to each string by specifying -1 for both start and stop.
The regular expression pattern to search within each string.
The string used to replace the matched sequence in each string. Default is an empty string.
The maximum number of times to replace the matched pattern within each string. Default replaces every substring that is matched.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
New strings column with matching elements replaced.
Replaces each string in the column with the provided repl string within the [start,stop) character position range.
Null string entries will return null output string entries.
Position values are 0-based meaning position 0 is the first character of each string.
This function can be used to insert a string into specific position by specifying the same position value for start and stop. The repl string can be appended to each string by specifying -1 for both start and stop.
Replacement string for specified positions found.
Start position where repl will be added. Default is 0, first character position.
End position (exclusive) to use for replacement. Default of -1 specifies the end of each string.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
Returns a new series with reversed elements.
OptionalmemoryResource: MemoryResourceAn optional MemoryResource used to allocate the result's device memory.
Scatters single value into this Series according to provided indices.
A column of values to be scattered in to this Series
A column of integral indices that indicate the rows in the this Series to be
replaced by value.
OptionalmemoryResource: MemoryResourceAn optional MemoryResource used to allocate the result's device memory.
import {Series, Int32} from '@rapidsai/cudf';
const a = Series.new({type: new Int32, data: [0, 1, 2, 3, 4]});
const indices = Series.new({type: new Int32, data: [2, 4]});
const indices_out_of_bounds = Series.new({type: new Int32, data: [5, 6]});
a.scatter(-1, indices); // returns [0, 1, -1, 3, -1];
a.scatter(-1, indices_out_of_bounds, true) // throws index out of bounds error
Scatters a column of values into this Series according to provided indices.
A column of integral indices that indicate the rows in the this Series to be
replaced by value.
OptionalmemoryResource: MemoryResourceAn optional MemoryResource used to allocate the result's device memory.
import {Series, Int32} from '@rapidsai/cudf';
const a = Series.new({type: new Int32, data: [0, 1, 2, 3, 4]});
const b = Series.new({type: new Int32, data: [200, 400]});
const indices = Series.new({type: new Int32, data: [2, 4]});
const indices_out_of_bounds = Series.new({type: new Int32, data: [5, 6]});
a.scatter(b, indices); // returns [0, 1, 200, 3, 400];
a.scatter(b, indices_out_of_bounds, true) // throws index out of bounds error
The null-mask. Valid values are marked as 1; otherwise 0. The mask bit given the data index idx is computed as:
(mask[idx // 8] >> (idx % 8)) & 1
OptionalnullCount: numberThe number of null values. If None, it is calculated automatically.
set value at the specified index
the index in this Series to set a value for
the value to set at index
set values at the specified indices
the indices in this Series to set values for
the values to set at Series of indices
import {Series, Int32} from '@rapidsai/cudf';
const a = Series.new({type: new Int32, data: [0, 1, 2, 3, 4]});
const values = Series.new({type: new Int32, data: [200, 400]});
const indices = Series.new({type: new Int32, data: [2, 4]});
a.setValues(indices, values); // inplace update [0, 1, 200, 3, 400];
a.setValues(indices, -1); // inplace update [0, 1, -1, 3, -1];
Generate a new Series that is sorted in a specified way.
whether to sort ascending (true) or descending (false) Default: true
whether nulls should sort before or after other values Default: before
OptionalmemoryResource: MemoryResourceAn optional MemoryResource used to allocate the result's device memory.
Sorted values
import {Series, NullOrder} from '@rapidsai/cudf';
// Float64Series
Series.new([50, 40, 30, 20, 10, 0]).sortValues(false) // [50, 40, 30, 20, 10, 0]
Series.new([50, 40, 30, 20, 10, 0]).sortValues(true) // [0, 10, 20, 30, 40, 50]
// StringSeries
Series.new(["a", "b", "c", "d", "e"]).sortValues(false) // ["e", "d", "c", "b", "a"]
Series.new(["a", "b", "c", "d", "e"]).sortValues(true) // ["a", "b", "c", "d", "e"]
// Bool8Series
Series.new([true, false, true, true, false]).sortValues(true) // [false, false, true,
true, true] Series.new([true, false, true, true, false]).sortValues(false) // [true,
true, true, false, false]
// NullOrder usage
Series.new([50, 40, 30, 20, 10, null]).sortValues(false, 'before') // [50, 40, 30, 20,
10, null]
Series.new([50, 40, 30, 20, 10, null]).sortValues(false, 'after') // [null, 50, 40, 30,
20, 10]
Splits a StringSeries along the delimiter.
Optional delimiter.
OptionalmemoryResource: MemoryResourceSeries with new splits determined by the delimiter.
Copy the underlying device memory to host and return an Array (or TypedArray) of the values.
Copy a Series to an Arrow vector in host memory
Return a string with a tabular representation of the Series, pretty-printed according to the options given.
Returns a new Series with only the unique values that were found in the original
Determines whether nulls are handled as equal values.
OptionalmemoryResource: MemoryResourceMemory resource used to allocate the result Column's device memory.
series without duplicate values
Returns an object with keys "value" and "count" whose respective values are new Series containing the unique values in the original series and the number of times they occur in the original series.
object with keys "value" and "count"
Add '0' as padding to the left of each string.
If the string is already width or more characters, no padding is performed. No strings are truncated.
This equivalent to pad(width, 'left', '0') but is more optimized for this special case.
Null string entries result in null entries in the output column.
The minimum number of characters for each string.
OptionalmemoryResource: MemoryResourceThe optional MemoryResource used to allocate the result Column's device memory.
StaticconcatenateRow-wise concatenates the given list of strings series and returns a single string series result.
List of string series to concatenate.
Options for the concatenation
New series with concatenated results.
StaticnewCreate a new cudf.Series from an apache arrow vector
import {Series, Int32} from '@rapidsai/cudf';
import * as arrow from 'apache-arrow';
const arrow_vec = arrow.vectorFromArray(new Int32Array([1,2,3,4])));
const a = Series.new(arrow_vec); // Int32Series [1, 2, 3, 4]
const arrow_vec_list = arrow.vectorFromArray(
[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
new arrow.List(arrow.Field.new({ name: 'ints', type: new arrow.Int32 })),
);
const b = Series.new(arrow_vec_list) // ListSeries [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
const arrow_vec_struct = arrow.vectorFromArray(
[{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }],
new arrow.Struct([
arrow.Field.new({ name: 'x', type: new arrow.Int32 }),
arrow.Field.new({ name: 'y', type: new arrow.Int32 })
]),
);
const c = Series.new(arrow_vec_struct);
// StructSeries [{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }]
Create a new cudf.Series from SeriesProps or a cudf.Column
Create a new cudf.Series from an apache arrow vector
import {Series, Int32} from '@rapidsai/cudf';
import * as arrow from 'apache-arrow';
const arrow_vec = arrow.vectorFromArray(new Int32Array([1,2,3,4])));
const a = Series.new(arrow_vec); // Int32Series [1, 2, 3, 4]
const arrow_vec_list = arrow.vectorFromArray(
[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
new arrow.List(arrow.Field.new({ name: 'ints', type: new arrow.Int32 })),
);
const b = Series.new(arrow_vec_list) // ListSeries [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
const arrow_vec_struct = arrow.vectorFromArray(
[{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }],
new arrow.Struct([
arrow.Field.new({ name: 'x', type: new arrow.Int32 }),
arrow.Field.new({ name: 'y', type: new arrow.Int32 })
]),
);
const c = Series.new(arrow_vec_struct);
// StructSeries [{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }]
Create a new cudf.Series from an apache arrow vector
import {Series, Int32} from '@rapidsai/cudf';
import * as arrow from 'apache-arrow';
const arrow_vec = arrow.vectorFromArray(new Int32Array([1,2,3,4])));
const a = Series.new(arrow_vec); // Int32Series [1, 2, 3, 4]
const arrow_vec_list = arrow.vectorFromArray(
[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
new arrow.List(arrow.Field.new({ name: 'ints', type: new arrow.Int32 })),
);
const b = Series.new(arrow_vec_list) // ListSeries [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
const arrow_vec_struct = arrow.vectorFromArray(
[{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }],
new arrow.Struct([
arrow.Field.new({ name: 'x', type: new arrow.Int32 }),
arrow.Field.new({ name: 'y', type: new arrow.Int32 })
]),
);
const c = Series.new(arrow_vec_struct);
// StructSeries [{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }]
Create a new cudf.Int8Series
Create a new cudf.Int16Series
Create a new cudf.Int32Series
Create a new cudf.Uint8Series
Create a new cudf.Uint16Series
Create a new cudf.Uint32Series
Create a new cudf.Uint64Series
Create a new cudf.Float32Series
Create a new cudf.Float64Series
Create a new cudf.Int64Series
Create a new cudf.TimestampMillisecondSeries
Create a new cudf.ListSeries that contain cudf.StringSeries elements.
Create a new cudf.ListSeries that contain cudf.Float64Series elements.
Create a new cudf.ListSeries that contain cudf.Int64Series elements.
Create a new cudf.ListSeries that contain cudf.Bool8Series elements.
Create a new cudf.ListSeries that contain cudf.TimestampMillisecondSeries elements.
import {Series} from '@rapidsai/cudf';
// ListSeries [[2021-05-13T00:00:00.000Z, null], [null, 2021-05-13T00:00:00.000Z]]
const a = Series.new([[new Date(), undefined], [undefined, new Date()]]);
a.getValue(0) // TimestampMillisecondSeries [2021-05-13T00:00:00.000Z, null]
a.getValue(1) // TimestampMillisecondSeries [null, 2021-05-13T00:00:00.000Z]
Create a new cudf.Series from an apache arrow vector
import {Series, Int32} from '@rapidsai/cudf';
import * as arrow from 'apache-arrow';
const arrow_vec = arrow.vectorFromArray(new Int32Array([1,2,3,4])));
const a = Series.new(arrow_vec); // Int32Series [1, 2, 3, 4]
const arrow_vec_list = arrow.vectorFromArray(
[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
new arrow.List(arrow.Field.new({ name: 'ints', type: new arrow.Int32 })),
);
const b = Series.new(arrow_vec_list) // ListSeries [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
const arrow_vec_struct = arrow.vectorFromArray(
[{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }],
new arrow.Struct([
arrow.Field.new({ name: 'x', type: new arrow.Int32 }),
arrow.Field.new({ name: 'y', type: new arrow.Int32 })
]),
);
const c = Series.new(arrow_vec_struct);
// StructSeries [{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }]
Create a new cudf.Series from an apache arrow vector
import {Series, Int32} from '@rapidsai/cudf';
import * as arrow from 'apache-arrow';
const arrow_vec = arrow.vectorFromArray(new Int32Array([1,2,3,4])));
const a = Series.new(arrow_vec); // Int32Series [1, 2, 3, 4]
const arrow_vec_list = arrow.vectorFromArray(
[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
new arrow.List(arrow.Field.new({ name: 'ints', type: new arrow.Int32 })),
);
const b = Series.new(arrow_vec_list) // ListSeries [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
const arrow_vec_struct = arrow.vectorFromArray(
[{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }],
new arrow.Struct([
arrow.Field.new({ name: 'x', type: new arrow.Int32 }),
arrow.Field.new({ name: 'y', type: new arrow.Int32 })
]),
);
const c = Series.new(arrow_vec_struct);
// StructSeries [{ x: 0, y: 3 }, { x: 1, y: 4 }, { x: 2, y: 5 }]
StaticreadConstructs a Series from a text file path.
Path of the input file.
Optional delimiter.
StringSeries from the file, split by delimiter.
StaticsequenceConstructs a Series with a sequence of values.
Series with the sequence
import {Series, Int64, Float32} from '@rapidsai/cudf';
Series.sequence({size: 5}).toArray() // Int32Array(5) [0, 1, 2, 3, 4]
Series.sequence({size: 5, init: 5}).toArray() // Int32Array(5) [5, 6, 7, 8, 9]
Series
.sequence({ size: 5, init: 0, type: new Int64 })
.toArray() // BigInt64Array(5) [0n, 1n, 2n, 3n, 4n]
Series
.sequence({ size: 5, step: 2, init: 1, type: new Float32 })
.toArray() // Float32Array(5) [1, 3, 5, 7, 9]
A Series of utf8-string values in GPU memory.