stream-charts 1.0.1 → 1.1.1

package/src/app/charts/observables/iterates.test.ts

@@ -0,0 +1,201 @@
+import {scan} from 'rxjs/operators';
+import {Observable, range} from 'rxjs';
+import {initialTimeSeriesChartData, TimeSeriesChartData} from "../series/timeSeriesChartData";
+import {Datum, datumOf, TimeSeries} from "../series/timeSeries";
+import {seriesFrom} from "../series/baseSeries";
+
+/**
+ * Higher-order function that forms a closure on the tent-map parameter, mu,
+ * and returns a tent-map function that accepts time and an iterate value. The
+ * time is only used for chart information, and not in the calculation of the
+ * next iterate.
+ * <pre>f[n+1](x) = mu * min(f[n](x), 1 - f[n](x))</pre>
+ * @param mu The "slope" of the tent function
+ * @return A datum, (t, f[n+1](x)) holding the informational time, and the
+ * value of the next iterate
+ */
+function tentMapFn(mu: number): (time: number, xn: number) => Datum {
+    const cleanMu = Math.max(0, Math.min(mu, 2))
+
+    // the time is just the data collection time and does not factor int
+    // the tent map calculation.
+    return (time: number, xn: number): Datum => {
+        const xn1 = cleanMu * Math.min(xn, 1 - xn)
+        return datumOf(time, xn1)
+    }
+}
+
+/**
+ * Higher-order function that forms a closure on the update-period of the incoming data.
+ * This function returns an accumulator function that uses the previous iterate (time-series
+ * chart-data) to calculate the next iterate (time-series chart-data).
+ * @param updatePeriod The update period, in milliseconds, forming the processing
+ * windows of the graph
+ * @return A function returns an accumulator function that uses the previous iterate (time-series
+ * chart-data) to calculate the next iterate (time-series chart-data).
+ */
+function accumulateTentDataAt(updatePeriod: number):
+    (previous: TimeSeriesChartData, iterateNum: number, tentMap: (time: number, xn: number) => Datum) => TimeSeriesChartData
+{
+    /**
+     * Calculates the next iterate, given the previous iterate, by applying the
+     * specified `tentMap` function
+     * @param previous The previous iterate
+     * @param iterateNum The iterate
+     * @param tentMap The function to calculate the tent-map
+     * @return The next iterate
+     */
+    return (
+        previous: TimeSeriesChartData,
+        iterateNum: number,
+        tentMap: (time: number, xn: number) => Datum
+    ): TimeSeriesChartData => {
+        // make a copy of the current max times, which we'll update with new points
+        const maxTimes = new Map(previous.maxTimes.entries())
+        previous.newPoints.forEach((datum, name) => {
+            maxTimes.set(name, (datum[datum.length - 1].time + updatePeriod))
+        })
+        // deep copy of the previous data points, and calculate the next point
+        const newPoints = new Map(Array.from(previous.newPoints.entries())
+            .map(([name, data]) => [name, data.slice()]))
+        newPoints.forEach((data, _) => {
+            const lastDatum = data[data.length - 1]
+            const newDatum = tentMap(lastDatum.time + updatePeriod, lastDatum.value)
+            data.shift()
+            data.push(newDatum)
+        })
+
+        return {
+            seriesNames: new Set<string>(previous.newPoints.keys()),
+            maxTime: previous.maxTime + updatePeriod,
+            maxTimes,
+            newPoints,
+            currentTime: (previous.currentTime || 0) + updatePeriod
+        }
+    }
+}
+
+/**
+ * Calculates and returns a time-series of iterates of the tent-map function.
+ * @param numPoints The number of iterates to calculate
+ * @param mu The slope of the tent-map function
+ * @param series The initial series
+ * @param updatePeriod The update period (chart-window processing)
+ * @return An observable of time-series chart-data holding the iterates
+ */
+function tentMapTimeSeriesObservable(
+    numPoints: number = 10,
+    mu: number,
+    series: Array<TimeSeries>,
+    updatePeriod: number = 25
+): Observable<TimeSeriesChartData> {
+    const maxTime = series
+        .map(srs => srs.last().map(datum => datum.time).getOrElse(0))
+        .reduce((tMax, tCurr) => (tCurr > tMax) ? tCurr : tMax, -Infinity)
+    const initialData = initialTimeSeriesChartData(series, maxTime)
+    const tentMap = tentMapFn(mu)
+    const accumulateFn = accumulateTentDataAt(updatePeriod);
+    return range(series.length, numPoints).pipe(
+        scan((prev, sequence) => accumulateFn(prev, sequence + 1, tentMap), initialData)
+    )
+}
+
+describe('when calculating tent-map iterates', () => {
+
+    const expected: Array<TimeSeriesChartData> = [
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 26,
+            maxTimes: new Map([["test1", 26]]),
+            newPoints: new Map([["test1", [datumOf(26, 0.578)]]]),
+            currentTime: 26
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 51,
+            maxTimes: new Map([["test1", 51]]),
+            newPoints: new Map([["test1", [datumOf(51, 0.7174)]]]),
+            currentTime: 51
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 76,
+            maxTimes: new Map([["test1", 76]]),
+            newPoints: new Map([["test1", [datumOf(76, 0.48042)]]]),
+            currentTime: 76
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 101,
+            maxTimes: new Map([["test1", 101]]),
+            newPoints: new Map([["test1", [datumOf(101, 0.816714)]]]),
+            currentTime: 101
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 126,
+            maxTimes: new Map([["test1", 126]]),
+            newPoints: new Map([["test1", [datumOf(126, 0.3115862)]]]),
+            currentTime: 126
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 151,
+            maxTimes: new Map([["test1", 151]]),
+            newPoints: new Map([["test1", [datumOf(151, 0.52969654)]]]),
+            currentTime: 151
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 176,
+            maxTimes: new Map([["test1", 176]]),
+            newPoints: new Map([["test1", [datumOf(176, 0.799515882)]]]),
+            currentTime: 176
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 201,
+            maxTimes: new Map([["test1", 201]]),
+            newPoints: new Map([["test1", [datumOf(201, 0.3408230006)]]]),
+            currentTime: 201
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 226,
+            maxTimes: new Map([["test1", 226]]),
+            newPoints: new Map([["test1", [datumOf(226, 0.5793991)]]]),
+            currentTime: 226
+        },
+        {
+            seriesNames: new Set<string>(["test1"]),
+            maxTime: 251,
+            maxTimes: new Map([["test1", 251]]),
+            newPoints: new Map([["test1", [datumOf(251, 0.7150215282659962)]]]),
+            currentTime: 251
+        },
+    ]
+
+    function assertChartDataEqual(expected: TimeSeriesChartData, actual: TimeSeriesChartData): void {
+        expect(actual.maxTime).toEqual(expected.maxTime);
+        expect(actual.maxTimes).toEqual(expected.maxTimes);
+        Array.from(actual.newPoints.entries())
+            .forEach(([name, data]: [string, Array<Datum>], index: number) => {
+                data.forEach(actualDatum => {
+                    const expectedDatum: Datum = expected.newPoints.get(name)![index]
+                    expect(actualDatum.time).toEqual(expectedDatum.time)
+                    expect(actualDatum.value).toBeCloseTo(expectedDatum.value, 6)
+                })
+            })
+    }
+
+    test('should be able to calculate the tent-map iterates', done => {
+        let results: Array<TimeSeriesChartData> = []
+        const initialData: Array<TimeSeries> = [seriesFrom("test1", [datumOf(1, 0.66)])]
+        tentMapTimeSeriesObservable(10, 1.7, initialData).subscribe(chartData => results.push(chartData))
+        done()
+        expect(results).toHaveLength(10)
+        results.forEach((result, index) => {
+            assertChartDataEqual(expected[index], result)
+        })
+    })
+})

package/src/app/charts/observables/iterates.ts

@@ -0,0 +1,203 @@
+/**
+ * Utilities for plotting function iterates. For example suppose that f[1](x) = f(x), f[2](x) = f(f(x)),
+ * f[3](x) = f(f(f(x))), and f[m](x) = f(f(f....(x))), where the function is applied m times. Given this,
+ * then an iterate (Poincare) plot shows points (f[m](x), f[m+1](x)), which is a 1-iterate. Plots of
+ * points (f[m](x), f[m+n](x)) are n-iterates.
+ *
+ * 1. Convert series to chart data observable in the usual way
+ * 2. Accepts that chart-data observable and converts that observable to an iterate-chart-data observable
+ */
+import {Observable} from "rxjs";
+import {TimeSeriesChartData} from "../series/timeSeriesChartData";
+import {filter, map, scan} from "rxjs/operators";
+import {Datum, emptyDatum} from "../series/timeSeries";
+import {emptyIterateDatum, IterateDatum, iterateDatumOf, nonEmptyIterateDatum} from "../series/iterateSeries";
+import {ChartData, copyChartData, defaultChartData} from "./ChartData";
+
+
+export interface IterateChartData extends ChartData {
+    /**
+     * The min values for (time, iterate n, and iterate n+1) for the data in the newPoints map
+     */
+    minIterate: IterateDatum
+
+    /**
+     * The max values for (time, iterate n, and iterate n+1) for the data in the newPoints map
+     */
+    maxIterate: IterateDatum
+
+    /**
+     * Holds the association of the series name to the current min time for that series
+     */
+    minIterates: Map<string, IterateDatum>
+
+    /**
+     * Holds the association of the series name to the current max time for that series
+     */
+    maxIterates: Map<string, IterateDatum>
+
+    /**
+     * Map holding the name of the series (the time-series identifier) and the associated
+     * data points for that time-series (`map(series_name -> array(datum))`)
+     */
+    newPoints: Map<string, Array<IterateDatum>>
+}
+
+const emptyIterateData = (): IterateChartData => ({
+    ...defaultChartData(),
+    minIterate: emptyIterateDatum,
+    maxIterate: emptyIterateDatum,
+    minIterates: new Map<string, IterateDatum>(),
+    maxIterates: new Map<string, IterateDatum>(),
+    newPoints: new Map<string, Array<IterateDatum>>()
+})
+
+/**
+ * Makes a deep copy of the iterate chart data
+ * @param data The iterate chart data to copy
+ */
+export const copyIterateDataFrom = (data: IterateChartData): IterateChartData => ({
+    ...copyChartData(data),
+    minIterate: data.minIterate,
+    maxIterate: data.maxIterate,
+    minIterates: new Map<string, IterateDatum>(data.minIterates),
+    maxIterates: new Map<string, IterateDatum>(data.maxIterates),
+    newPoints: new Map<string, Array<IterateDatum>>(Array.from(data.newPoints.entries()).map(([name, points]) => [name, points.slice()])),
+})
+
+type Accumulator = {
+    n: number
+    previous: Map<string, Array<Datum>>
+    accumulated: IterateChartData
+}
+
+const initialAccumulate = (n: number): Accumulator => ({n, previous: new Map(), accumulated: emptyIterateData()})
+
+/**
+ * Accepts a {@link TimeSeriesChartData} observable and converts it to an observable of {@link IterateChartData}
+ * for the specified n-iterate. suppose that `f[0](x) = x`, `f[1](x) = f(x)`, `f[2](x) = f(f(x))`,
+ * `f[3](x) = f(f(f(x)))`, and `f[m](x) = f(f(f....(x)))`, where the function is applied `m` times. Given this,
+ * then an iterate (Poincare) plot shows points `(f[m](x), f[m+1](x))`, which is a 1-iterate. Plots of
+ * points `(f[m](x), f[m+n](x))` are n-iterates.
+ * @param dataObservable The observable over {@link TimeSeriesChartData}
+ * @param [n=1] The iterate distance
+ * @return An over {@link IterateChartData} holding the n-iterate for the incoming chart data
+ */
+export function iteratesObservable(dataObservable: Observable<TimeSeriesChartData>, n: number = 1): Observable<IterateChartData> {
+    return dataObservable
+        .pipe(
+            // calculate the iterates for each series in the chart data
+            scan(({n, previous, accumulated}: Accumulator, current: TimeSeriesChartData) => {
+                // make a deep copy of the accumulated data (because the accumulated data object
+                // holds references to maps)
+                const accum = copyIterateDataFrom(accumulated)
+
+                // for each series, add the new points to the accumulated data
+                Array
+                    .from(current.newPoints.entries())
+                    .forEach(([name, series]) => {
+                        // grab the points from the previous incoming data and add the new
+                        // data to its end (when the updated data didn't yet exist, add it
+                        // to the map holding the previous series)
+                        const updated = (previous.get(name) || [])
+                        if (updated.length === 0) {
+                            previous.set(name, updated)
+                        }
+                        updated.push(...series)
+
+                        // we may have multiple new data points for this series, so we may need to
+                        // calculate multiple iterates
+                        while (updated.length > n) {
+                            // grab the start and end of the n-iterate interval
+                            const last = updated[n]
+                            const first = updated.shift() || emptyDatum()
+
+                            // set the updated new points for the series for the next
+                            // iteration of the while-loop
+                            previous.set(name, updated)
+
+                            // create the new iterate
+                            const iterate: IterateDatum = iterateDatumOf(first.time, first.value, last.value);
+
+                            // update the min, max values for all the series
+                            accum.minIterate = minIterateFor(iterate, accum.minIterate)
+                            accum.maxIterate = maxIterateFor(iterate, accum.maxIterate)
+
+                            // update the min, max values for the current series
+                            accum.minIterates.set(name, minIterateFor(iterate, accum.minIterates.get(name)))
+                            accum.maxIterates.set(name, maxIterateFor(iterate, accum.maxIterates.get(name)))
+
+                            // add the newly calculated iterate, and then trim from the
+                            // head of the array to a size n. For the iterates, we only need
+                            // to keep enough to create points (x(j), x(j+n))
+                            const updatedPoints = accum.newPoints.get(name) || []
+                            if (updatedPoints.length === 0) {
+                                accum.newPoints.set(name, updatedPoints)
+                            }
+                            updatedPoints.push(iterate)
+                            if (updatedPoints.length > series.length) {
+                                updatedPoints.shift()
+                            }
+                        }
+                    })
+                return {n, previous, accumulated: accum}
+            }, initialAccumulate(n)),
+
+            // remove new points from the map that are empty
+            filter(accum => !isNaN(accum.accumulated.minIterate.iterateN) && !isNaN(accum.accumulated.minIterate.iterateN_1)),
+            map(accum => removeEmptyNewPoints(accum)),
+            map(accum => accum.accumulated === undefined ? emptyIterateData() : accum.accumulated)
+        )
+}
+
+/**
+ * Calculates and returns the minimum values for the specified iterate and the current minimum
+ * @param iterate The iterate to compare against the minimum
+ * @param minIterate The minimum values for the iterate. Generally, this will be the accumulated
+ * values
+ * @return the minimum values for the specified iterate and the current minimum
+ */
+function minIterateFor(iterate: IterateDatum, minIterate: IterateDatum = emptyIterateDatum): IterateDatum {
+    const minN = isNaN(minIterate.iterateN) ? iterate.iterateN : Math.min(iterate.iterateN, minIterate.iterateN)
+    const minN_1 = isNaN(minIterate.iterateN_1) ? iterate.iterateN_1 : Math.min(iterate.iterateN_1, minIterate.iterateN_1)
+    const minTime = (iterate.iterateN <= minN || iterate.iterateN_1 <= minN_1) ? iterate.time : minIterate.time
+    return {
+        time: minTime,
+        iterateN: minN,
+        iterateN_1: minN_1
+    }
+}
+
+/**
+ * Calculates and returns the maximum values for the specified iterate and the current maximum
+ * @param iterate The iterate to compare against the maximum
+ * @param maxIterate The maximum values for the iterate. Generally, this will be the accumulated
+ * values
+ * @return the maximum values for the specified iterate and the current maximum
+ */
+function maxIterateFor(iterate: IterateDatum, maxIterate: IterateDatum = emptyIterateDatum): IterateDatum {
+    const maxN = isNaN(maxIterate.iterateN) ? iterate.iterateN : Math.max(iterate.iterateN, maxIterate.iterateN)
+    const maxN_1 = isNaN(maxIterate.iterateN_1) ? iterate.iterateN_1 : Math.max(iterate.iterateN_1, maxIterate.iterateN_1)
+    const maxTime = (iterate.iterateN >= maxN || iterate.iterateN_1 >= maxN_1) ? iterate.time : maxIterate.time
+    return {
+        time: maxTime,
+        iterateN: maxN,
+        iterateN_1: maxN_1
+    }
+}
+
+function removeEmptyNewPoints(accum: Accumulator): Accumulator {
+    const newPoints = new Map(
+        Array
+            .from(accum.accumulated.newPoints.entries())
+            .map(([name, points]) => [name, points.filter(point => nonEmptyIterateDatum(point))])
+    )
+    return {
+        n: accum.n,
+        previous: accum.previous,
+        accumulated: {
+            ...accum.accumulated,
+            newPoints
+        }
+    }
+}

package/src/app/charts/observables/ordinals.test.ts

@@ -0,0 +1,135 @@
+import {TimeSeriesChartData} from "../series/timeSeriesChartData";
+import {Datum, datumOf, TimeSeries} from "../series/timeSeries";
+import {seriesFrom} from "../series/baseSeries";
+import {Observable, range} from "rxjs";
+import {map} from "rxjs/operators";
+import {OrdinalChartData, ordinalsObservable} from "./ordinals";
+
+export function sinFn(x: number, period: number): number {
+    return Math.sin(2 * Math.PI * x / period)
+}
+
+describe('when generating ordinal series', () => {
+    const NUM_POINTS = 10
+    const UPDATE_PERIOD = 25
+    const seriesData: Array<[string, number]> = [["test1", sinFn(0, 250)], ["test2", sinFn(1, 251)], ["test3", sinFn(2, 252)]]
+
+    const initialData: Array<TimeSeries> = seriesData
+        .map(([name, value], index) => seriesFrom(name, [datumOf(index, value)]))
+
+    test('should be able to generate ordinals', done => {
+        let results: Array<OrdinalChartData> = []
+        ordinalsObservable(
+            sineDataObservable(initialData, NUM_POINTS, UPDATE_PERIOD)
+        ).subscribe(chartData => results.push(chartData))
+
+        // blocks until done is called
+        done()
+
+        expect(results).toHaveLength(NUM_POINTS)
+
+        results.forEach((result, timeIndex) => {
+            Array.from(result.newPoints.entries()).forEach(([seriesName, ordinalDatum], index) => {
+                expect(seriesName).toEqual(seriesData[index][0])
+
+                // check the time for the datum (only one new-point datum)
+                expect(ordinalDatum).toBeDefined()
+                expect(ordinalDatum.length).toBe(1)
+                expect(ordinalDatum[0].time).toEqual(index+ timeIndex * UPDATE_PERIOD)
+
+                // should be bounded (data is bounded)
+                expect(ordinalDatum[0].value).toBeLessThanOrEqual(1)
+                expect(ordinalDatum[0].value).toBeGreaterThanOrEqual(-1)
+            })
+
+            // the min time should be 1 and the max time should be (3 + timeIndex + updatePeriod)
+            expect(result.stats.minDatum.time.time).toBe(0)
+            expect(result.stats.maxDatum.time.time).toBe(2 + timeIndex * UPDATE_PERIOD)
+        })
+
+    })
+
+})
+
+/**
+ * Creates random data
+ * @param sequenceTime The current time
+ * @param maxTime The number of points in the series
+ * @param series The list of series names (identifiers) to update
+ * @param seriesMaxTimes The maximum time for each series
+ * @return The random chart data
+ */
+function sineData(
+    sequenceTime: number,
+    maxTime: number,
+    series: Array<string>,
+    seriesMaxTimes: Map<string, number>
+): TimeSeriesChartData {
+    const maxTimes = new Map(Array.from(
+        seriesMaxTimes.entries()).map(([name, maxTime]) => [name, maxTime + sequenceTime])
+    )
+    return {
+        seriesNames: new Set(series),
+        maxTime: sequenceTime,
+        maxTimes,
+        newPoints: new Map(series.map((name, index) => {
+            const time = sequenceTime + index
+            const value = sinFn(time, maxTime + index)
+            return [name, [{time, value}]]
+        }))
+    };
+}
+
+/**
+ * Creates an empty chart data object with all the values set to 0
+ * @param seriesList The list of series names (identifiers) to update
+ * @param currentTime=0] The current time
+ * @return An empty chart data object
+ */
+function initialChartData(seriesList: Array<TimeSeries>, currentTime: number = 0): TimeSeriesChartData {
+    const maxTime = seriesList.reduce(
+        (tMax, series) => Math.max(tMax, series.last().map(datum => datum.time).getOrElse(-Infinity)),
+        -Infinity
+    )
+    return {
+        seriesNames: new Set(seriesList.map(series => series.name)),
+        maxTime,
+        maxTimes: new Map(seriesList.map(series => [series.name, series.last().map(datum => datum.time).getOrElse(0)])),
+        newPoints: new Map<string, Array<Datum>>(seriesList.map(series => [
+            series.name,
+            [{
+                time: series.last().map(datum => datum.time).getOrElse(0),
+                value: series.last().map(datum => datum.value).getOrElse(0)
+            }]
+        ])),
+        currentTime: currentTime
+    }
+}
+
+/**
+ * Creates random set of time-series data, essentially creating a random walk for each series
+ * @param series The number of time-series for which to generate data (i.e. one for each neuron)
+ * @param numPoints The number of points to generate
+ * @param [updatePeriod=25] The time-interval between the generation of subsequent data points
+ * @return An observable that produces data.
+ */
+function sineDataObservable(
+    series: Array<TimeSeries>,
+    numPoints: number = 10,
+    updatePeriod: number = 25,
+): Observable<TimeSeriesChartData> {
+    const seriesNames = series.map(series => series.name)
+    const initialData = initialChartData(series)
+    return range(0, numPoints).pipe(
+        // convert the number sequence to a time
+        map(sequence => sequence * updatePeriod),
+
+        // create a new (time, value) for each series
+        map(time => {
+            if (time <= initialData.maxTime) {
+                return initialData
+            }
+            return sineData(time, numPoints * updatePeriod, seriesNames, initialData.maxTimes)
+        }),
+    )
+}