Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface IIndex<IndexT>

Interface that represents an index for a Series.

Type parameters

  • IndexT

Hierarchy

Implemented by

Index

Methods

Methods

__@iterator

  • __@iterator(): Iterator<IndexT>

  • Get an iterator to enumerate the values of the series. Enumerating the iterator forces lazy evaluation to complete. This function is automatically called by for...of.

    example
    
for (const value of series) {
    // ... do something with the value ...
}

    Returns Iterator<IndexT>

    An iterator for the values in the series.

after

  • after(indexValue: number): ISeries<number, IndexT>

  • Gets a new series containing all values after the specified index value (exclusive).

    example
    
const series = new Series({
     index: [0, 1, 2, 3], // This is the default index.
     values: [10, 20, 30, 40],
});

const lastHalf = df.before(1);
expect(lastHalf.toArray()).to.eql([30, 40]);
    example
    
const timeSerie = ... a series indexed by date/time ...

// Get all values after the specified date.
const result = timeSeries.after(new Date(2016, 5, 4));

    Parameters

    • indexValue: number

      The index value after which to start the new series.

    Returns ISeries<number, IndexT>

    Returns a new series containing all values after the specified index value.

aggregate

  • Reduces the values in the series to a single result.

    aggregate is similar to Series.reduce, but the parameters are reversed. Please use Series.reduce in preference to aggregate.

    example
    
const dailySales = ... daily sales figures for the past month ...
const totalSalesForthisMonth = dailySales.aggregate(
     0, // Seed - the starting value.
     (accumulator, salesAmount) => accumulator + salesAmount // Aggregation function.
);
    example
    
const previousSales = 500; // We'll seed the aggregation with this value.
const dailySales = ... daily sales figures for the past month ...
const updatedSales = dailySales.aggregate(
     previousSales,
     (accumulator, salesAmount) => accumulator + salesAmount
);
    example
    
var salesDataSummary = salesData.aggregate({
     TotalSales: series => series.count(),
     AveragePrice: series => series.average(),
     TotalRevenue: series => series.sum(),
});

    Type parameters

    • ToT

    Parameters

    Returns ToT

    Returns a new value that has been reduced from the input series by passing it through the 'reducer' function.

all

  • Evaluates a predicate function for every value in the series to determine if some condition is true/truthy for all values in the series.

    example
    
const result = series.all(salesFigure => salesFigure > 100); // Returns true if all sales figures are greater than 100.

    Parameters

    • predicate: PredicateFn<IndexT>

      Predicate function that receives each value. It should returns true/truthy for a match, otherwise false/falsy.

    Returns boolean

    Returns true if the predicate has returned true or truthy for every value in the series, otherwise returns false. Returns false for an empty series.

amountChange

  • amountChange(period?: undefined | number, whichIndex?: WhichIndex): ISeries<number, number>

  • Compute the amount of change between pairs or sets of values in the series.

    example
    
const saleFigures = ... running series of daily sales figures ...
const amountChanged = salesFigures.amountChanged(); // Amount that sales has changed, day to day.
    example
    
const saleFigures = ... running series of daily sales figures ...
const amountChanged = salesFigures.amountChanged(7); // Amount that sales has changed, week to week.

    Parameters

    • Optional period: undefined | number

      Optional period for computing the change - defaults to 2.

    • Optional whichIndex: WhichIndex

      Sets which side of the window the index comes from: start or end. Can be "start" or "end", defaults to "end".

    Returns ISeries<number, number>

    Returns a new series where each value indicates the amount of change from the previous number value in the original series.

amountRange

  • Compute the absolute range of values in each period. The range for each period is the absolute difference between largest (max) and smallest (min) values in that period.

    example
    
const closingPrice = ... series of closing prices for a particular stock ...
const volatility = closingPrice.amountRange(5);

    Parameters

    • period: number

      Period for computing the range.

    • Optional whichIndex: WhichIndex

      Sets which side of the window the index comes from: start or end. Can be "start" or "end", defaults to "end".

    Returns ISeries<number, number>

    Returns a new series where each value indicates the absolute range of values for each period in the original series.

any

  • Evaluates a predicate function for every value in the series to determine if some condition is true/truthy for any of values in the series.

    If no predicate is specified then it simply checks if the series contains more than zero values.

    example
    
const result = series.any(salesFigure => salesFigure > 100); // Do we have any sales figures greater than 100?
    example
    
const result = series.any(); // Do we have any sales figures at all?

    Parameters

    • Optional predicate: PredicateFn<IndexT>

      Optional predicate function that receives each value. It should return true/truthy for a match, otherwise false/falsy.

    Returns boolean

    Returns true if the predicate has returned truthy for any value in the series, otherwise returns false. If no predicate is passed it returns true if the series contains any values at all. Returns false for an empty series.

appendPair

  • appendPair(pair: [number, IndexT]): ISeries<number, IndexT>

  • Append a pair to the end of a series. Doesn't modify the original series! The returned series is entirely new and contains values from the original series plus the appended pair.

    example
    
const newIndex = ... index of the new row ...
const newRow = ... the new data row to append ...
const appendedSeries = series.appendPair([newIndex, newRows]);

    Parameters

    • pair: [number, IndexT]

      The index/value pair to append.

    Returns ISeries<number, IndexT>

    Returns a new series with the specified pair appended.

at

  • at(index: number): IndexT | undefined

  • Get the value, if there is one, with the specified index.

    example
    
const value = series.at(5); // Get the value at index 5 (with a default 0-based index).
    example
    
const date = ... some date ...
// Retreive the value with specified date from a time-series (assuming date indexed has been applied).
const value = series.at(date);

    Parameters

    • index: number

      Index to for which to retreive the value.

    Returns IndexT | undefined

    Returns the value from the specified index in the series or undefined if there is no such index in the present in the series.

average

  • average(): number

  • Average the values in a series and returns the result.

    average is an alias of Series.mean.

    example
    
const averageSales = salesFigures.average();

    Returns number

    Returns the average of the number values in the series.

bake

  • Forces lazy evaluation to complete and 'bakes' the series into memory.

    example
    
const baked = series.bake();

    Returns ISeries<number, IndexT>

    Returns a series that has been 'baked', all lazy evaluation has completed.

before

  • before(indexValue: number): ISeries<number, IndexT>

  • Gets a new series containing all values up to the specified index value (exclusive).

    example
    
const series = new Series({
     index: [0, 1, 2, 3], // This is the default index.
     values: [10, 20, 30, 40],
});

const firstHalf = series.before(2);
expect(firstHalf.toArray()).to.eql([10, 20]);
    example
    
const timeSeries = ... a series indexed by date/time ...

// Get all values before the specified date.
const result = timeSeries.before(new Date(2016, 5, 4));

    Parameters

    • indexValue: number

      The index value at which to end the new series.

    Returns ISeries<number, IndexT>

    Returns a new series containing all values up to (but not including) the specified index value.

between

  • between(startIndexValue: number, endIndexValue: number): ISeries<number, IndexT>

  • Gets a new series containing all values between the specified index values (inclusive).

    example
    
const series = new Series({
     index: [0, 1, 2, 3, 4, 6], // This is the default index.
     values: [10, 20, 30, 40, 50, 60],
});

const middleSection = series.between(1, 4);
expect(middleSection.toArray()).to.eql([20, 30, 40, 50]);
    example
    
const timeSeries = ... a series indexed by date/time ...

// Get all values between the start and end dates (inclusive).
const result = timeSeries.after(new Date(2016, 5, 4), new Date(2016, 5, 22));

    Parameters

    • startIndexValue: number

      The index at which to start the new series.

    • endIndexValue: number

      The index at which to end the new series.

    Returns ISeries<number, IndexT>

    Returns a new series containing all values between the specified index values (inclusive).

bucket

  • Organise all values in the series into the specified number of buckets. Assumes that the series is a series of numbers.

    WARNING: This function is deprecated and will be removed in the future.

    example
    
const buckets = series.bucket(20); // Distribute values into 20 evenly spaced buckets.
console.log(buckets.toString());

    Parameters

    • numBuckets: number

      The number of buckets to create.

    Returns IDataFrame<number, IBucket>

    Returns a dataframe containing bucketed values. The input values are divided up into these buckets.

cast

  • cast<NewValueT>(): ISeries<number, NewValueT>

  • Cast the value of the series to a new type. This operation has no effect but to retype the values that the series contains.

    example
    
const castSeries = series.cast();

    Type parameters

    • NewValueT

    Returns ISeries<number, NewValueT>

    The same series, but with the type changed.

concat

  • Concatenate multiple other series onto this series.

    example
    
const concatenated = a.concat(b);
    example
    
const concatenated = a.concat(b, c);
    example
    
const concatenated = a.concat([b, c]);
    example
    
const concatenated = a.concat(b, [c, d]);
    example
    
const otherSeries = [... array of series...];
const concatenated = a.concat(otherSeries);

    Parameters

    • Rest ...series: (ISeries<IndexT, ValueT> | ISeries<IndexT, ValueT>[])[]

      Multiple arguments. Each can be either a series or an array of series.

    Returns ISeries<number, IndexT>

    Returns a single series concatenated from multiple input series.

count

  • count(): number

  • Count the number of values in the seriese

    example
    
const numValues = series.count();

    Returns number

    Returns the count of all values.

counter

  • Counts the number of sequential values where the predicate evaluates to truthy. Outputs 0 for values when the predicate evaluates to falsy.

    example
    
const series = new Series([ 1, 10, 3, 15, 8, 5 ]);
const counted = series.counter(value => value >= 3);
console.log(counted.toString());

    Parameters

    • predicate: PredicateFn<IndexT>

      User-defined function. Should evaluate to truthy to activate the counter or falsy to deactivate it.

    Returns ISeries<number, number>

    Returns a new series that counts up the number of sequential values where the predicate evaluates to truthy. 0 values appear when the prediate evaluates to falsy.

cumsum

  • cumsum(): ISeries<number, number>

  • Generates a cumulative sum across a series.

    Returns ISeries<number, number>

    Returns a new series that is the cumulative sum of values across the input series.

defaultIfEmpty

  • defaultIfEmpty(defaultSequence: IndexT[] | ISeries<number, IndexT>): ISeries<number, IndexT>

  • Returns the specified default series if the input series is empty.

    example
    
const emptySeries = new Series();
const defaultSeries = new Series([ 1, 2, 3 ]);
expect(emptyDataFrame.defaultIfEmpty(defaultSeries)).to.eql(defaultSeries);
    example
    
const nonEmptySeries = new Series([ 100 ]);
const defaultSeries = new Series([ 1, 2, 3 ]);
expect(nonEmptySeries.defaultIfEmpty(defaultSeries)).to.eql(nonEmptySeries);

    Parameters

    • defaultSequence: IndexT[] | ISeries<number, IndexT>

      Default series to return if the input series is empty.

    Returns ISeries<number, IndexT>

    Returns 'defaultSequence' if the input series is empty.

detectTypes

  • detectTypes(): IDataFrame<number, ITypeFrequency>

  • Detect the the frequency of the types of the values in the series. This is a good way to understand the shape of your data.

    example
    
const dataTypes = series.detectTypes();
console.log(dataTypes.toString());

    Returns IDataFrame<number, ITypeFrequency>

    Returns a DataFrame with rows that confirm to ITypeFrequency that describes the data types contained in the original series.

detectValues

  • detectValues(): IDataFrame<number, IValueFrequency>

  • Detect the frequency of the values in the series. This is a good way to understand the shape of your data.

    example
    
const dataValues = series.detectValues();
console.log(dataValues.toString());

    Returns IDataFrame<number, IValueFrequency>

    Returns a DataFrame with rows that conform to IValueFrequency that describes the values contained in the original series.

distinct

  • Returns only the set of values in the series that are distinct. Provide a user-defined t (tor to specify criteria for determining the distinctness. This can be used to remove duplicate values from the series.

    example
    
const uniqueValues = series.distinct(); // Get only non-duplicated value in the series.
    example
    
const bucketedValues = series.distinct(value => Math.floor(value / 10)); // Lump values into buckets of 10.

    Type parameters

    • ToT

    Parameters

    • Optional selector: SelectorFn<IndexT, ToT>

      Optional user-defined selector function that specifies the criteria used to make comparisons for duplicate values.

    Returns ISeries<number, IndexT>

    Returns a series containing only unique values in the series.

endAt

  • endAt(indexValue: number): ISeries<number, IndexT>

  • Gets a new series containing all values up until and including the specified index value (inclusive).

    example
    
const series = new Series({
     index: [0, 1, 2, 3], // This is the default index.
     values: [10, 20, 30, 40],
});

const firstHalf = series.endAt(1);
expect(firstHalf.toArray()).to.eql([10, 20]);
    example
    
const timeSeries = ... a series indexed by date/time ...

// Get all values ending at a particular date.
const result = timeSeries.endAt(new Date(2016, 5, 4));

    Parameters

    • indexValue: number

      The index value at which to end the new series.

    Returns ISeries<number, IndexT>

    Returns a new series containing all values up until and including the specified index value.

except

  • except<InnerIndexT, InnerValueT, KeyT>(inner: ISeries<InnerIndexT, InnerValueT>, outerSelector?: SelectorFn<IndexT, KeyT>, innerSelector?: SelectorFn<InnerValueT, KeyT>): ISeries<number, IndexT>

  • Creates a new series by merging two input series. The resulting series contains only the values from the 1st series that don't appear in the 2nd series. This is essentially subtracting the values from the 2nd series from the 1st and creating a new series with the remaining values.

    example
    
const seriesA = ...
const seriesB = ...
const remainingDf = seriesA.except(seriesB);
    example
    
// Find the list of customers haven't bought anything recently.
const allCustomers = ... list of all customers ...
const recentCustomers = ... list of customers who have purchased recently ...
const remainingCustomers = allCustomers.except(
     recentCustomers,
     customerRecord => customerRecord.CustomerId
);

    Type parameters

    • InnerIndexT

    • InnerValueT

    • KeyT

    Parameters

    • inner: ISeries<InnerIndexT, InnerValueT>

      The inner series to merge (the series you call the function on is the 'outer' series).

    • Optional outerSelector: SelectorFn<IndexT, KeyT>

      Optional user-defined selector function that selects the key from the outer series that is used to match the two series.

    • Optional innerSelector: SelectorFn<InnerValueT, KeyT>

      Optional user-defined selector function that selects the key from the inner series that is used to match the two series.

    Returns ISeries<number, IndexT>

    Returns a new series that contains only the values from the 1st series that don't appear in the 2nd series.

fillGaps

  • fillGaps(comparer: ComparerFn<[number, IndexT], [number, IndexT]>, generator: GapFillFn<[number, IndexT], [number, IndexT]>): ISeries<number, IndexT>

  • Fill gaps in a series.

    example
    
  var sequenceWithGaps = ...

 // Predicate that determines if there is a gap.
 var gapExists = (pairA, pairB) => {
     // Returns true if there is a gap.
     return true;
 };

 // Generator function that produces new rows to fill the game.
 var gapFiller = (pairA, pairB) => {
     // Create an array of index, value pairs that fill the gaps between pairA and pairB.
     return [
         newPair1,
         newPair2,
         newPair3,
     ];
 };

 var sequenceWithoutGaps = sequenceWithGaps.fillGaps(gapExists, gapFiller);

    Parameters

    • comparer: ComparerFn<[number, IndexT], [number, IndexT]>

      User-defined comparer function that is passed pairA and pairB, two consecutive values, return truthy if there is a gap between the value, or falsey if there is no gap.

    • generator: GapFillFn<[number, IndexT], [number, IndexT]>

      User-defined generator function that is passed pairA and pairB, two consecutive values, returns an array of pairs that fills the gap between the values.

    Returns ISeries<number, IndexT>

    Returns a new series with gaps filled in.

filter

  • Filter the series through a user-defined predicate function.

    This is the same concept as the JavaScript function Array.filter but filters a data series rather than an array.

    example
    
// Filter so we only have sales figures greater than 100.
const filtered = series.filter(salesFigure => salesFigure > 100);
console.log(filtered.toArray());

    Parameters

    • predicate: PredicateFn<IndexT>

      Predicate function to filter values from the series. Returns true/truthy to keep elements, or false/falsy to omit elements.

    Returns ISeries<number, IndexT>

    Returns a new series containing only the values from the original series that matched the predicate.

first

  • first(): IndexT

  • Get the first value of the series.

    example
    
const firstValue = series.first();

    Returns IndexT

    Returns the first value of the series.

flatMap

  • Transforms and flattens an input series, generating a new series. The transformer function is called for each value in the input series and produces an array that is then flattened into the generated series.

    This is the same concept as the JavaScript function Array.flatMap but maps over a data series rather than an array.

    example
    
function transformer (input) {
     const output = [];
     while (someCondition) {
         // ... generate zero or more outputs from a single input ...
         output.push(... some generated value ...);
     }
     return output;
}

const transformed = series.flatMap(transformer);
console.log(transformed.toString());

    Type parameters

    • ToT

    Parameters

    • transformer: SelectorWithIndexFn<IndexT, Iterable<ToT>>

      A user-defined function that transforms each value into an array that is then flattened into the generated series.

    Returns ISeries<number, ToT>

    Returns a new series generated by calling the transformer function over each element of the input.

forEach

  • Invoke a callback function for each value in the series.

    example
    
series.forEach(value => {
     // ... do something with the value ...
});

    Parameters

    • callback: CallbackFn<IndexT>

      The calback function to invoke for each value.

    Returns ISeries<number, IndexT>

    Returns the original series with no modifications.

frequency

  • Counts frequencies in the series to produce a frequency table.

    example
    
const series = new Series([ 1, 2, 3, 4 ]);
// Or
const series = dataFrame.getSeries("SomeColumn");

const frequencyTable = series.frequency();
console.log(frequencyTable.toArray());
    example
    
const series = new Series([ 37, 63, 56, 54, 39, 49, 55, 114, 59, 55 ]);
const frequencyTable = series.frequency({
     lower: 40,
     upper: 90,
     interval: 10,
})
console.log(frequencyTable.toArray());

    Parameters

    • Optional options: IFrequencyTableOptions

      Options for computing the frequency table (e.g. numGroups which defaults to 10).

    Returns IDataFrame<number, IFrequencyTableEntry>

    Returns a dataframe for the frequency table showing the frequency for the band of values in each group.

getGreaterThan

  • Get the greater than operation for the index.

    Returns PredicateFn

    Returns a function that can be used to compare a value against an index value.

getIndex

  • Get the index for the series.

    example
    
const index = series.getIndex();

    Returns IIndex<number>

    The Index for the series.

getLessThan

  • Get the less than operation for the index.

    Returns PredicateFn

    Returns a function that can be used to compare a value against an index value.

getLessThanOrEqualTo

  • Get the less than or equal to operation for the index.

    Returns PredicateFn

    Returns a function that can be used to compare a value against an index value.

getType

  • getType(): string

  • Get the type of the index.

    Returns string

    Returns a string that specifies the type of the index.

groupBy

  • Collects values in the series into a new series of groups according to a user-defined selector function.

    example
    
const sales = ... product sales ...
const salesByProduct = sales.groupBy(sale => sale.ProductId);
for (const productSalesGroup of salesByProduct) {
     // ... do something with each product group ...
     const productId = productSalesGroup.first().ProductId;
     const totalSalesForProduct = productSalesGroup.deflate(sale => sale.Amount).sum();
     console.log(totalSalesForProduct);
}

    Type parameters

    • GroupT

    Parameters

    • selector: SelectorFn<IndexT, GroupT>

      User-defined selector function that specifies the criteriay to group by.

    Returns ISeries<number, ISeries<number, IndexT>>

    Returns a new series of groups. Each group is a series with values that have been grouped by the 'selector' function.

groupSequentialBy

  • Collects values in the series into a new series of groups based on if the values are the same or according to a user-defined selector function.

    example
    
// Some ultra simple stock trading strategy backtesting...
const dailyStockPrice = ... daily stock price for a company ...
const priceGroups  = dailyStockPrice.groupBy(day => day.close > day.movingAverage);
for (const priceGroup of priceGroups) {
     // ... do something with each stock price group ...

     const firstDay = priceGroup.first();
     if (firstDay.close > movingAverage) {
         // This group of days has the stock price above its moving average.
         // ... maybe enter a long trade here ...
     }
     else {
         // This group of days has the stock price below its moving average.
         // ... maybe enter a short trade here ...
     }
}

    Type parameters

    • GroupT

    Parameters

    • Optional selector: SelectorFn<IndexT, GroupT>

      Optional selector that specifies the criteria for grouping.

    Returns ISeries<number, ISeries<number, IndexT>>

    Returns a new series of groups. Each group is a series with values that are the same or have been grouped by the 'selector' function.

head

  • head(numValues: number): ISeries<number, IndexT>

  • Get X value from the start of the series. Pass in a negative value to get all values at the head except for X values at the tail.

    examples
    
const sample = series.head(10); // Take a sample of 10 values from the start of the series.

    Parameters

    • numValues: number

      Number of values to take.

    Returns ISeries<number, IndexT>

    Returns a new series that has only the specified number of values taken from the start of the original series.

inflate

  • Converts (inflates) a series to a DataFrame.

    example
    
const dataframe = series.inflate(); // Inflate a series of objects to a dataframe.
    example
    
const dataframe = series.inflate(value => { AColumn:  value }); // Produces a dataframe with 1 column from a series of values.
    example
    
const dataframe = series.inflate(value => { AColumn:  value.NestedValue }); // Extract a nested value and produce a dataframe from it.

    Type parameters

    • ToT

    Parameters

    • Optional selector: SelectorWithIndexFn<IndexT, ToT>

      Optional user-defined selector function that transforms each value to produce the dataframe.

    Returns IDataFrame<number, ToT>

    Returns a dataframe that was created from the original series.

insertPair

  • insertPair(pair: [number, IndexT]): ISeries<number, IndexT>

  • Insert a pair at the start of the series. Doesn't modify the original series! The returned series is entirely new and contains values from the original series plus the inserted pair.

    example
    
const newIndex = ... index of the new row ...
const newRow = ... the new data row to insert ...
const insertedSeries = series.insertPair([newIndex, newRows]);

    Parameters

    • pair: [number, IndexT]

      The index/value pair to insert.

    Returns ISeries<number, IndexT>

    Returns a new series with the specified pair inserted.

intersection

  • intersection<InnerIndexT, InnerValueT, KeyT>(inner: ISeries<InnerIndexT, InnerValueT>, outerSelector?: SelectorFn<IndexT, KeyT>, innerSelector?: SelectorFn<InnerValueT, KeyT>): ISeries<number, IndexT>

  • Creates a new series by merging two input series. The resulting series contains the intersection of values from the two input series. These are only the values that appear in both series.

    example
    
const seriesA = ...
const seriesB = ...
const mergedDf = seriesA.intersection(seriesB);
    example
    
// Merge two sets of customer records to find only the
// customers that appears in both.
const customerRecordsA = ...
const customerRecordsB = ...
const intersectionOfCustomerRecords = customerRecordsA.intersection(
     customerRecordsB,
     customerRecord => customerRecord.CustomerId
);

    Type parameters

    • InnerIndexT

    • InnerValueT

    • KeyT

    Parameters

    • inner: ISeries<InnerIndexT, InnerValueT>

      The inner series to merge (the series you call the function on is the 'outer' series).

    • Optional outerSelector: SelectorFn<IndexT, KeyT>

      Optional user-defined selector function that selects the key from the outer series that is used to match the two series.

    • Optional innerSelector: SelectorFn<InnerValueT, KeyT>

      Optional user-defined selector function that selects the key from the inner series that is used to match the two series.

    Returns ISeries<number, IndexT>

    Returns a new series that contains the intersection of values from the two input series.

invert

  • invert(): ISeries<number, number>

  • Invert the sign of every number value in the series. This assumes that the input series contains numbers.

    example
    
const inverted = series.invert();

    Returns ISeries<number, number>

    Returns a new series with all number values inverted.

join

  • join<KeyT, InnerIndexT, InnerValueT, ResultValueT>(inner: ISeries<InnerIndexT, InnerValueT>, outerKeySelector: SelectorFn<IndexT, KeyT>, innerKeySelector: SelectorFn<InnerValueT, KeyT>, resultSelector: JoinFn<IndexT, InnerValueT, ResultValueT>): ISeries<number, ResultValueT>

  • Creates a new series by merging two input series. The resulting dataframe contains only those value that have matching keys in both input series.

    example
    
// Join together two sets of customers to find those
// that have bought both product A and product B.
const customerWhoBoughtProductA = ...
const customerWhoBoughtProductB = ...
const customersWhoBoughtBothProductsDf = customerWhoBoughtProductA.join(
         customerWhoBoughtProductB,
         customerA => customerA.CustomerId, // Join key.
         customerB => customerB.CustomerId, // Join key.
         (customerA, customerB) => {
             return {
                 // ... merge the results ...
             };
         }
     );

    Type parameters

    • KeyT

    • InnerIndexT

    • InnerValueT

    • ResultValueT

    Parameters

    • inner: ISeries<InnerIndexT, InnerValueT>

      The 'inner' series to join (the series you are callling the function on is the 'outer' series).

    • outerKeySelector: SelectorFn<IndexT, KeyT>

      User-defined selector function that chooses the join key from the outer series.

    • innerKeySelector: SelectorFn<InnerValueT, KeyT>

      User-defined selector function that chooses the join key from the inner series.

    • resultSelector: JoinFn<IndexT, InnerValueT, ResultValueT>

      User-defined function that merges outer and inner values.

    Returns ISeries<number, ResultValueT>

    Returns the new merged series.

joinOuter

  • joinOuter<KeyT, InnerIndexT, InnerValueT, ResultValueT>(inner: ISeries<InnerIndexT, InnerValueT>, outerKeySelector: SelectorFn<IndexT, KeyT>, innerKeySelector: SelectorFn<InnerValueT, KeyT>, resultSelector: JoinFn<IndexT | null, InnerValueT | null, ResultValueT>): ISeries<number, ResultValueT>

  • Creates a new series by merging two input series. The resulting series contains only those values that are only present in one or the other of the series, not both.

    example
    
// Join together two sets of customers to find those
// that have bought either product A or product B, not not both.
const customerWhoBoughtProductA = ...
const customerWhoBoughtProductB = ...
const customersWhoBoughtEitherProductButNotBothDf = customerWhoBoughtProductA.joinOuter(
         customerWhoBoughtProductB,
         customerA => customerA.CustomerId, // Join key.
         customerB => customerB.CustomerId, // Join key.
         (customerA, customerB) => {
             return {
                 // ... merge the results ...
             };
         }
     );

    Type parameters

    • KeyT

    • InnerIndexT

    • InnerValueT

    • ResultValueT

    Parameters

    • inner: ISeries<InnerIndexT, InnerValueT>

      The 'inner' series to join (the series you are callling the function on is the 'outer' series).

    • outerKeySelector: SelectorFn<IndexT, KeyT>

      User-defined selector function that chooses the join key from the outer series.

    • innerKeySelector: SelectorFn<InnerValueT, KeyT>

      User-defined selector function that chooses the join key from the inner series.

    • resultSelector: JoinFn<IndexT | null, InnerValueT | null, ResultValueT>

      User-defined function that merges outer and inner values.

      Implementation from here:

      http://blogs.geniuscode.net/RyanDHatch/?p=116

    Returns ISeries<number, ResultValueT>

    Returns the new merged series.

joinOuterLeft

  • joinOuterLeft<KeyT, InnerIndexT, InnerValueT, ResultValueT>(inner: ISeries<InnerIndexT, InnerValueT>, outerKeySelector: SelectorFn<IndexT, KeyT>, innerKeySelector: SelectorFn<InnerValueT, KeyT>, resultSelector: JoinFn<IndexT | null, InnerValueT | null, ResultValueT>): ISeries<number, ResultValueT>

  • Creates a new series by merging two input series. The resulting series contains only those values that are present either in both series or only in the outer (left) series.

    example
    
// Join together two sets of customers to find those
// that have bought either just product A or both product A and product B.
const customerWhoBoughtProductA = ...
const customerWhoBoughtProductB = ...
const boughtJustAorAandB = customerWhoBoughtProductA.joinOuterLeft(
         customerWhoBoughtProductB,
         customerA => customerA.CustomerId, // Join key.
         customerB => customerB.CustomerId, // Join key.
         (customerA, customerB) => {
             return {
                 // ... merge the results ...
             };
         }
     );

    Type parameters

    • KeyT

    • InnerIndexT

    • InnerValueT

    • ResultValueT

    Parameters

    • inner: ISeries<InnerIndexT, InnerValueT>

      The 'inner' series to join (the series you are callling the function on is the 'outer' series).

    • outerKeySelector: SelectorFn<IndexT, KeyT>

      User-defined selector function that chooses the join key from the outer series.

    • innerKeySelector: SelectorFn<InnerValueT, KeyT>

      User-defined selector function that chooses the join key from the inner series.

    • resultSelector: JoinFn<IndexT | null, InnerValueT | null, ResultValueT>

      User-defined function that merges outer and inner values.

      Implementation from here:

      http://blogs.geniuscode.net/RyanDHatch/?p=116

    Returns ISeries<number, ResultValueT>

    Returns the new merged series.

joinOuterRight

  • joinOuterRight<KeyT, InnerIndexT, InnerValueT, ResultValueT>(inner: ISeries<InnerIndexT, InnerValueT>, outerKeySelector: SelectorFn<IndexT, KeyT>, innerKeySelector: SelectorFn<InnerValueT, KeyT>, resultSelector: JoinFn<IndexT | null, InnerValueT | null, ResultValueT>): ISeries<number, ResultValueT>

  • Creates a new series by merging two input series. The resulting series contains only those values that are present either in both series or only in the inner (right) series.

    example
    
// Join together two sets of customers to find those
// that have bought either just product B or both product A and product B.
const customerWhoBoughtProductA = ...
const customerWhoBoughtProductB = ...
const boughtJustAorAandB = customerWhoBoughtProductA.joinOuterRight(
         customerWhoBoughtProductB,
         customerA => customerA.CustomerId, // Join key.
         customerB => customerB.CustomerId, // Join key.
         (customerA, customerB) => {
             return {
                 // ... merge the results ...
             };
         }
     );

    Type parameters

    • KeyT

    • InnerIndexT

    • InnerValueT

    • ResultValueT

    Parameters

    • inner: ISeries<InnerIndexT, InnerValueT>

      The 'inner' series to join (the series you are callling the function on is the 'outer' series).

    • outerKeySelector: SelectorFn<IndexT, KeyT>

      User-defined selector function that chooses the join key from the outer series.

    • innerKeySelector: SelectorFn<InnerValueT, KeyT>

      User-defined selector function that chooses the join key from the inner series.

    • resultSelector: JoinFn<IndexT | null, InnerValueT | null, ResultValueT>

      User-defined function that merges outer and inner values.

      Implementation from here:

      http://blogs.geniuscode.net/RyanDHatch/?p=116

    Returns ISeries<number, ResultValueT>

    Returns the new merged series.

last

  • last(): IndexT

  • Get the last value of the series.

    example
    
const lastValue = series.last();

    Returns IndexT

    Returns the last value of the series.

map

  • Transforms an input series, generating a new series. The transformer function is called for each element of the input and the collection of outputs creates the generated series.

    This is the same concept as the JavaScript function Array.map but maps over a data series rather than an array.

    example
    
function transformer (input) {
     const output = // ... construct output from input ...
     return output;
}

const transformed = series.map(transformer);
console.log(transformed.toString());

    Type parameters

    • ToT

    Parameters

    • transformer: SelectorWithIndexFn<IndexT, ToT>

      A user-defined transformer function that transforms each element from the input to generate the output.

    Returns ISeries<number, ToT>

    Returns a new series generated by calling the transformer function over each element of the input.

max

  • max(): number

  • Get the max value in the series.

    example
    
const maxSales = salesFigures.max();

    Returns number

    Returns the maximum of the number values in the series.

mean

  • mean(): number

  • Computes and returns the mean value of a set of values.

    example
    
const averageSales = salesFigures.mean();

    Returns number

    Returns the mean of the number values in the series.

median

  • median(): number

  • Get the median value in the series. Note that this sorts the series, which can be expensive.

    example
    
const medianSales = salesFigures.median();

    Returns number

    Returns the median of the values in the series.

merge

  • merge<MergedValueT>(...args: any[]): ISeries<number, MergedValueT[]>

  • Merge one or more series into this series. Values are merged by index. Values at each index are combined into arrays in the resulting series.

    example
    
const mergedSeries = series1.merge(series2);

    
const mergedSeries = series1.merge(series2, series3, etc);

    Type parameters

    • MergedValueT

    Parameters

    • Rest ...args: any[]

    Returns ISeries<number, MergedValueT[]>

    The merged series.

min

  • min(): number

  • Get the min value in the series.

    example
    
const minSales = salesFigures.min();

    Returns number

    Returns the minimum of the number values in the series.

mode

  • mode(): any

  • Get the mode of the values in the series. The mode is the most frequent value in the series. Note that this reads the entire series into memory, which can be expensive.

    example
    
const modeSales = salesFigures.mode();

    Returns any

    Returns the mode of the values in the series.

none

  • Evaluates a predicate function for every value in the series to determine if some condition is true/truthy for none of values in the series.

    If no predicate is specified then it simply checks if the series contains zero values.

    example
    
const result = series.none(salesFigure => salesFigure > 100); // Do we have zero sales figures greater than 100?
    example
    
const result = series.none(); // Do we have zero sales figures?

    Parameters

    • Optional predicate: PredicateFn<IndexT>

      Optional predicate function that receives each value. It should return true/truthy for a match, otherwise false/falsy.

    Returns boolean

    Returns true if the predicate has returned truthy for zero values in the series, otherwise returns false. Returns false for an empty series.

orderBy

  • Sorts the series in ascending order by a value defined by the user-defined selector function.

    example
    
const orderedSeries = series.orderBy(value => value);
    example
    
const orderedSeries = series.orderBy(value => value.NestedValue);

    Type parameters

    • SortT

    Parameters

    • selector: SelectorWithIndexFn<IndexT, SortT>

      User-defined selector function that selects the value to sort by.

    Returns IOrderedSeries<number, IndexT, SortT>

    Returns a new series that has been ordered accorrding to the value chosen by the selector function.

orderByDescending

  • Sorts the series in descending order by a value defined by the user-defined selector function.

    example
    
const orderedSeries = series.orderByDescending(value => value);
    example
    
const orderedSeries = series.orderByDescending(value => value.NestedValue);

    Type parameters

    • SortT

    Parameters

    • selector: SelectorWithIndexFn<IndexT, SortT>

      User-defined selector function that selects the value to sort by.

    Returns IOrderedSeries<number, IndexT, SortT>

    Returns a new series that has been ordered accorrding to the value chosen by the selector function.

parseDates

  • parseDates(formatString?: undefined | string): ISeries<number, Date>

  • Parse a series with string values and convert it to a series with date values.

    example
    
const parsed = series.parseDates();

    Parameters

    • Optional formatString: undefined | string

      Optional formatting string for dates.

      Moment is used for date parsing. https://momentjs.com

    Returns ISeries<number, Date>

    Returns a new series with values parsed from strings to dates.

parseFloats

  • parseFloats(): ISeries<number, number>

  • Parse a series with string values and convert it to a series with float values.

    example
    
const parsed = series.parseFloats();

    Returns ISeries<number, number>

    Returns a new series with values parsed from strings to floats.

parseInts

  • parseInts(): ISeries<number, number>

  • Parse a series with string values and convert it to a series with int values.

    example
    
const parsed = series.parseInts();

    Returns ISeries<number, number>

    Returns a new series with values parsed from strings to ints.

percentChange

  • percentChange(period?: undefined | number, whichIndex?: WhichIndex): ISeries<number, number>

  • Compute the percentage change between pairs or sets of values in the series. Percentages are expressed as 0-100 values.

    example
    
const saleFigures = ... running series of daily sales figures ...
const percentChanged = salesFigures.amountChanged(); // Percent that sales has changed, day to day.
    example
    
const saleFigures = ... running series of daily sales figures ...
const percentChanged = salesFigures.amountChanged(7); // Percent that sales has changed, week to week.

    Parameters

    • Optional period: undefined | number

      Optional period for computing the percentage - defaults to 2.

    • Optional whichIndex: WhichIndex

      Sets which side of the window the index comes from: start or end. Can be "start" or "end", defaults to "end".

    Returns ISeries<number, number>

    Returns a new series where each value indicates the percent change from the previous number value in the original series.

percentRange

  • Compute the range of values in each period in proportion to the latest value. The range for each period is the absolute difference between largest (max) and smallest (min) values in that period. Proportions are expressed as 0-1 values.

    example
    
const closingPrice = ... series of closing prices for a particular stock ...
const percentVolatility = closingPrice.percentRange(5);

    Parameters

    • period: number

      Period for computing the range.

    • Optional whichIndex: WhichIndex

      Sets which side of the window the index comes from: start or end. Can be "start" or "end", defaults to "end".

    Returns ISeries<number, number>

    Returns a new series where each value indicates the proportion change from the previous number value in the original series.

percentRank

  • percentRank(period?: undefined | number): ISeries<number, number>

  • For each period, compute the percent of values that are less than the last value in the period. Percent are expressed as 0-100 values.

    example
    
const percentRank = series.percentRank();
    example
    
const percentRank = series.percentRank(100);

    Parameters

    • Optional period: undefined | number

      Optional period for computing the percent rank - defaults to 2.

    Returns ISeries<number, number>

    Returns a new series where each value indicates the percent rank value for that period.

proportionChange

  • proportionChange(period?: undefined | number, whichIndex?: WhichIndex): ISeries<number, number>

  • Compute the proportion change between pairs or sets of values in the series. Proportions are expressed as 0-1 values.

    example
    
const saleFigures = ... running series of daily sales figures ...
const proportionChanged = salesFigures.amountChanged(); // Proportion that sales has changed, day to day.
    example
    
const saleFigures = ... running series of daily sales figures ...
const proportionChanged = salesFigures.amountChanged(7); // Proportion that sales has changed, week to week.

    Parameters

    • Optional period: undefined | number

      Optional period for computing the proportion - defaults to 2.

    • Optional whichIndex: WhichIndex

      Sets which side of the window the index comes from: start or end. Can be "start" or "end", defaults to "end".

    Returns ISeries<number, number>

    Returns a new series where each value indicates the proportion change from the previous number value in the original series.

proportionRange

  • Compute the range of values in each period in proportion to the latest value. The range for each period is the absolute difference between largest (max) and smallest (min) values in that period. Proportions are expressed as 0-1 values.

    example
    
const closingPrice = ... series of closing prices for a particular stock ...
const proportionVolatility = closingPrice.proportionRange(5);

    Parameters

    • period: number

      Period for computing the range.

    • Optional whichIndex: WhichIndex

      Sets which side of the window the index comes from: start or end. Can be "start" or "end", defaults to "end".

    Returns ISeries<number, number>

    Returns a new series where each value indicates the proportion change from the previous number value in the original series.

proportionRank

  • proportionRank(period?: undefined | number): ISeries<number, number>

  • For each period, compute the proportion of values that are less than the last value in the period. Proportions are expressed as 0-1 values.

    example
    
const proportionRank = series.proportionRank();
    example
    
const proportionRank = series.proportionRank(100);

    Parameters

    • Optional period: undefined | number

      Optional period for computing the proportion rank - defaults to 2.

    Returns ISeries<number, number>

    Returns a new series where each value indicates the proportion rank value for that period.

range

  • range(): number

  • Get the range of values in the series.

    example
    
const range = salesFigures.range();

    Returns number

    Returns the range of the number values in the series.

reduce

  • Reduces the values in the series to a single result.

    This is the same concept as the JavaScript function Array.reduce but reduces a data series rather than an array.

    example
    
const dailySales = ... daily sales figures for the past month ...
const totalSalesForthisMonth = dailySales.reduce(
     (accumulator, salesAmount) => accumulator + salesAmount, // Reducer function.
     0  // Seed value, the starting value.
);
    example
    
const previousSales = 500; // We'll seed the reduction with this value.
const dailySales = ... daily sales figures for the past month ...
const updatedSales = dailySales.reduce(
     (accumulator, salesAmount) => accumulator + salesAmount,
     previousSales
);

    Type parameters

    • ToT

    Parameters

    • reducer: AggregateFn<IndexT, ToT>

      Function that takes the seed and then each value in the series and produces the reduced value.

    • Optional seed: ToT

      Optional initial value, if not specifed the first value in the series is used as the initial value.

    Returns ToT

    Returns a new value that has been reduced from the input series by passing it through the 'reducer' function.

resetIndex

  • resetIndex(): ISeries<number, IndexT>

  • Resets the Index of the series back to the default zero-based sequential integer index.

    example
    
const seriesWithResetIndex = series.resetIndex();

    Returns ISeries<number, IndexT>

    Returns a new series with the Index reset to the default zero-based index.

reverse

  • reverse(): ISeries<number, IndexT>

  • Gets a new series in reverse order.

    example
    
const reversed = series.reverse();

    Returns ISeries<number, IndexT>

    Returns a new series that is the reverse of the original.

rollingWindow

  • Partition a series into a new series of rolling data windows. Each value in the new series is a rolling chunk of data from the original series.

    example
    
const salesData = ... // Daily sales data.
const rollingWeeklySales = salesData.rollingWindow(7); // Get rolling window over weekly sales data.
console.log(rollingWeeklySales.toString());

    Parameters

    • period: number

      The number of data values to include in each data window.

    • Optional whichIndex: WhichIndex

      Sets which side of the window the index comes from: start or end. Can be "start" or "end", defaults to "end".

    Returns ISeries<number, ISeries<number, IndexT>>

    Returns a new series, each value of which is a rolling chunk of the original series.

round

  • round(numDecimalPlaces?: undefined | number): ISeries<number, IndexT>

  • Produces a new series with all number values rounded to the specified number of places.

    example
    
const series = ... your data series ...
const rounded = series.round(); // Round numbers to two decimal places.
    example
    
const series = ... your data series ...
const rounded = series.round(3); // Round numbers to three decimal places.

    Parameters

    • Optional numDecimalPlaces: undefined | number

      The number of decimal places, defaults to 2.

    Returns ISeries<number, IndexT>

    Returns a new series with all number values rounded to the specified number of places.

sampleStandardize

  • sampleStandardize(): ISeries<number, number>

  • Standardize a series of numbers by converting each "standard deviations from the mean". This converts the input series to Z scores using the sample standard deviation.

    example
    
const standardizedSeries = series.sampleStandardize();

    Returns ISeries<number, number>

    A new series containing Z scores computed from the input series.

sampleStd

  • sampleStd(): number

  • Get the (sample) standard deviation of number values in the series.

    example
    
const salesStdDev = salesFigures.sampleStd();

    Returns number

    Returns the (sample) standard deviation of the values in the series.

sampleVariance

  • sampleVariance(): number

  • Get the (sample) variance of number values in the series.

    example
    
const salesVariance = salesFigures.variance();

    Returns number

    Returns the (sample) variance of the values in the series.

select

  • Transforms an input series, generating a new series. The transformer function is called for each element of the input and the collection of outputs creates the generated series.

    select is an alias for Series.map.

    This is the same concept as the JavaScript function Array.map but maps over a data series rather than an array.

    example
    
function transformer (input) {
     const output = // ... construct output from input ...
     return output;
}

const transformed = series.select(transformer);
console.log(transformed.toString());

    Type parameters

    • ToT

    Parameters

    • transformer: SelectorWithIndexFn<IndexT, ToT>

      A user-defined transformer function that transforms each element from the input to generate the output.

    Returns ISeries<number, ToT>

    Returns the series generated by calling the transformer function over each value in the input series.

selectMany

  • Transforms and flattens an input series, generating a new series. The transformer function is called for each value in the input series and produces an array that is then flattened into the generated series.

    selectMany is an alias for Series.flatMap.

    This is the same concept as the JavaScript function Array.flatMap but maps over a data series rather than an array.

    example
    
function transformer (input) {
     const output = [];
     while (someCondition) {
         // ... generate zero or more outputs from a single input ...
         output.push(... some generated value ...);
     }
     return output;
}

const transformed = series.selectMany(transformer);
console.log(transformed.toString());

    Type parameters

    • ToT

    Parameters

    • transformer: SelectorWithIndexFn<IndexT, Iterable<ToT>>

      A user-defined function that transforms each value into an array that is then flattened into the generated series.

    Returns ISeries<number, ToT>

    Returns a new series generated by calling the transformer function over each element of the input.

sequentialDistinct

  • sequentialDistinct<ToT>(selector: SelectorFn<IndexT, ToT>): ISeries<number, IndexT>

  • Eliminates adjacent duplicate values.

    For each group of adjacent values that are equivalent only returns the last index/row for the group, thus ajacent equivalent values are collapsed down to the last value.

    example
    
const seriesWithDuplicateRowsRemoved = series.sequentialDistinct(value => value);

// Or
const seriesWithDuplicateRowsRemoved = series.sequentialDistinct(value => value.someNestedField);

    Type parameters

    • ToT

    Parameters

    • selector: SelectorFn<IndexT, ToT>

      Optional selector function to determine the value used to compare for equivalence.

    Returns ISeries<number, IndexT>

    Returns a new series with groups of adjacent duplicate vlaues collapsed to a single value per group.

skip

  • skip(numValues: number): ISeries<number, IndexT>

  • Skip a number of values in the series.

    example
    
const seriesWithRowsSkipped = series.skip(10); // Skip 10 rows in the original series.

    Parameters

    • numValues: number

      Number of values to skip.

    Returns ISeries<number, IndexT>

    Returns a new series with the specified number of values skipped.

skipUntil

  • Skips values in the series untils a condition evaluates to true or truthy.

    example
    
const seriesWithRowsSkipped = series.skipUntil(salesFigure => salesFigure > 100); // Skip initial sales figures unitl we see one greater than 100.

    Parameters

    • predicate: PredicateFn<IndexT>

      Return true/truthy to stop skipping values in the original series.

    Returns ISeries<number, IndexT>

    Returns a new series with all initial sequential values removed until the predicate returned true/truthy.

skipWhile

  • Skips values in the series while a condition evaluates to true or truthy.

    example
    
const seriesWithRowsSkipped = series.skipWhile(salesFigure => salesFigure > 100); // Skip initial sales figure that are less than 100.

    Parameters

    • predicate: PredicateFn<IndexT>

      Returns true/truthy to continue to skip values in the original series.

    Returns ISeries<number, IndexT>

    Returns a new series with all initial sequential values removed while the predicate returned true/truthy.

standardize

  • standardize(): ISeries<number, number>

  • Standardize a series of numbers by converting each "standard deviations from the mean". This converts the input series to Z scores using the population standard deviation.

    example
    
const standardizedSeries = series.standardize();

    Returns ISeries<number, number>

    A new series containing Z scores computed from the input series.

startAt

  • startAt(indexValue: number): ISeries<number, IndexT>

  • Gets a new series containing all values starting at or after the specified index value.

    example
    
const series = new Series({
     index: [0, 1, 2, 3], // This is the default index.
     values: [10, 20, 30, 40],
});

const lastHalf = series.startAt(2);
expect(lastHalf.toArray()).to.eql([30, 40]);
    example
    
const timeSeries = ... a series indexed by date/time ...

// Get all values starting at (or after) a particular date.
const result = timeSeries.startAt(new Date(2016, 5, 4));

    Parameters

    • indexValue: number

      The index value at which to start the new series.

    Returns ISeries<number, IndexT>

    Returns a new series containing all values starting at or after the specified index value.

std

  • std(): number

  • Get the standard deviation of number values in the series.

    example
    
const salesStdDev = salesFigures.std();

    Returns number

    Returns the standard deviation of the values in the series.

sum

  • sum(): number

  • Sum the values in a series and returns the result.

    example
    
const totalSales = salesFigures.sum();

    Returns number

    Returns the sum of the number values in the series.

tail

  • tail(numValues: number): ISeries<number, IndexT>

  • Get X values from the end of the series. Pass in a negative value to get all values at the tail except X values at the head.

    examples
    
const sample = series.tail(12); // Take a sample of 12 values from the end of the series.

    Parameters

    • numValues: number

      Number of values to take.

    Returns ISeries<number, IndexT>

    Returns a new series that has only the specified number of values taken from the end of the original series.

take

  • take(numRows: number): ISeries<number, IndexT>

  • Take a number of values from the series.

    example
    
const seriesWithRowsTaken = series.take(15); // Take only the first 15 values from the original series.

    Parameters

    • numRows: number

    Returns ISeries<number, IndexT>

    Returns a new series with only the specified number of values taken from the original series.

takeUntil

  • Takes values from the series until a condition evaluates to true or truthy.

    example
    
const seriesWithRowsTaken = series.takeUntil(salesFigure => salesFigure > 100); // Take all initial sales figures until we see one that is greater than 100.

    Parameters

    • predicate: PredicateFn<IndexT>

      Return true/truthy to stop taking values in the original series.

    Returns ISeries<number, IndexT>

    Returns a new series with only the initial sequential values taken until the predicate returned true/truthy.

takeWhile

  • Takes values from the series while a condition evaluates to true or truthy.

    example
    
const seriesWithRowsTaken = series.takeWhile(salesFigure => salesFigure > 100); // Take only initial sales figures that are greater than 100.

    Parameters

    • predicate: PredicateFn<IndexT>

      Returns true/truthy to continue to take values from the original series.

    Returns ISeries<number, IndexT>

    Returns a new series with only the initial sequential values that were taken while the predicate returned true/truthy.

toArray

  • toArray(): IndexT[]

  • Extract values from the series as an array. This forces lazy evaluation to complete.

    example
    const values = series.toArray();

    Returns IndexT[]

    Returns an array of the values contained within the series.

toObject

  • toObject<KeyT, FieldT, OutT>(keySelector: function, valueSelector: function): OutT

  • Convert the series to a JavaScript object.

    example
    
const someObject = series.toObject(
     value => value, // Specify the value to use for field names in the output object.
     value => value // Specify the value to use as the value for each field.
);

    Type parameters

    • KeyT

    • FieldT

    • OutT

    Parameters

    • keySelector: function

      User-defined selector function that selects keys for the resulting object.

        • (value: IndexT): KeyT

        • Parameters

          • value: IndexT

          Returns KeyT

    • valueSelector: function

      User-defined selector function that selects values for the resulting object.

        • (value: IndexT): FieldT

        • Parameters

          • value: IndexT

          Returns FieldT

    Returns OutT

    Returns a JavaScript object generated from the series by applying the key and value selector functions.

toPairs

  • toPairs(): Object[]

  • Retreive the index, values pairs from the series as an array. Each pair is [index, value]. This forces lazy evaluation to complete.

    example
    const pairs = series.toPairs();

    Returns Object[]

    Returns an array of pairs that contains the series values. Each pair is a two element array that contains an index and a value.

toString

  • toString(): string

  • Format the series for display as a string. This forces lazy evaluation to complete.

    example
    
console.log(series.toString());

    Returns string

    Generates and returns a string representation of the series.

toStrings

  • toStrings(formatString?: undefined | string): ISeries<number, string>

  • Convert a series of values of different types to a series containing string values.

    example
    
const result = series.toStrings("YYYY-MM-DD");
    example
    
const result = series.toStrings("0.00");

    Parameters

    Returns ISeries<number, string>

    Returns a new series values converted from values to strings.

truncateStrings

  • truncateStrings(maxLength: number): ISeries<number, IndexT>

  • Produces a new series with all string values truncated to the requested maximum length.

    example
    
const truncated = series.truncateStrings(10); // Truncate all string values to max length of 10 characters.

    Parameters

    • maxLength: number

      The maximum length of the string values after truncation.

    Returns ISeries<number, IndexT>

    Returns a new series with strings that are truncated to the specified maximum length.

union

  • Creates a new series by merging two input dataframes. The resulting series contains the union of value from the two input series. These are the unique combination of values in both series. This is basically a concatenation and then elimination of duplicates.

    example
    
const seriesA = ...
const seriesB = ...
const merged = seriesA.union(seriesB);
    example
    
// Merge two sets of customer records that may contain the same
// customer record in each set. This is basically a concatenation
// of the series and then an elimination of any duplicate records
// that result.
const customerRecordsA = ...
const customerRecordsB = ...
const mergedCustomerRecords = customerRecordsA.union(
     customerRecordsB,
     customerRecord => customerRecord.CustomerId
);
    example
    
// Note that you can achieve the exact same result as the previous
// example by doing a {@link Series.concat) and {@link Series.distinct}
// of the input series and then an elimination of any duplicate records
// that result.
const customerRecordsA = ...
const customerRecordsB = ...
const mergedCustomerRecords = customerRecordsA
     .concat(customerRecordsB)
     .distinct(customerRecord => customerRecord.CustomerId);

    Type parameters

    • KeyT

    Parameters

    • other: ISeries<number, IndexT>

      The other series to merge.

    • Optional selector: SelectorFn<IndexT, KeyT>

      Optional user-defined selector function that selects the value to compare to determine distinctness.

    Returns ISeries<number, IndexT>

    Returns the union of the two series.

variableWindow

  • Partition a series into a new series of variable-length data windows where the divisions between the data chunks are defined by a user-provided comparer function.

    example
    
function rowComparer (valueA, valueB) {
     if (... valueA should be in the same data window as valueB ...) {
         return true;
     }
     else {
         return false;
     }
};

const variableWindows = series.variableWindow(rowComparer);

    Parameters

    • comparer: ComparerFn<IndexT, IndexT>

      Function that compares two adjacent data values and returns true if they should be in the same window.

    Returns ISeries<number, ISeries<number, IndexT>>

    Returns a new series, each value of which is a chunk of data from the original series.

variance

  • variance(): number

  • Get the variance of number values in the series.

    example
    
const salesVariance = salesFigures.variance();

    Returns number

    Returns the variance of the values in the series.

where

  • Filter the series using user-defined predicate function.

    where is an alias for Series.filter.

    This is the same concept as the JavaScript function Array.filter but filters a data series rather than an array.

    example
    
// Filter so we only have sales figures greater than 100.
const filtered = series.where(salesFigure => salesFigure > 100);
console.log(filtered.toArray());

    Parameters

    • predicate: PredicateFn<IndexT>

      Predicate function to filter values from the series. Returns true/truthy to keep elements, or false/falsy to omit elements.

    Returns ISeries<number, IndexT>

    Returns a new series containing only the values from the original series that matched the predicate.

window

  • Partition a series into a Series of data windows. Each value in the new series is a chunk of data from the original series.

    example
    
const windows = series.window(2); // Get values in pairs.
const pctIncrease = windows.select(pair => (pair.last() - pair.first()) / pair.first());
console.log(pctIncrease.toString());
    example
    
const salesDf = ... // Daily sales data.
const weeklySales = salesDf.window(7); // Partition up into weekly data sets.
console.log(weeklySales.toString());

    Parameters

    • period: number

      The number of values to include in each data window.

    • Optional whichIndex: WhichIndex

      Sets which side of the window the index comes from: start or end. Can be "start" or "end", defaults to "end".

    Returns ISeries<number, ISeries<number, IndexT>>

    Returns a new series, each value of which is a chunk (data window) of the original series.

withIndex

  • withIndex<NewIndexT>(newIndex: Iterable<NewIndexT> | SelectorFn<IndexT, NewIndexT>): ISeries<NewIndexT, IndexT>

  • Apply a new Index to the series.

    example
    
const indexedSeries = series.withIndex([10, 20, 30]);
    example
    
const indexedSeries = series.withIndex(someOtherSeries);
    example
    
const indexedSeries = series.withIndex(value => computeIndexFromValue(value));
    example
    
const indexedSeries = series.withIndex(value => value + 20);

    Type parameters

    • NewIndexT

    Parameters

    • newIndex: Iterable<NewIndexT> | SelectorFn<IndexT, NewIndexT>

      The new array or iterable to be the new Index of the series. Can also be a selector to choose the Index for each value in the series.

    Returns ISeries<NewIndexT, IndexT>

    Returns a new series with the specified Index attached.

zip

  • zip<Index2T, Value2T, ResultT>(s2: ISeries<Index2T, Value2T>, zipper: Zip2Fn<IndexT, Value2T, ResultT>): ISeries<number, ResultT>
  • zip<Index2T, Value2T, Index3T, Value3T, ResultT>(s2: ISeries<Index2T, Value2T>, s3: ISeries<Index3T, Value3T>, zipper: Zip3Fn<IndexT, Value2T, Value3T, ResultT>): ISeries<number, ResultT>
  • zip<Index2T, Value2T, Index3T, Value3T, Index4T, Value4T, ResultT>(s2: ISeries<Index2T, Value2T>, s3: ISeries<Index3T, Value3T>, s4: ISeries<Index4T, Value4T>, zipper: Zip3Fn<IndexT, Value2T, Value3T, ResultT>): ISeries<number, ResultT>
  • zip<ResultT>(...args: any[]): ISeries<number, ResultT>

  • Zip together multiple series to create a new series. Preserves the index of the first series.

    example
    
const a = new Series([1, 2, 3]);
const b = new Series([10, 20, 30]);
const zipped = a.zip(b (valueA, valueB) => valueA + valueB);

    Type parameters

    • Index2T

    • Value2T

    • ResultT

    Parameters

    • s2: ISeries<Index2T, Value2T>
    • zipper: Zip2Fn<IndexT, Value2T, ResultT>

      User-defined zipper function that merges rows. It produces values for the new series based-on values from the input series.

    Returns ISeries<number, ResultT>

    Returns a single series merged from multiple input series.

  • Type parameters

    • Index2T

    • Value2T

    • Index3T

    • Value3T

    • ResultT

    Parameters

    • s2: ISeries<Index2T, Value2T>
    • s3: ISeries<Index3T, Value3T>
    • zipper: Zip3Fn<IndexT, Value2T, Value3T, ResultT>

    Returns ISeries<number, ResultT>

  • Type parameters

    • Index2T

    • Value2T

    • Index3T

    • Value3T

    • Index4T

    • Value4T

    • ResultT

    Parameters

    • s2: ISeries<Index2T, Value2T>
    • s3: ISeries<Index3T, Value3T>
    • s4: ISeries<Index4T, Value4T>
    • zipper: Zip3Fn<IndexT, Value2T, Value3T, ResultT>

    Returns ISeries<number, ResultT>

  • Type parameters

    • ResultT

    Parameters

    • Rest ...args: any[]

    Returns ISeries<number, ResultT>

Generated using TypeDoc