RAPIDS
    Preparing search index...

    Class StructSeries<T>

    A Series of structs.

    Type Parameters

    Hierarchy (View Summary)

    Index

    Accessors

    hasNulls length mask nullable nullCount numChildren offset type

    Methods

    _castAsBool8 _castAsCategorical _castAsFloat32 _castAsFloat64 _castAsInt16 _castAsInt32 _castAsInt64 _castAsInt8 _castAsTimeStampDay _castAsTimeStampMicrosecond _castAsTimeStampMillisecond _castAsTimeStampNanosecond _castAsTimeStampSecond _castAsUint16 _castAsUint32 _castAsUint64 _castAsUint8 [iterator] cast concat copy countNonNulls dispose dropDuplicates dropNulls encodeLabels fill fillInPlace filter gather getChild getValue head isNotNull isNull nLargest nSmallest orderBy replaceNulls replaceNullsFollowing replaceNullsPreceding reverse scatter setNullMask setValues sortValues tail toArray toArrow toString unique valueCounts new readText sequence

    Accessors

    • get hasNulls(): boolean

      Whether the Series contains null elements.

      Returns boolean

    • get mask(): DeviceBuffer

      The DeviceBuffer for for the validity bitmask in GPU memory.

      Returns DeviceBuffer

    • get nullable(): boolean

      A boolean indicating whether a validity bitmask exists.

      Returns boolean

    • get nullCount(): number

      The number of null elements in this Series.

      Returns number

    • get numChildren(): number

      The number of child columns in this Series.

      Returns number

    • get offset(): number

      The offset of elements in this Series underlying Column.

      Returns number

    Methods

    _castAsBool8

    _castAsCategorical

    _castAsFloat32

    _castAsFloat64

    _castAsInt16

    _castAsInt32

    _castAsInt64

    _castAsInt8

    _castAsTimeStampDay

    • _castAsTimeStampDay(_memoryResource?: MemoryResource): TimestampDaySeries

      Parameters

      • Optional_memoryResource: MemoryResource

      Returns TimestampDaySeries

    _castAsTimeStampMicrosecond

    • _castAsTimeStampMicrosecond(
          _memoryResource?: MemoryResource,
      ): TimestampMicrosecondSeries

      Parameters

      • Optional_memoryResource: MemoryResource

      Returns TimestampMicrosecondSeries

    _castAsTimeStampMillisecond

    • _castAsTimeStampMillisecond(
          _memoryResource?: MemoryResource,
      ): TimestampMillisecondSeries

      Parameters

      • Optional_memoryResource: MemoryResource

      Returns TimestampMillisecondSeries

    _castAsTimeStampNanosecond

    • _castAsTimeStampNanosecond(
          _memoryResource?: MemoryResource,
      ): TimestampNanosecondSeries

      Parameters

      • Optional_memoryResource: MemoryResource

      Returns TimestampNanosecondSeries

    _castAsTimeStampSecond

    • _castAsTimeStampSecond(_memoryResource?: MemoryResource): TimestampSecondSeries

      Parameters

      • Optional_memoryResource: MemoryResource

      Returns TimestampSecondSeries

    _castAsUint16

    _castAsUint32

    _castAsUint64

    _castAsUint8

    • Copy the underlying device memory to host, and return an Iterator of the values.

      Returns IterableIterator<StructRowProxy<T> | null>

    • Casts the values to a new dtype (similar to static_cast in C++).

      Type Parameters

      Parameters

      • dataType: R

        The new dtype.

      • OptionalmemoryResource: MemoryResource

        The optional MemoryResource used to allocate the result Series's device memory.

      Returns Series<R>

      Series of same size as the current Series containing result of the cast operation.

      import {Series, Bool8, Int32} from '@rapidsai/cudf';

      const a = Series.new({type:new Int32, data: [1,0,1,0]});

      a.cast(new Bool8); // Bool8Series [true, false, true, false];

    • Concat a Series to the end of the caller, returning a new Series of a common dtype.

      Type Parameters

      Parameters

      • other: R

        The Series to concat to the end of the caller.

      • OptionalmemoryResource: MemoryResource

      Returns Series<CommonType<Struct<T>, R["type"]>>

      import {Series} from '@rapidsai/cudf';

      Series.new([1, 2, 3]).concat(Series.new([4, 5, 6])) // [1, 2, 3, 4, 5, 6]

    • Return a copy of this Series.

      Parameters

      • OptionalmemoryResource: MemoryResource

      Returns StructSeries<T>

      import {Series} from '@rapidsai/cudf';

      const a = Series.new(["foo", "bar", "test"]);

      a.copy() // StringSeries ["foo", "bar", "test"]

    • Return the number of non-null elements in the Series.

      Returns number

      The number of non-null elements

      import {Series} from '@rapidsai/cudf';

      Series.new([1, 2, 3]).countNonNulls(); // 3
      Series.new([1, null, 3]).countNonNulls(); // 2

    • Returns a new Series with duplicate values from the original removed

      Parameters

      • keep: boolean = true

        Determines whether or not to keep the duplicate items.

      • nullsEqual: boolean = true

        Determines whether nulls are handled as equal values.

      • nullsFirst: boolean = true

        Determines whether null values are inserted before or after non-null values.

      • OptionalmemoryResource: MemoryResource

        Memory resource used to allocate the result Column's device memory.

      Returns StructSeries<T>

      series without duplicate values

      import {Series} from '@rapidsai/cudf';

      // Float64Series
      Series.new([4, null, 1, 2, null, 3, 4]).dropDuplicates(
        true,
        true,
        true
      ) // [null, 1, 2, 3, 4]

      Series.new([4, null, 1, 2, null, 3, 4]).dropDuplicates(
        false,
        true,
        true
      ) // [1, 2, 3]

    • drop Null values from the series

      Parameters

      • OptionalmemoryResource: MemoryResource

        Memory resource used to allocate the result Column's device memory.

      Returns StructSeries<T>

      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.

      Type Parameters

      Parameters

      • categories: StructSeries<T> = ...

        The optional Series of values to encode into integers. Defaults to the unique elements in this Series.

      • type: R = ...

        The optional integer DataType to use for the returned Series. Defaults to Int32.

      • nullSentinel: R["scalarType"] = -1

        The optional value used to indicate missing category. Defaults to -1.

      • OptionalmemoryResource: MemoryResource

        The optional MemoryResource used to allocate the result Column's device memory.

      Returns Series<R>

      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.

      Parameters

      • value: Table

        The scalar value to fill.

      • begin: number = 0

        The starting index of the fill range (inclusive).

      • end: number = ...

        The index of the last element in the fill range (exclusive), default this.length .

      • OptionalmemoryResource: MemoryResource

        The optional MemoryResource used to allocate the result Column's device memory.

      Returns StructSeries<T>

      import {Series} from '@rapidsai/cudf';

      // Float64Series
      Series.new([1, 2, 3]).fill(0) // [0, 0, 0]
      // StringSeries
      Series.new(["foo", "bar", "test"]).fill("rplc", 0, 1) // ["rplc", "bar", "test"]
      // Bool8Series
      Series.new([true, true, true]).fill(false, 1) // [true, false, false]

    • Fills a range of elements in-place in a column with a scalar value.

      Parameters

      • value: Table

        The scalar value to fill

      • begin: number = 0

        The starting index of the fill range (inclusive)

      • end: number = ...

        The index of the last element in the fill range (exclusive)

      Returns StructSeries<T>

      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.

      Parameters

      • mask: Bool8Series

        A Series of boolean values for whose corresponding element in this Series will be selected or ignored.

      • OptionalmemoryResource: MemoryResource

        An optional MemoryResource used to allocate the result's device memory.

      Returns StructSeries<T>

      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]

    • Parameters

      • indices: number[] | Series<IndexType>

        A Series of 8/16/32-bit signed or unsigned integer indices to gather.

      • nullify_out_of_bounds: boolean = false

        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: MemoryResource

        An optional MemoryResource used to allocate the result's device memory.

      Returns StructSeries<T>

      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]

    • Return a child series by name.

      Type Parameters

      • P extends string | number | symbol

      Parameters

      • name: P

        Name of the Series to return.

      Returns Series<T[P]>

      import {Series} = require('@rapidsai/cudf');
      import * as arrow from 'apache-arrow';

      const vec = 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 a = Series.new(vec);

      a.getChild('x') // Int32Series [0, 1, 2]
      a.getChild('y') // Int32Series [3, 4, 5]

    • Return a value at the specified index to host memory

      Parameters

      • index: number

        the index in this Series to return a value for

      Returns {} | null

      import {Series} from "@rapidsai/cudf";

      // Series<Struct<{a: Float64, b: Float64}>>
      Series.new([{a: 0, b: 1}]).getValue(0) // {a: 0, b: 1}

    • Returns the first n rows.

      Parameters

      • n: number = 5

        The number of rows to return.

      Returns StructSeries<T>

      import {Series} from '@rapidsai/cudf';

      const a = Series.new([4, 6, 8, 10, 12, 1, 2]);
      const b = Series.new(["foo", "bar", "test"]);

      a.head(); // [4, 6, 8, 10, 12]
      b.head(1); // ["foo"]
      a.head(-1); // throws index out of bounds error

    • Creates a Series of BOOL8 elements where true indicates the value is valid and false indicates the value is null.

      Parameters

      • OptionalmemoryResource: MemoryResource

        Memory resource used to allocate the result Column's device memory.

      Returns Bool8Series

      A non-nullable Series of BOOL8 elements with false representing null values.

      import {Series} from '@rapidsai/cudf';

      // Float64Series
      Series.new([1, null, 3]).isNotNull() // [true, false, true]
      // StringSeries
      Series.new(["foo", "bar", null]).isNotNull() // [true, true, false]
      // Bool8Series
      Series.new([true, true, null]).isNotNull() // [true, true, false]

    • Creates a Series of BOOL8 elements where true indicates the value is null and false indicates the value is valid.

      Parameters

      • OptionalmemoryResource: MemoryResource

        Memory resource used to allocate the result Column's device memory.

      Returns Bool8Series

      A non-nullable Series of BOOL8 elements with true representing null values.

      import {Series} from '@rapidsai/cudf';

      // Float64Series
      Series.new([1, null, 3]).isNull() // [false, true, false]
      // StringSeries
      Series.new(["foo", "bar", null]).isNull() // [false, false, true]
      // Bool8Series
      Series.new([true, true, null]).isNull() // [false, false, true]

    • Returns the n largest element(s).

      Parameters

      • n: number = 5

        The number of values to retrieve.

      • keep: "none" | "any" | "first" | "last" = 'first'

        Determines whether to keep the first or last of any duplicate values.

      Returns StructSeries<T>

      import {Series} from '@rapidsai/cudf';

      const a = Series.new([4, 6, 8, 10, 12, 1, 2]);
      const b = Series.new(["foo", "bar", "test"]);

      a.nLargest(); // [12, 10, 8, 6, 4]
      b.nLargest(1); // ["test"]
      a.nLargest(-1); // []

    • Returns the n smallest element(s).

      Parameters

      • n: number = 5

        The number of values to retrieve.

      • keep: "none" | "any" | "first" | "last" = 'first'

        Determines whether to keep the first or last of any duplicate values.

      Returns StructSeries<T>

      import {Series} from '@rapidsai/cudf';

      const a = Series.new([4, 6, 8, 10, 12, 1, 2]);
      const b = Series.new(["foo", "bar", "test"]);

      a.nSmallest(); // [1, 2, 4, 6, 8]
      b.nSmallest(1); // ["bar"]
      a.nSmallest(-1); // []

    • Generate an ordering that sorts the Series in a specified way.

      Parameters

      • ascending: boolean = true

        whether to sort ascending (true) or descending (false)

      • null_order: "after" | "before" = 'after'

        whether nulls should sort before or after other values

      • OptionalmemoryResource: MemoryResource

        An optional MemoryResource used to allocate the result's device memory.

      Returns Int32Series

      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]

    • Replace null values with a scalar value.

      Parameters

      • value: any

        The scalar value to use in place of nulls.

      • OptionalmemoryResource: MemoryResource

        The optional MemoryResource used to allocate the result Column's device memory.

      Returns StructSeries<T>

      import {Series} from '@rapidsai/cudf';

      // Float64Series
      Series.new([1, null, 3]).replaceNulls(-1) // [1, -1, 3]
      // StringSeries
      Series.new(["foo", "bar", null]).replaceNulls("rplc") // ["foo", "bar", "rplc"]
      // Bool8Series
      Series.new([null, true, true]).replaceNulls(false) // [true, true, true]

    • Replace null values with the corresponding elements from another Series.

      Parameters

      • value: StructSeries<T>

        The Series to use in place of nulls.

      • OptionalmemoryResource: MemoryResource

        The optional MemoryResource used to allocate the result Column's device memory.

      Returns StructSeries<T>

      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.

      Parameters

      • OptionalmemoryResource: MemoryResource

        The optional MemoryResource used to allocate the result Column's device memory.

      Returns StructSeries<T>

      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.

      Parameters

      • OptionalmemoryResource: MemoryResource

        The optional MemoryResource used to allocate the result Column's device memory.

      Returns StructSeries<T>

      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]

    • Returns a new series with reversed elements.

      Parameters

      • OptionalmemoryResource: MemoryResource

        An optional MemoryResource used to allocate the result's device memory.

      Returns StructSeries<T>

      import {Series} from '@rapidsai/cudf';

      // Float64Series
      Series.new([1, 2, 3]).reverse() // [3, 2, 1]
      // StringSeries
      Series.new(["foo", "bar"]).reverse() // ["bar", "foo"]
      // Bool8Series
      Series.new([false, true]).reverse() // [true, false]

    • Scatters single value into this Series according to provided indices.

      Parameters

      • value: Table

        A column of values to be scattered in to this Series

      • indices: number[] | Series<IndexType>

        A column of integral indices that indicate the rows in the this Series to be replaced by value.

      • OptionalmemoryResource: MemoryResource

        An optional MemoryResource used to allocate the result's device memory.

      Returns StructSeries<T>

      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.

      Parameters

      • values: StructSeries<T>
      • indices: number[] | Series<IndexType>

        A column of integral indices that indicate the rows in the this Series to be replaced by value.

      • OptionalmemoryResource: MemoryResource

        An optional MemoryResource used to allocate the result's device memory.

      Returns StructSeries<T>

      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

    • Parameters

      • mask: ArrayLike<number> | MemoryData | ArrayLike<bigint>

        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: number

        The number of null values. If None, it is calculated automatically.

      Returns void

    • set values at the specified indices

      Parameters

      • indices: number[] | Int32Series

        the indices in this Series to set values for

      • values: Table | StructSeries<T>

        the values to set at Series of indices

      Returns void

      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.

      Parameters

      • ascending: boolean = true

        whether to sort ascending (true) or descending (false) Default: true

      • null_order: "after" | "before" = 'after'

        whether nulls should sort before or after other values Default: before

      • OptionalmemoryResource: MemoryResource

        An optional MemoryResource used to allocate the result's device memory.

      Returns StructSeries<T>

      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]

    • Returns the last n rows.

      Parameters

      • n: number = 5

        The number of rows to return.

      Returns StructSeries<T>

      import {Series} from '@rapidsai/cudf';

      const a = Series.new([4, 6, 8, 10, 12, 1, 2]);
      const b = Series.new(["foo", "bar", "test"]);

      a.tail(); // [8, 10, 12, 1, 2]
      b.tail(1); // ["test"]
      a.tail(-1); // throws index out of bounds error

    • Copy the underlying device memory to host and return an Array (or TypedArray) of the values.

      Returns StructRowProxy<T>[]

    • Return a string with a tabular representation of the Series, pretty-printed according to the options given.

      Parameters

      • options: DisplayOptions & { name?: string } = {}

      Returns string

    • Returns a new Series with only the unique values that were found in the original

      Parameters

      • nullsEqual: boolean = true

        Determines whether nulls are handled as equal values.

      • OptionalmemoryResource: MemoryResource

        Memory resource used to allocate the result Column's device memory.

      Returns StructSeries<T>

      series without duplicate values

      import {Series} from '@rapidsai/cudf';

      // Float64Series
      Series.new([null, null, 1, 2, 3, 3]).unique(true) // [null, 1, 2, 3]
      Series.new([null, null, 1, 2, 3, 3]).unique(false) // [null, null, 1, 2, 3]

    • 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.

      Returns { count: Int32Series; value: StructSeries<T> }

      object with keys "value" and "count"

    • Create a new cudf.Series from an apache arrow vector

      Type Parameters

      • T extends Vector<any>

      Parameters

      • input: T

      Returns Series<ArrowToCUDFType<T["type"]>>

      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

      Type Parameters

      Parameters

      • input: T

      Returns T

      import {Series, Int32} from '@rapidsai/cudf';

      //using SeriesProps
      const a = Series.new({type: new Int32, data: [1, 2, 3, 4]}); // Int32Series [1, 2, 3, 4]

      //using underlying cudf.Column
      const b = Series.new(a._col); // Int32Series [1, 2, 3, 4]

    • Create a new cudf.Series from an apache arrow vector

      Type Parameters

      Parameters

      Returns Series<T>

      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

      Type Parameters

      Parameters

      Returns Series<T>

      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

      Parameters

      Returns Int8Series

      import {
       Series,
       Int8Series,
       Int8
      } from '@rapidsai/cudf';

      // Int8Series [1, 2, 3]
      const a = Series.new(new Int8Array([1, 2, 3]));
      const b = Series.new(new Int8Buffer([1, 2, 3]));

    • Create a new cudf.Int16Series

      Parameters

      Returns Int16Series

      import {
       Series,
       Int16Series,
       Int16
      } from '@rapidsai/cudf';

      // Int16Series [1, 2, 3]
      const a = Series.new(new Int16Array([1, 2, 3]));
      const b = Series.new(new Int16Buffer([1, 2, 3]));

    • Create a new cudf.Int32Series

      Parameters

      Returns Int32Series

      import {
       Series,
       Int32Series,
       Int32
      } from '@rapidsai/cudf';

      // Int32Series [1, 2, 3]
      const a = Series.new(new Int32Array([1, 2, 3]));
      const b = Series.new(new Int32Buffer([1, 2, 3]));

    • Create a new cudf.Uint8Series

      Parameters

      Returns Uint8Series

      import {
       Series,
       Uint8Series,
       Uint8
      } from '@rapidsai/cudf';

      // Uint8Series [1, 2, 3]
      const a = Series.new(new Uint8Array([1, 2, 3]));
      const b = Series.new(new Uint8Buffer([1, 2, 3]));
      const c = Series.new(new Uint8ClampedArray([1, 2, 3]));
      const d = Series.new(new Uint8ClampedBuffer([1, 2, 3]));

    • Create a new cudf.Uint16Series

      Parameters

      Returns Uint16Series

      import {
       Series,
       Uint16Series,
       Uint16
      } from '@rapidsai/cudf';

      // Uint16Series [1, 2, 3]
      const a = Series.new(new Uint16Array([1, 2, 3]));
      const b = Series.new(new Uint16Buffer([1, 2, 3]));

    • Create a new cudf.Uint32Series

      Parameters

      Returns Uint32Series

      import {
       Series,
       Uint32Series,
       Uint32
      } from '@rapidsai/cudf';

      // Uint32Series [1, 2, 3]
      const a = Series.new(new Uint32Array([1, 2, 3]));
      const b = Series.new(new Uint32Buffer([1, 2, 3]));

    • Create a new cudf.Uint64Series

      Parameters

      Returns Uint64Series

      import {
       Series,
       Uint64Series,
       Uint64
      } from '@rapidsai/cudf';

      // Uint64Series [1n, 2n, 3n]
      const a = Series.new(new BigUint64Array([1n, 2n, 3n]));
      const b = Series.new(new Uint64Buffer([1n, 2n, 3n]));

    • Create a new cudf.Float32Series

      Parameters

      Returns Float32Series

      import {
       Series,
       Float32Series,
       Float32
      } from '@rapidsai/cudf';

      // Float32Series [1, 2, 3]
      const a = Series.new(new Float32Array([1, 2, 3]));
      const b = Series.new(new Float32Buffer([1, 2, 3]));

    • Create a new cudf.StringSeries

      Parameters

      • input: (string | null | undefined)[]

      Returns StringSeries

      import {Series} from '@rapidsai/cudf';

      // StringSeries ["foo", "bar", "test", null]
      const a = Series.new(["foo", "bar", "test", null]);

    • Create a new cudf.Float64Series

      Parameters

      • input: Float64Array<ArrayBufferLike> | (number | null | undefined)[] | Float64Buffer

      Returns Float64Series

      import {Series} from '@rapidsai/cudf';

      // Float64Series [1, 2, 3, null, 4]
      const a = Series.new([1, 2, 3, undefined, 4]);

    • Create a new cudf.Int64Series

      Parameters

      • input: BigInt64Array<ArrayBufferLike> | (bigint | null | undefined)[] | Int64Buffer

      Returns Int64Series

      import {Series} from '@rapidsai/cudf';

      // Int64Series [1n, 2n, 3n, null, 4n]
      const a = Series.new([1n, 2n, 3n, undefined, 4n]);

    • Create a new cudf.Bool8Series

      Parameters

      • input: (boolean | null | undefined)[]

      Returns Bool8Series

      import {Series} from '@rapidsai/cudf';

      // Bool8Series [true, false, null, false]
      const a = Series.new([true, false, undefined, false]);

    • Create a new cudf.TimestampMillisecondSeries

      Parameters

      • input: (Date | null | undefined)[]

      Returns TimestampMillisecondSeries

      import {Series} from '@rapidsai/cudf';

      // TimestampMillisecondSeries [2021-05-13T00:00:00.000Z, null, 2021-05-13T00:00:00.000Z,
      null] const a = Series.new([new Date(), undefined, new Date(), undefined]);

    • Create a new cudf.ListSeries that contain cudf.StringSeries elements.

      Parameters

      • input: (string | null | undefined)[][]

      Returns ListSeries<Utf8String>

      import {Series} from '@rapidsai/cudf';

      // ListSeries [["foo", "bar"], ["test", null]]
      const a = Series.new([["foo", "bar"], ["test",null]]);
      a.getValue(0) // StringSeries ["foo", "bar"]
      a.getValue(1) // StringSeries ["test", null]

    • Create a new cudf.ListSeries that contain cudf.Float64Series elements.

      Parameters

      • input: (number | null | undefined)[][]

      Returns ListSeries<Float64>

      import {Series} from '@rapidsai/cudf';

      // ListSeries [[1, 2], [3, null, 4]]
      const a = Series.new([[1, 2], [3, undefined, 4]]);
      a.getValue(0) // Float64Series [1, 2]
      a.getValue(1) // Float64Series [3, null, 4]

    • Create a new cudf.ListSeries that contain cudf.Int64Series elements.

      Parameters

      • input: (bigint | null | undefined)[][]

      Returns ListSeries<Int64>

      import {Series} from '@rapidsai/cudf';

      // ListSeries [[1n, 2n], [3n, null, 4n]]
      const a = Series.new([[1n, 2n], [3n, undefined, 4n]]);
      a.getValue(0) // Int64Series [1n, 2n]
      a.getValue(1) // Int64Series [3n, null, 4n]

    • Create a new cudf.ListSeries that contain cudf.Bool8Series elements.

      Parameters

      • input: (boolean | null | undefined)[][]

      Returns ListSeries<Bool8>

      import {Series} from '@rapidsai/cudf';

      // ListSeries [[true, false], [null, false]]
      const a = Series.new([[true, false], [undefined, false]]);
      a.getValue(0) // Bool8Series [true, false]
      a.getValue(1) // Bool8Series [null, false]

    • Create a new cudf.ListSeries that contain cudf.TimestampMillisecondSeries elements.

      Parameters

      • input: (Date | null | undefined)[][]

      Returns ListSeries<TimestampMillisecond>

      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

      Type Parameters

      • T extends readonly unknown[]

      Parameters

      • input: T

      Returns Series<ArrowToCUDFType<JavaScriptArrayDataType<T>>>

      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

      Type Parameters

      Parameters

      • input:
            | (boolean | null | undefined)[]
            | (number | null | undefined)[]
            | (bigint | null | undefined)[]
            | (string | null | undefined)[]
            | (Date | null | undefined)[]
            | AbstractSeries<T>
            | Column<T>
            | SeriesProps<T>
            | Vector<T>
            | (string | null | undefined)[][]
            | (number | null | undefined)[][]
            | (bigint | null | undefined)[][]
            | (boolean | null | undefined)[][]
            | (Date | null | undefined)[][]

      Returns Series<T>

      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 }]

    • Constructs a Series from a text file path.

      Parameters

      • filepath: string

        Path of the input file.

      • delimiter: string

        Optional delimiter.

      Returns StringSeries

      StringSeries from the file, split by delimiter.

      If delimiter is omitted, the default is ''.

      import {Series} from '@rapidsai/cudf';

      const infile = Series.readText('./inputAsciiFile.txt')

    • Constructs a Series with a sequence of values.

      Type Parameters

      Parameters

      • opts: {
            init?: U["scalarType"];
            memoryResource?: MemoryResource;
            size: number;
            step?: U["scalarType"];
            type?: U;
        }

        Options for creating the sequence

      Returns Series<U>

      Series with the sequence

      If init is omitted, the default is 0.

      If step is omitted, the default is 1.

      If type is omitted, the default is Int32.

      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]

    Settings

    Member Visibility

    On This Page

    Accessors
    Methods