Class ListSeries<T>

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

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

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

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

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

Explicitly free the device memory associated with this Series.

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]

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]

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]

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]

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]

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

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]

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

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]

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]

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

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

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]

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]

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]

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]

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]

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]

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

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

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

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]

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

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]