Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Uint16Series

A Series of 16-bit unsigned integer values in GPU memory.

Hierarchy

Index

Accessors

Methods

Accessors

data

hasNulls

  • get hasNulls(): boolean

length

  • get length(): number

mask

  • get mask(): DeviceBuffer

  • The DeviceBuffer for for the validity bitmask in GPU memory.

    Returns DeviceBuffer

nullCount

  • get nullCount(): number

nullable

  • get nullable(): boolean

numChildren

  • get numChildren(): number

offset

  • get offset(): number

type

  • get type(): T

Methods

[iterator]

  • [iterator](): IterableIterator<null | number>

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

    Returns IterableIterator<null | number>

_castAsCategorical

  • _castAsCategorical<R>(type: R, memoryResource?: MemoryResource): Series<R>

_castAsString

  • _castAsString(memoryResource?: MemoryResource): StringSeries

_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

abs

  • Compute the absolute value for each value in this Series.

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

    Series.new([-1, 2, -3, 4, 5]).abs(); // [1, 2, 3, 4, 5]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

acos

  • Compute the trigonometric cosine inverse for each value in this Series.

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

    Series.new([0, 45, 1]).acos(); // [1.5707963267948966, NaN, 0]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

acosh

  • Compute the hyperbolic cosine inverse for each value in this Series.

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

    Series.new([7, 56, 1]).acosh(); // [2.6339157938496336, 4.71841914237288, 0]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

add

all

  • all(skipNulls?: boolean, memoryResource?: MemoryResource): boolean

  • Return whether all elements are true in Series.

    example
    import {Series} from '@rapidsai/cudf';
    //boolean series
    Series.new([true, false, true]).all() // false
    Series.new([true, true, true]).all() // true

    Parameters

    • skipNulls: boolean = true

      bool Exclude null values. If the entire row/column is NA and skipNulls is true, then the result will be true, as for an empty row/column. If skipNulls is false, then NA are treated as true, because these are not equal to zero.

    • Optional memoryResource: MemoryResource

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

    Returns boolean

    true if all elements are true in Series, else false.

any

  • any(skipNulls?: boolean, memoryResource?: MemoryResource): boolean

  • Return whether any elements are true in Series.

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

    //boolean series
    Series.new([false, false, false]).any() // false
    Series.new([true, false, true]).any() // true

    Parameters

    • skipNulls: boolean = true

      bool Exclude NA/null values. If the entire row/column is NA and skipNulls is true, then the result will be true, as for an empty row/column. If skipNulls is false, then NA are treated as true, because these are not equal to zero.

    • Optional memoryResource: MemoryResource

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

    Returns boolean

    true if any elements are true in Series, else false.

asin

  • Compute the trigonometric sine inverse for each value in this Series.

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

    Series.new([0, 45, 1]).asin(); // [0, NaN, 1.5707963267948966]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

asinh

  • Compute the hyperbolic sine inverse for each value in this Series.

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

    Series.new([0, 45, 1]).asinh(); // [0, 4.49993310426429, 0.8813735870195429]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

atan

  • Compute the trigonometric tangent inverse for each value in this Series.

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

    Series.new([0, 45, 1]).atan(); // [0, 1.5485777614681775, 0.7853981633974483]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

atan2

  • Perform a binary atan2 operation between this Series and another Series or scalar value.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 3, 5, null, 7]);
    const b = Series.new([1, 3, 3, null, 9]);

    a.atan2(3);
    // [0.3217505543966422, 0.7853981633974483, 1.0303768265243125, 0, 1.1659045405098132]

    a.atan2(b);
    // [0.7853981633974483, 0.7853981633974483, 1.0303768265243125, 0, 0.6610431688506869]

    Parameters

    • rhs: bigint

      The other Series or scalar to use.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

atanh

  • Compute the hyperbolic tangent inverse for each value in this Series.

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

    Series.new([0, -0.5]).atanh(); // [0, -0.5493061443340549]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

bitInvert

  • Compute the bitwise not (~) for each value in this Series.

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

bitwiseAnd

bitwiseOr

bitwiseXor

cast

  • cast<R>(dataType: R, memoryResource?: MemoryResource): Series<R>

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

    example
    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];

    Type parameters

    Parameters

    • dataType: R

      The new dtype.

    • Optional memoryResource: 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.

cbrt

  • Compute the cube-root (x^(1.0/3)) for each value in this Series.

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

    Series.new([-1.2, 2.5]).cbrt(); // [-1.0626585691826111, 1.3572088082974534]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

ceil

  • Compute the smallest integer value not less than arg for each value in this Series.

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

    Series.new([-1.2, 2.5, -3, 4.6, 5]).ceil(); // [-1, 3, -3, 5, 5]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

concat

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

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

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

    Type parameters

    Parameters

    • other: R

      The Series to concat to the end of the caller.

    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

copy

  • Return a copy of this Series.

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

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

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

    Parameters

    • Optional memoryResource: MemoryResource

    Returns Uint16Series

cos

  • Compute the trigonometric cosine for each value in this Series.

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

    Series.new([0, 45, 1]).cos(); // [1, 0.5253219888177297, 0.5403023058681398]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

cosh

  • Compute the hyperbolic cosine for each value in this Series.

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

    Series.new([0, 45, 1]).cosh(); // [1, 17467135528742547000, 1.5430806348152437]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

countNonNulls

  • countNonNulls(): number

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

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

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

    Returns number

    The number of non-null elements

cumulativeMax

  • cumulativeMax(skipNulls?: boolean, memoryResource?: MemoryResource): Uint16Series

  • Compute the cumulative max of all values in this Series.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([4, 2, 5, 1, 1]).cast(new Int32)

    a.cumulativeMax() // {4, 4, 5, 5, 5}

    Parameters

    • skipNulls: boolean = true

      The optional skipNulls if true drops NA and null values before computing reduction, else if skipNulls is false, reduction is computed directly.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    The cumulative max of all the values in this Series.

cumulativeMin

  • cumulativeMin(skipNulls?: boolean, memoryResource?: MemoryResource): Uint16Series

  • Compute the cumulative min of all values in this Series.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([4, 2, 5, 1, 1]).cast(new Int32)

    a.cumulativeMin() // {4, 2, 2, 1, 1}

    Parameters

    • skipNulls: boolean = true

      The optional skipNulls if true drops NA and null values before computing reduction, else if skipNulls is false, reduction is computed directly.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    The cumulative min of all the values in this Series.

cumulativeProduct

  • cumulativeProduct(skipNulls?: boolean, memoryResource?: MemoryResource): Uint16Series

  • Compute the cumulative product of all values in this Series.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([4, 2, 5, 1, 1]).cast(new Int32)

    a.cumulativeProduct() // {4, 8, 40, 40, 40}

    Parameters

    • skipNulls: boolean = true

      The optional skipNulls if true drops NA and null values before computing reduction, else if skipNulls is false, reduction is computed directly.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    The cumulative product of all the values in this Series.

cumulativeSum

  • cumulativeSum(skipNulls?: boolean, memoryResource?: MemoryResource): Uint16Series

  • Compute the cumulative sum of all values in this Series.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([4, 2, 5, 1, 1]).cast(new Int32)

    a.cumulativeSum() // {4, 6, 11, 12, 13}

    Parameters

    • skipNulls: boolean = true

      The optional skipNulls if true drops NA and null values before computing reduction, else if skipNulls is false, reduction is computed directly.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    The cumulative sum of all the values in this Series.

dispose

  • dispose(): void
  • summary

    Explicitly free the device memory associated with this Series.

    Returns void

div

  • Divide this Series and another Series or scalar value.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([10, 12, 14, 20]);
    const b = Series.new([3, 2, 1, 3]);

    a.div(3); // [3.3333333333333335, 4, 4.666666666666667, 6.666666666666667]
    a.div(b); // [3.3333333333333335, 6, 14, 6.666666666666667]

    Parameters

    • rhs: bigint

      The other Series or scalar to divide this Series by.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

dropDuplicates

  • dropDuplicates(keep?: boolean, nullsEqual?: boolean, nullsFirst?: boolean, memoryResource?: MemoryResource): Uint16Series

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

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

    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.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    series without duplicate values

dropNulls

  • drop Null values from the series

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

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    series without Null values

encodeLabels

  • encodeLabels<R>(categories?: Uint16Series, type?: R, nullSentinel?: R["scalarType"], memoryResource?: MemoryResource): Series<R>

  • Encode the Series values into integer labels.

    Type parameters

    Parameters

    • categories: Uint16Series = ...

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

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

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

    • Optional memoryResource: 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

eq

  • eq(rhs: bigint, memoryResource?: MemoryResource): Bool8Series
  • eq(rhs: number, memoryResource?: MemoryResource): Bool8Series
  • eq<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series
  • eq<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series

  • Perform the binary '==' operation between this column and another Series or scalar value.

    rhs

    The other Series or scalar to compare with this column.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([0, 1, 2, 3]);
    const b = Series.new([3, 2, 1, 3]);

    a.eq(1); // [ false, true, false, false ]
    a.eq(b); // [ false, false, false, true ]

    Parameters

    • rhs: bigint
    • Optional memoryResource: MemoryResource

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

    Returns Bool8Series

    A Series of booleans with the comparison result.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

exp

  • Compute the exponential (base e, euler number) for each value in this Series.

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

    Series.new([-1.2, 2.5]).exp(); // [0.30119421191220214, 12.182493960703473]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

fill

  • fill(value: number, begin?: number, end?: number, memoryResource?: MemoryResource): Uint16Series

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

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

    Parameters

    • value: number

      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 .

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

fillInPlace

  • fillInPlace(value: number, begin?: number, end?: number): Uint16Series

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

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

    Parameters

    • value: number

      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 Uint16Series

filter

  • Return a sub-selection of this Series using the specified boolean mask.

    example
    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

    • mask: Bool8Series

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

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

floor

  • Compute the largest integer value not greater than arg for each value in this Series.

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

    Series.new([-1.2, 2.5, -3, 4.6, 5]).floor(); // [-2, 2, -3, 4, 5]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

floorDiv

  • Floor-divide this Series and another Series or scalar value.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([10, 12, 14, 20]);
    const b = Series.new([3, 2, 1, 3]);

    a.floorDiv(3); // [ 3, 4, 4, 6 ]
    a.floorDiv(b); // [ 3, 6, 14, 6 ]

    Parameters

    • rhs: bigint

      The other Series or scalar to floor-divide this Series by.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

gather

  • summary

    Return sub-selection from a Series using the specified integral indices.

    description

    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.

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

    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.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

ge

  • ge(rhs: bigint, memoryResource?: MemoryResource): Bool8Series
  • ge(rhs: number, memoryResource?: MemoryResource): Bool8Series
  • ge<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series
  • ge<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series

  • Perform the binary '>=' operation between this column and another Series or scalar value.

    rhs

    The other Series or scalar to compare with this column.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([0, 1, 2, 3]);
    const b = Series.new([3, 2, 1, 3]);

    a.ge(1); // [false, true, true, true]
    a.ge(b); // [false, false, true, true]

    Parameters

    • rhs: bigint
    • Optional memoryResource: MemoryResource

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

    Returns Bool8Series

    A Series of booleans with the comparison result.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

getValue

  • getValue(index: number): null | number

  • Return a value at the specified index to host memory

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

    // Float64Series
    Series.new([1, 2, 3]).getValue(0) // 1
    Series.new([1, 2, 3]).getValue(2) // 3
    Series.new([1, 2, 3]).getValue(3) // throws index out of bounds error

    Parameters

    • index: number

      the index in this Series to return a value for

    Returns null | number

gt

  • gt(rhs: bigint, memoryResource?: MemoryResource): Bool8Series
  • gt(rhs: number, memoryResource?: MemoryResource): Bool8Series
  • gt<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series
  • gt<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series

  • Perform the binary '>' operation between this column and another Series or scalar value.

    rhs

    The other Series or scalar to compare with this column.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([0, 1, 2, 3]);
    const b = Series.new([3, 2, 1, 3]);

    a.gt(1); // [false, false, true, true]
    a.gt(b); // [false, false, true, false]

    Parameters

    • rhs: bigint
    • Optional memoryResource: MemoryResource

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

    Returns Bool8Series

    A Series of booleans with the comparison result.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

head

  • Returns the first n rows.

    example
    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

    Parameters

    • n: number = 5

      The number of rows to return.

    Returns Uint16Series

isNotNull

  • isNotNull(memoryResource?: MemoryResource): Bool8Series

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

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

    Parameters

    • Optional memoryResource: 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.

isNull

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

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

    Parameters

    • Optional memoryResource: 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.

kurtosis

  • kurtosis(skipNulls?: boolean): number

  • Return Fisher’s unbiased kurtosis of a sample. Kurtosis obtained using Fisher’s definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 2, 3, 4]);

    a.kurtosis() // -1.1999999999999904

    Parameters

    • skipNulls: boolean = true

      Exclude NA/null values. If an entire row/column is NA, the result will be NA.

    Returns number

    The unbiased kurtosis of all the values in this Series.

le

  • le(rhs: bigint, memoryResource?: MemoryResource): Bool8Series
  • le(rhs: number, memoryResource?: MemoryResource): Bool8Series
  • le<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series
  • le<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series

  • Perform the binary '<=' operation between this column and another Series or scalar value.

    rhs

    The other Series or scalar to compare with this column.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([0, 1, 2, 3]);
    const b = Series.new([3, 2, 1, 3]);

    a.le(1); // [true, true, false, false]
    a.le(b); // [true, true, false, true]

    Parameters

    • rhs: bigint
    • Optional memoryResource: MemoryResource

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

    Returns Bool8Series

    A Series of booleans with the comparison result.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

log

  • Compute the natural logarithm (base e) for each value in this Series.

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

    Series.new([-1.2, 2.5, 4]).log(); // [NaN, 0.9162907318741551, 1.3862943611198906]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

logBase

  • Perform a binary logBase operation between this Series and another Series or scalar value.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 10, 100]);
    const b = Series.new([2, 10, 20]);

    a.logBase(10); // [0, 1, 2]
    a.logBase(b); // [0, 1, 1.537243573680482]

    Parameters

    • rhs: bigint

      The other Series or scalar to use.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

logicalAnd

  • Perform a binary && operation between this Series and another Series or scalar value.

    example
    import {Series, Bool8} from '@rapidsai/cudf';
    const a = Series.new([false, true, true, false]);
    const b = Series.new([false, false, false, false]);

    a.logicalAnd(0); // Float64Series [ 0, 0, 0, 0 ]
    a.logicalAnd(0).view(new Bool8); // Bool8Series [ false, false, false, false ]
    a.logicalAnd(b); // [false, false, false, false]

    Parameters

    • rhs: bigint

      The other Series or scalar to use.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

logicalOr

  • Perform a binary || operation between this Series and another Series or scalar value.

    example
    import {Series, Bool8} from '@rapidsai/cudf';
    const a = Series.new([false, true, true, false]);
    const b = Series.new([false, false, false, false]);

    a.logicalOr(0); // Float64Series [ 0, 1, 1, 0 ]
    a.logicalOr(0).cast(new Bool8); // Bool8Series [ false, true, true, false ]
    a.logicalOr(b); // [false, true, true, false]

    Parameters

    • rhs: bigint

      The other Series or scalar to use.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

lt

  • lt(rhs: bigint, memoryResource?: MemoryResource): Bool8Series
  • lt(rhs: number, memoryResource?: MemoryResource): Bool8Series
  • lt<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series
  • lt<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series

  • Perform the binary '<' operation between this column and another Series or scalar value.

    rhs

    The other Series or scalar to compare with this column.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([0, 1, 2, 3]);
    const b = Series.new([3, 2, 1, 3]);

    a.lt(1); // [true, false, false, false]
    a.lt(b); // [true, true, false, false]

    Parameters

    • rhs: bigint
    • Optional memoryResource: MemoryResource

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

    Returns Bool8Series

    A Series of booleans with the comparison result.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

max

  • max(skipNulls?: boolean, memoryResource?: MemoryResource): number

mean

  • mean(skipNulls?: boolean, memoryResource?: MemoryResource): number

  • Compute the mean of all values in this Series.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([5, 4, 1, 1, 1])

    a.mean() // 2.4

    Parameters

    • skipNulls: boolean = true

      The optional skipNulls if true drops NA and null values before computing reduction, else if skipNulls is false, reduction is computed directly.

    • Optional memoryResource: MemoryResource

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

    Returns number

    The mean of all the values in this Series.

median

  • median(skipNulls?: boolean, memoryResource?: MemoryResource): number | bigint | boolean

  • Compute the median of all values in this Series.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([5, 4, 1, 1, 1])

    a.median() // 1

    Parameters

    • skipNulls: boolean = true

      The optional skipNulls if true drops NA and null values before computing reduction, else if skipNulls is false, reduction is computed directly.

    • Optional memoryResource: MemoryResource

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

    Returns number | bigint | boolean

    The median of all the values in this Series.

min

  • min(skipNulls?: boolean, memoryResource?: MemoryResource): number

minmax

  • minmax(skipNulls?: boolean, memoryResource?: MemoryResource): [number, number]

mod

mul

nLargest

  • nLargest(n?: number, keep?: "any" | "first" | "last" | "none"): Uint16Series

  • Returns the n largest element(s).

    example
    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); // []

    Parameters

    • n: number = 5

      The number of values to retrieve.

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

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

    Returns Uint16Series

nSmallest

  • nSmallest(n?: number, keep?: "any" | "first" | "last" | "none"): Uint16Series

  • Returns the n smallest element(s).

    example
    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); // []

    Parameters

    • n: number = 5

      The number of values to retrieve.

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

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

    Returns Uint16Series

ne

  • ne(rhs: bigint, memoryResource?: MemoryResource): Bool8Series
  • ne(rhs: number, memoryResource?: MemoryResource): Bool8Series
  • ne<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series
  • ne<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series

  • Perform the binary '!=' operation between this column and another Series or scalar value.

    rhs

    The other Series or scalar to compare with this column.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([0, 1, 2, 3]);
    const b = Series.new([3, 2, 1, 3]);

    a.ne(1); // [true, false, true, true]
    a.ne(b); // [true, true, true, false]

    Parameters

    • rhs: bigint
    • Optional memoryResource: MemoryResource

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

    Returns Bool8Series

    A Series of booleans with the comparison result.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

not

  • Compute the logical not (!) for each value in this Series.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([true, false, true, true, false])
    const b = Series.new([0, 1, 2, 3, 4])

    a.not() // [false, true, false, false, true]
    b.not() // [true, false, false, false, false]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Bool8Series

    A Series of the same number of elements containing the result of the operation.

nullEquals

  • nullEquals(rhs: bigint, memoryResource?: MemoryResource): Bool8Series
  • nullEquals(rhs: number, memoryResource?: MemoryResource): Bool8Series
  • nullEquals<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series
  • nullEquals<R>(rhs: R, memoryResource?: MemoryResource): Bool8Series

  • Perform a binary nullEquals operation between this Series and another Series or scalar value.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 3, 5, null, 7]);
    const b = Series.new([1, 3, 3, null, 9]);

    a.nullEquals(3); // [false, true, false, false, false]
    a.nullEquals(b); // [true, true, false, true, false]

    Parameters

    • rhs: bigint

      The other Series or scalar to use.

    • Optional memoryResource: MemoryResource

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

    Returns Bool8Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Bool8Series

nullMax

  • Perform a binary nullMax operation between this Series and another Series or scalar value.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 3, 5, null, 7]);
    const b = Series.new([6, 6, 6, 6, 6]);

    a.nullMax(4); // [4, 4, 5, 4, 7]
    a.nullMax(b); // [6, 6, 6, 6, 7]

    Parameters

    • rhs: bigint

      The other Series or scalar to use.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

nullMin

  • Perform a binary nullMin operation between this Series and another Series or scalar value.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 3, 5, null, 7]);
    const c = Series.new([6, 6, 6, 6, 6]);

    a.nullMin(4); // [1, 3, 4, 4, 4]
    a.nullMin(b); // [1, 3, 5, 6, 6]

    Parameters

    • rhs: bigint

      The other Series or scalar to use.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

nunique

  • nunique(dropna?: boolean, memoryResource?: MemoryResource): number

  • Compute the nunique of all values in this Series.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 2, 3, 4, 4, 5, null, null]);

    a.nunique() // 5
    a.nunique(false) // 6

    Parameters

    • dropna: boolean = true

      The optional dropna if true drops NA and null values before computing reduction, else if dropna is false, reduction is computed directly.

    • Optional memoryResource: MemoryResource

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

    Returns number

    The number of unqiue values in this Series.

orderBy

  • orderBy(ascending?: boolean, null_order?: "after" | "before", memoryResource?: MemoryResource): Int32Series

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

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

    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

    • Optional memoryResource: MemoryResource

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

    Returns Int32Series

    Series containting the permutation indices for the desired sort order

pow

product

  • product(skipNulls?: boolean, memoryResource?: MemoryResource): bigint

quantile

  • quantile(q?: number, interpolation?: "linear" | "lower" | "higher" | "midpoint" | "nearest", memoryResource?: MemoryResource): number

  • Return values at the given quantile.

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

    const a = Series.new([1, 2, 3, 4, 5])

    a.quantile(0.3, "linear") // 2.2
    a.quantile(0.3, "lower") // 2
    a.quantile(0.3, "higher") // 3
    a.quantile(0.3, "midpoint") // 2.5
    a.quantile(0.3, "nearest") // 2

    Parameters

    • q: number = 0.5

      the quantile(s) to compute, 0 <= q <= 1

    • interpolation: "linear" | "lower" | "higher" | "midpoint" | "nearest" = 'linear'

      This optional parameter specifies the interpolation method to use, when the desired quantile lies between two data points i and j. Valid values: ’linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’.

    • Optional memoryResource: MemoryResource

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

    Returns number

    values at the given quantile.

replaceNulls

  • Replace null values with a scalar value.

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

    Parameters

    • value: any

      The scalar value to use in place of nulls.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

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

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

    Parameters

    • value: Uint16Series

      The Series to use in place of nulls.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

replaceNullsFollowing

  • replaceNullsFollowing(memoryResource?: MemoryResource): Uint16Series

  • Replace null values with the non-null value following the null value in the same series.

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

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

replaceNullsPreceding

  • replaceNullsPreceding(memoryResource?: MemoryResource): Uint16Series

  • Replace null values with the non-null value preceding the null value in the same series.

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

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

reverse

  • Returns a new series with reversed elements.

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

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

scale

  • summary

    Scale values to [0, 1] in float64

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Float64Series

    Series with values scaled between [0, 1].

scatter

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

    example
    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

    Parameters

    • value: number

      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.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

  • Scatters a column of values into this Series according to provided indices.

    example
    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

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

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

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

setNullMask

  • setNullMask(mask: MemoryData | ArrayLike<number> | ArrayLike<bigint>, nullCount?: number): void

  • Parameters

    • mask: MemoryData | ArrayLike<number> | 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
    • Optional nullCount: number

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

    Returns void

setValue

  • setValue(index: number, value: number): void

  • set value at the specified index

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

    // Float64Series
    const a = Series.new([1, 2, 3]);
    a.setValue(0, -1) // inplace update -> Series([-1, 2, 3])

    Parameters

    • index: number

      the index in this Series to set a value for

    • value: number

      the value to set at index

    Returns void

setValues

  • set values at the specified indices

    example
    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];

    Parameters

    • indices: number[] | Int32Series

      the indices in this Series to set values for

    • values: number | Uint16Series

      the values to set at Series of indices

    Returns void

shiftLeft

shiftRight

shiftRightUnsigned

  • shiftRightUnsigned(rhs: bigint, memoryResource?: MemoryResource): Int64Series
  • shiftRightUnsigned(rhs: number, memoryResource?: MemoryResource): Float64Series
  • shiftRightUnsigned<R>(rhs: R, memoryResource?: MemoryResource): Series<CommonType<Uint16, R["type"]>>
  • shiftRightUnsigned<R>(rhs: R, memoryResource?: MemoryResource): Series<CommonType<Uint16, R["type"]>>

sin

  • Compute the trigonometric sine for each value in this Series.

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

    Series.new([0, 45, 1]).sin(); // [0, 0.8509035245341184, 0.8414709848078965]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

sinh

  • Compute the hyperbolic sine for each value in this Series.

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

    Series.new([0, 45, 1]).sinh(); // [0, 17467135528742547000, 1.1752011936438014]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

skew

  • skew(skipNulls?: boolean): number

  • Return unbiased Fisher-Pearson skew of a sample.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 2, 3, 4, 5, 6, 6]);

    a.skew() // -0.288195490292614

    Parameters

    • skipNulls: boolean = true

      Exclude NA/null values. If an entire row/column is NA, the result will be NA.

    Returns number

    The unbiased skew of all the values in this Series.

sortValues

  • sortValues(ascending?: boolean, null_order?: "after" | "before", memoryResource?: MemoryResource): Uint16Series

  • Generate a new Series that is sorted in a specified way.

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

    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

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    Sorted values

sqrt

  • Compute the square-root (x^0.5) for each value in this Series.

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

    Series.new([-1.2, 2.5, 4]).sqrt(); // [NaN, 1.5811388300841898, 2]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

std

  • std(skipNulls?: boolean, ddof?: number, memoryResource?: MemoryResource): number

  • Return sample standard deviation of the Series. Normalized by N-1 by default. This can be changed using the ddof argument

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

    const a = Series.new([1, 2, 3, 4, 5]);

    //skipNulls=true, ddof=1
    a.std() // 1.5811388300841898
    a.std(true, 2) // 1.8257418583505534
    a.std(true, 5) // NaN, ddof>=a.length results in NaN

    Parameters

    • skipNulls: boolean = true

      Exclude NA/null values. If an entire row/column is NA, the result will be NA.

    • ddof: number = 1

      Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.

    • Optional memoryResource: MemoryResource

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

    Returns number

    The standard deviation of all the values in this Series.

sub

sum

  • sum(skipNulls?: boolean, memoryResource?: MemoryResource): bigint

sumOfSquares

  • sumOfSquares(skipNulls?: boolean, memoryResource?: MemoryResource): bigint

tail

  • Returns the last n rows.

    example
    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

    Parameters

    • n: number = 5

      The number of rows to return.

    Returns Uint16Series

tan

  • Compute the trigonometric tangent for each value in this Series.

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

    Series.new([0, 45, 1]).tan(); // [0, 1.6197751905438615, 1.557407724654902]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

tanh

  • Compute the hyperbolic tangent for each value in this Series.

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

    Series.new([0, 45, 1]).tanh(); // [0, 1, 0.7615941559557649]

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    A Series of the same number of elements containing the result of the operation.

toArray

  • toArray(): Uint16Array

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

    Returns Uint16Array

toArrow

toHexString

  • Returns a new string Series converting integer columns to hexadecimal characters.

    Any null entries will result in corresponding null entries in the output series.

    The output character set is '0'-'9' and 'A'-'F'. The output string width will be a multiple of 2 depending on the size of the integer type. A single leading zero is applied to the first non-zero output byte if it less than 0x10.

    Leading zeros are suppressed unless filling out a complete byte as in 1234 -> 04D2 instead of 000004D2 or 4D2.

    Parameters

    • Optional memoryResource: MemoryResource

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

    Returns StringSeries

toString

  • toString(options?: DisplayOptions & { name?: string }): string

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

    Parameters

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

    Returns string

trueDiv

  • True-divide this Series and another Series or scalar value.

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([10, 12, 14, 20]);
    const b = Series.new([3, 2, 1, 3]);

    a.trueDiv(3); // [3.3333333333333335, 4, 4.666666666666667, 6.666666666666667]
    a.trueDiv(b); // [3.3333333333333335, 6, 14, 6.666666666666667]

    Parameters

    • rhs: bigint

      The other Series or scalar to true-divide this Series by.

    • Optional memoryResource: MemoryResource

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

    Returns Int64Series

    A Series of a common numeric type with the results of the binary operation.

  • Parameters

    • rhs: number
    • Optional memoryResource: MemoryResource

    Returns Float64Series

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

  • Type parameters

    Parameters

    • rhs: R
    • Optional memoryResource: MemoryResource

    Returns Series<CommonType<Uint16, R["type"]>>

unique

  • unique(nullsEqual?: boolean, memoryResource?: MemoryResource): Uint16Series

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

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

    Parameters

    • nullsEqual: boolean = true

      Determines whether nulls are handled as equal values.

    • Optional memoryResource: MemoryResource

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

    Returns Uint16Series

    series without duplicate values

valueCounts

  • 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: Uint16Series }

    object with keys "value" and "count"

var

  • var(skipNulls?: boolean, ddof?: number, memoryResource?: MemoryResource): number

  • Return unbiased variance of the Series. Normalized by N-1 by default. This can be changed using the ddof argument

    example
    import {Series} from '@rapidsai/cudf';
    const a = Series.new([1, 2, 3, 4, 5, null]);

    a.var() // 2.5
    a.var(true, 2) // 3.333333333333332
    a.var(true, 5) // NaN, ddof>=a.length results in NaN

    Parameters

    • skipNulls: boolean = true

      Exclude NA/null values. If an entire row/column is NA, the result will be NA.

    • ddof: number = 1

      Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.

    • Optional memoryResource: MemoryResource

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

    Returns number

    The unbiased variance of all the values in this Series.

view

  • view<R>(dataType: R): Series<R>

  • View the data underlying this Series as a new dtype (similar to reinterpret_cast in C++).

    note

    The length of this Series must divide evenly into the size of the desired data type.

    note

    Series with nulls may only be viewed as dtypes of the same element width.

    Type parameters

    Parameters

    • dataType: R

    Returns Series<R>

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

Static new

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

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

    Type parameters

    • T: Vector<any, T>

    Parameters

    • input: T

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

  • Create a new cudf.Series from SeriesProps or a cudf.Column

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

    Type parameters

    Parameters

    • input: T

    Returns T

  • Type parameters

    Parameters

    Returns Series<T>

  • Type parameters

    Parameters

    Returns Series<T>

  • Create a new cudf.Int8Series

    example
    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]));

    Parameters

    Returns Int8Series

  • Create a new cudf.Int16Series

    example
    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]));

    Parameters

    Returns Int16Series

  • Create a new cudf.Int32Series

    example
    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]));

    Parameters

    Returns Int32Series

  • Create a new cudf.Uint8Series

    example
    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]));

    Parameters

    Returns Uint8Series

  • Create a new cudf.Uint16Series

    example
    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]));

    Parameters

    Returns Uint16Series

  • Create a new cudf.Uint32Series

    example
    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]));

    Parameters

    Returns Uint32Series

  • Create a new cudf.Uint64Series

    example
    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]));

    Parameters

    Returns Uint64Series

  • Create a new cudf.Float32Series

    example
    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]));

    Parameters

    Returns Float32Series

  • Create a new cudf.StringSeries

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

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

    Parameters

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

    Returns StringSeries

  • Create a new cudf.Float64Series

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

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

    Parameters

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

    Returns Float64Series

  • Create a new cudf.Int64Series

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

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

    Parameters

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

    Returns Int64Series

  • Create a new cudf.Bool8Series

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

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

    Parameters

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

    Returns Bool8Series

  • Create a new cudf.TimestampMillisecondSeries

    example
    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]);

    Parameters

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

    Returns TimestampMillisecondSeries

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

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

    Parameters

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

    Returns ListSeries<Utf8String>

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

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

    Parameters

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

    Returns ListSeries<Float64>

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

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

    Parameters

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

    Returns ListSeries<Int64>

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

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

    Parameters

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

    Returns ListSeries<Bool8>

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

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

    Parameters

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

    Returns ListSeries<TimestampMillisecond>

  • Type parameters

    • T: readonly unknown[]

    Parameters

    • input: T

    Returns Series<ArrowToCUDFType<JavaScriptArrayDataType<T>>>

  • Type parameters

    Parameters

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

    Returns Series<T>

Static readText

  • Constructs a Series from a text file path.

    note

    If delimiter is omitted, the default is ''.

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

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

    Parameters

    • filepath: string

      Path of the input file.

    • delimiter: string

      Optional delimiter.

    Returns StringSeries

    StringSeries from the file, split by delimiter.

Static sequence

  • sequence<U>(opts: { init?: U["scalarType"]; memoryResource?: MemoryResource; size: number; step?: U["scalarType"]; type?: U }): Series<U>

  • Constructs a Series with a sequence of values.

    note

    If init is omitted, the default is 0.

    note

    If step is omitted, the default is 1.

    note

    If type is omitted, the default is Int32.

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

    Series.sequence({size: 5}).toArray() // Int32Array[0, 1, 2, 3, 4]
    Series.sequence({size: 5, init: 5}).toArray() // Int32Array[5, 6, 7, 8, 9]
    Series
      .sequence({ size: 5, init: 0, type: new Int64 })
      .toArray() // BigInt64Array[0n, 1n, 2n, 3n, 4n]
    Series
      .sequence({ size: 5, step: 2, init: 1, type: new Float32 })
      .toArray() // Float32Array[1, 3, 5, 7, 9]

    Type parameters

    Parameters

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

      Options for creating the sequence

      • Optional init?: U["scalarType"]
      • Optional memoryResource?: MemoryResource
      • size: number
      • Optional step?: U["scalarType"]
      • Optional type?: U

    Returns Series<U>

    Series with the sequence