stream-charts 1.2.1 → 2.0.0

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

@@ -1,201 +0,0 @@
-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/ordinals.test.ts

@@ -1,135 +0,0 @@
-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)
-        }),
-    )
-}

package/src/app/charts/series/datumSeries.test.ts

@@ -1,60 +0,0 @@
-import {emptySeries, seriesFrom} from "./baseSeries";
-
-describe('should be able to create an empty series', () => {
-    test('an empty series should be empty', () => {
-        expect(emptySeries('test1').isEmpty());
-    });
-
-    test('an empty series should not have a last element', () => {
-        expect(emptySeries('test1').last().failed);
-    });
-
-    test('an empty series should have 0 length', () => {
-        expect(emptySeries('test1').length()).toBe(0);
-    });
-
-    test('an empty series should not have any data', () => {
-        expect(emptySeries('test1').data.length).toBe(0);
-    });
-
-    test('an empty series should have the specified name', () => {
-        expect(emptySeries('test1').name).toBe('test1');
-    });
-});
-
-describe('should be able to create a series from data', () => {
-    const data = [
-        {time: 1, value: 10},
-        {time: 2, value: 20},
-        {time: 3, value: 30},
-        {time: 4, value: 40},
-        {time: 5, value: 50},
-        {time: 6, value: 60},
-        {time: 7, value: 70},
-        {time: 8, value: 80},
-        {time: 9, value: 90},
-        {time: 10, value: 100},
-    ];
-    const series = seriesFrom('test2', data);
-
-    test('series should not be empty', () => {
-        expect(!series.isEmpty())
-    });
-
-    test('series name should be test2', () => {
-        expect(series.name).toEqual('test2')
-    });
-
-    test('series should have 10 points', () => {
-        expect(series.length()).toBe(10);
-    });
-
-    test('last value in series should be (10, 100)', () => {
-        const lastElement = series.last().getOrElse({time: NaN, value: NaN});
-        expect(lastElement).toEqual({time: 10, value: 100});
-    });
-
-    test('series data should equal original data', () => {
-        expect(series.data).toEqual(data);
-    });
-});

package/src/app/charts/styling/margins.test.ts

@@ -1,22 +0,0 @@
-import {plotDimensionsFrom, Margin, containerDimensionsFrom} from "./margins";
-
-describe('adjusted dimension should correct for margins', () => {
-    const margins: Margin = {top: 11, bottom: 12, left: 13, right: 14};
-    const width = 100;
-    const height = 200;
-    const dimensions = plotDimensionsFrom(width, height, margins);
-
-    test('adjusted width should have the left and right margins removed', () => {
-        expect(dimensions.width).toBe(width - margins.right - margins.left);
-    });
-
-    test('adjusted height should have the top and bottom margins removed', () => {
-        expect(dimensions.height).toBe(height - margins.top - margins.bottom);
-    });
-
-    test('should be able to get back the container dimensions after calculate the plot dimensions', () => {
-        const {width: containerWidth, height: containerHeight} = containerDimensionsFrom(plotDimensionsFrom(width, height, margins), margins);
-        expect(containerWidth).toBe(width);
-        expect(containerHeight).toBe(height);
-    })
-})