stream-charts 1.0.1 → 1.1.0

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

@@ -0,0 +1 @@
+export {};

package/dist/src/app/charts/styling/margins.test.js

@@ -0,0 +1,19 @@
+import { plotDimensionsFrom, containerDimensionsFrom } from "./margins";
+describe('adjusted dimension should correct for margins', () => {
+    const margins = { 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);
+    });
+});
+//# sourceMappingURL=margins.test.js.map

package/dist/src/app/charts/styling/margins.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"margins.test.js","sourceRoot":"","sources":["../../../../../src/app/charts/styling/margins.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAU,uBAAuB,EAAC,MAAM,WAAW,CAAC;AAE9E,QAAQ,CAAC,+CAA+C,EAAE,GAAG,EAAE;IAC3D,MAAM,OAAO,GAAW,EAAC,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAC,CAAC;IACnE,MAAM,KAAK,GAAG,GAAG,CAAC;IAClB,MAAM,MAAM,GAAG,GAAG,CAAC;IACnB,MAAM,UAAU,GAAG,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAE9D,IAAI,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACvE,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,gEAAgE,EAAE,GAAG,EAAE;QACxE,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,yFAAyF,EAAE,GAAG,EAAE;QACjG,MAAM,EAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,eAAe,EAAC,GAAG,uBAAuB,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;QACtI,MAAM,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnC,MAAM,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA"}

package/dist/src/app/charts/styling/svgStyle.d.ts

@@ -0,0 +1,76 @@
+import * as d3 from "d3";
+import { BaseType } from "d3";
+export interface SvgStyle {
+    height?: string | number;
+    width?: string | number;
+    outline?: string;
+    [propName: string]: any;
+}
+export declare const initialSvgStyle: SvgStyle;
+/**
+ * Grabs the client-width of the svg element, or 1 if the svg element hasn't yet
+ * been initialized. The client-width is a read-only property returns the width of
+ * the html element, including horizontal padding and borders, as an integer. The reason
+ * that we return 1 when the svg element hasn't yet been initialized,  is so that the
+ * aspect (width / height) is 1.
+ * @param {SVGElement | null} svg The svg element
+ * @return {number} The client width of the svg
+ */
+export declare function grabWidth(svg: SVGElement | null): number;
+/**
+ * Grabs the client-height of the svg element, or 1 if the svg element hasn't yet
+ * been initialized. The client-height is a read-only property returns the height of
+ * the html element, including vertical padding and borders, as an integer.  The reason
+ * that we return 1 when the svg element hasn't yet been initialized,  is so that the
+ * aspect (width / height) is 1.
+ * @param {SVGElement | null} svg The svg element
+ * @return {number} The client height of the svg
+ */
+export declare function grabHeight(svg: SVGElement | null): number;
+export declare const STROKE_COLOR: string;
+export declare const STROKE_WIDTH: string;
+export declare const STROKE_OPACITY: string;
+export interface SvgStrokeStyle {
+    readonly color: string;
+    readonly width: number;
+    readonly opacity: number;
+}
+export declare function updateSvgStrokeColor(current: SvgStrokeStyle, color: string): {
+    color: string;
+    width: number;
+    opacity: number;
+};
+export declare function updateSvgStrokeWidth(current: SvgStrokeStyle, width: number): {
+    width: number;
+    color: string;
+    opacity: number;
+};
+export declare function updateSvgStrokeOpacity(current: SvgStrokeStyle, opacity: number): {
+    opacity: number;
+    color: string;
+    width: number;
+};
+/**
+ *
+ * @param style
+ * @param selection
+ * @template E The SVG element (e.g. SVGRectElement, SVGLineElement, etc)
+ * @template D The datum type
+ * @template The SVG G element
+ */
+export declare function applyStrokeStylesTo<E extends BaseType, D, G extends BaseType = SVGGElement>(selection: d3.Selection<E, D, G, any>, style: Partial<SvgStrokeStyle>): d3.Selection<E, D, G, any>;
+export interface SvgFillStyle {
+    readonly color: string;
+    readonly opacity: number;
+}
+export declare function updateSvgFillColor(current: SvgFillStyle, color: string): SvgFillStyle;
+export declare function updateSvgFillOpacity(current: SvgFillStyle, opacity: number): SvgFillStyle;
+/**
+ *
+ * @param style
+ * @param selection
+ * @template E The SVG element (e.g. SVGRectElement, SVGLineElement, etc)
+ * @template D The datum type
+ * @template The SVG G element
+ */
+export declare function applyFillStylesTo<E extends BaseType, D, G extends BaseType = SVGGElement>(selection: d3.Selection<E, D, G, any>, style: Partial<SvgFillStyle>): d3.Selection<E, D, G, any>;

package/dist/src/app/charts/styling/svgStyle.js

@@ -0,0 +1,84 @@
+export const initialSvgStyle = {
+    width: '100%',
+    // display: "inline-block",
+    // position: "floating",
+    top: 0,
+    left: 0
+};
+/**
+ * Grabs the client-width of the svg element, or 1 if the svg element hasn't yet
+ * been initialized. The client-width is a read-only property returns the width of
+ * the html element, including horizontal padding and borders, as an integer. The reason
+ * that we return 1 when the svg element hasn't yet been initialized,  is so that the
+ * aspect (width / height) is 1.
+ * @param {SVGElement | null} svg The svg element
+ * @return {number} The client width of the svg
+ */
+export function grabWidth(svg) {
+    return svg !== null ? svg.clientWidth : 1;
+}
+/**
+ * Grabs the client-height of the svg element, or 1 if the svg element hasn't yet
+ * been initialized. The client-height is a read-only property returns the height of
+ * the html element, including vertical padding and borders, as an integer.  The reason
+ * that we return 1 when the svg element hasn't yet been initialized,  is so that the
+ * aspect (width / height) is 1.
+ * @param {SVGElement | null} svg The svg element
+ * @return {number} The client height of the svg
+ */
+export function grabHeight(svg) {
+    return svg !== null ? svg.clientHeight : 1;
+}
+export const STROKE_COLOR = "stroke";
+export const STROKE_WIDTH = "stroke-width";
+export const STROKE_OPACITY = "stroke-opacity";
+export function updateSvgStrokeColor(current, color) {
+    return Object.assign(Object.assign({}, current), { color });
+}
+export function updateSvgStrokeWidth(current, width) {
+    return Object.assign(Object.assign({}, current), { width });
+}
+export function updateSvgStrokeOpacity(current, opacity) {
+    return Object.assign(Object.assign({}, current), { opacity });
+}
+/**
+ *
+ * @param style
+ * @param selection
+ * @template E The SVG element (e.g. SVGRectElement, SVGLineElement, etc)
+ * @template D The datum type
+ * @template The SVG G element
+ */
+export function applyStrokeStylesTo(selection, style) {
+    if (style.color !== undefined)
+        selection.style(STROKE_COLOR, style.color);
+    if (style.width !== undefined)
+        selection.style(STROKE_WIDTH, style.width);
+    if (style.opacity !== undefined)
+        selection.style(STROKE_OPACITY, style.opacity);
+    return selection;
+}
+const FILL_COLOR = "fill";
+const FILL_OPACITY = "fill-opacity";
+export function updateSvgFillColor(current, color) {
+    return Object.assign(Object.assign({}, current), { color });
+}
+export function updateSvgFillOpacity(current, opacity) {
+    return Object.assign(Object.assign({}, current), { opacity });
+}
+/**
+ *
+ * @param style
+ * @param selection
+ * @template E The SVG element (e.g. SVGRectElement, SVGLineElement, etc)
+ * @template D The datum type
+ * @template The SVG G element
+ */
+export function applyFillStylesTo(selection, style) {
+    if (style.color !== undefined)
+        selection.style(FILL_COLOR, style.color);
+    if (style.opacity !== undefined)
+        selection.style(FILL_OPACITY, style.opacity);
+    return selection;
+}
+//# sourceMappingURL=svgStyle.js.map

package/dist/src/app/charts/styling/svgStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"svgStyle.js","sourceRoot":"","sources":["../../../../../src/app/charts/styling/svgStyle.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,eAAe,GAAa;IACrC,KAAK,EAAE,MAAM;IACb,2BAA2B;IAC3B,wBAAwB;IACxB,GAAG,EAAE,CAAC;IACN,IAAI,EAAE,CAAC;CACV,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,GAAsB;IAC5C,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,UAAU,CAAC,GAAsB;IAC7C,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/C,CAAC;AAGD,MAAM,CAAC,MAAM,YAAY,GAAW,QAAQ,CAAA;AAC5C,MAAM,CAAC,MAAM,YAAY,GAAW,cAAc,CAAA;AAClD,MAAM,CAAC,MAAM,cAAc,GAAW,gBAAgB,CAAA;AAQtD,MAAM,UAAU,oBAAoB,CAAC,OAAuB,EAAE,KAAa;IACvE,uCAAW,OAAO,KAAE,KAAK,IAAE;AAC/B,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,OAAuB,EAAE,KAAa;IACvE,uCAAW,OAAO,KAAE,KAAK,IAAE;AAC/B,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,OAAuB,EAAE,OAAe;IAC3E,uCAAW,OAAO,KAAE,OAAO,IAAE;AACjC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAC/B,SAAqC,EACrC,KAA8B;IAE9B,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;QAAE,SAAS,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IACzE,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;QAAE,SAAS,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IACzE,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;QAAE,SAAS,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;IAC/E,OAAO,SAAS,CAAA;AACpB,CAAC;AAED,MAAM,UAAU,GAAW,MAAM,CAAA;AACjC,MAAM,YAAY,GAAW,cAAc,CAAA;AAO3C,MAAM,UAAU,kBAAkB,CAAC,OAAqB,EAAE,KAAa;IACnE,uCAAW,OAAO,KAAE,KAAK,IAAC;AAC9B,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,OAAqB,EAAE,OAAe;IACvE,uCAAW,OAAO,KAAE,OAAO,IAAC;AAChC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC7B,SAAqC,EACrC,KAA4B;IAE5B,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;QAAE,SAAS,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IACvE,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;QAAE,SAAS,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;IAC7E,OAAO,SAAS,CAAA;AACpB,CAAC"}

package/dist/src/app/charts/subscriptions/subscription.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/app/charts/subscriptions/subscription.test.js

@@ -0,0 +1,395 @@
+import { filter, map, scan } from 'rxjs/operators';
+import { range } from 'rxjs';
+import { iteratesObservable as iterateObservable } from '../observables/iterates';
+import { datumOf } from "../series/timeSeries";
+const pointFrom = (x, y) => ({ x, y });
+const emptyPoint = () => ({ x: NaN, y: NaN });
+const isEmptyPoint = (point) => point === undefined || (isNaN(point.x) && isNaN(point.y));
+const nonEmptyPoint = (point) => !isEmptyPoint(point);
+const initialAccumulate = (n = 1) => ({ n, previous: [] });
+/**
+ * Source for {@link Point} data that generates `x`-values from a range of 1 to `numPoints` and
+ * creates the `y`-values by applying the `valueFn` to those `x`-values.
+ * @param numPoints The number of points to generate
+ * @param valueFn The function that maps `x` to `y` (i.e. the value function is `f(x)` in `y = f(x)`)
+ * @return an observable of {@link Point}
+ */
+function pointsObservable(numPoints = 10, valueFn) {
+    return range(1, numPoints).pipe(map(value => pointFrom(value, valueFn(value))));
+}
+/**
+ *
+ * @param n The number of points back from which to calculate the `n-difference`
+ * @param dataObservable Observable that is the source of the underlying data
+ * @param useStartX Whether to use the x-value from the beginning of the interval as the x-value
+ * for the difference (default), or whether to use the last x-value in the interval.
+ */
+function successiveDiffsObservable(n = 1, dataObservable, useStartX = true) {
+    return dataObservable
+        .pipe(scan(({ n, previous, }, current) => {
+        // when we have accumulated enough previous values to cover the "n-difference",
+        // we can calculate an actual difference
+        if (previous.length >= n) {
+            // add the new point, and take the first point from the beginning
+            previous.push(current);
+            const first = previous.shift() || emptyPoint();
+            // calculate the n-difference, using the x-value of the initial point (default)
+            // or the current point (end of current time-range
+            const difference = pointFrom(useStartX ? first.x : current.x, current.y - first.y);
+            return { n, previous, difference };
+        }
+        // not enough points yet, so just accumulate the current point
+        previous.push(current);
+        return { n, previous };
+    }, initialAccumulate(n)), filter(accum => nonEmptyPoint(accum.difference)), map(accum => accum.difference === undefined ? emptyPoint() : accum.difference));
+}
+describe('should be able to calculate successive differences', () => {
+    test('should be able to calc successive-diffs for x^2 where x is in 1..10', done => {
+        let results = [];
+        successiveDiffsObservable(1, pointsObservable(10, x => x * x), true).subscribe(point => results.push(point));
+        done();
+        expect(results).toHaveLength(9);
+        expect(results).toEqual([
+            { x: 1, y: 3 },
+            { x: 2, y: 5 },
+            { x: 3, y: 7 },
+            { x: 4, y: 9 },
+            { x: 5, y: 11 },
+            { x: 6, y: 13 },
+            { x: 7, y: 15 },
+            { x: 8, y: 17 },
+            { x: 9, y: 19 },
+        ]);
+    });
+    test('should be able to calc successive-diffs for x^2 where x is in 1..10 using interval end', done => {
+        let results = [];
+        successiveDiffsObservable(1, pointsObservable(10, x => x * x), false).subscribe(point => results.push(point));
+        done();
+        expect(results).toHaveLength(9);
+        expect(results).toEqual([
+            { x: 2, y: 3 },
+            { x: 3, y: 5 },
+            { x: 4, y: 7 },
+            { x: 5, y: 9 },
+            { x: 6, y: 11 },
+            { x: 7, y: 13 },
+            { x: 8, y: 15 },
+            { x: 9, y: 17 },
+            { x: 10, y: 19 },
+        ]);
+    });
+    test('should be able to calc 3-diffs for x^2 where x is in 1..10', done => {
+        let results = [];
+        successiveDiffsObservable(3, pointsObservable(10, x => x * x), true).subscribe(point => results.push(point));
+        done();
+        expect(results).toHaveLength(7);
+        expect(results).toEqual([
+            { x: 1, y: 15 },
+            { x: 2, y: 21 },
+            { x: 3, y: 27 },
+            { x: 4, y: 33 },
+            { x: 5, y: 39 },
+            { x: 6, y: 45 },
+            { x: 7, y: 51 },
+        ]);
+    });
+    test('should be able to calc 3-diffs for x^2 where x is in 1..10 using interval end', done => {
+        let results = [];
+        successiveDiffsObservable(3, pointsObservable(10, x => x * x), false).subscribe(point => results.push(point));
+        done();
+        expect(results).toHaveLength(7);
+        expect(results).toEqual([
+            { x: 4, y: 15 },
+            { x: 5, y: 21 },
+            { x: 6, y: 27 },
+            { x: 7, y: 33 },
+            { x: 8, y: 39 },
+            { x: 9, y: 45 },
+            { x: 10, y: 51 },
+        ]);
+    });
+});
+/**
+ * Observable that converts data points into iterates for poincare plots where one plots x(j+n) vs x(j)
+ * @param n The n-th iterate for plotting x(j+n) vs x(j)
+ * @param dataObservable The observable with the point data
+ * @return an observable of a stream of {@link Point}s
+ */
+function iteratesObservable(n = 1, dataObservable) {
+    return dataObservable
+        .pipe(scan(({ n, previous, }, current) => {
+        // when we have accumulated enough previous values to cover the "n-iterate",
+        // we can grab the y-value from the n-th point back
+        if (previous.length >= n) {
+            // add the new point, and take the first point from the beginning
+            previous.push(pointFrom(previous[previous.length - 1].y, current.y));
+            const first = previous.shift() || emptyPoint();
+            // calculate the n-difference, using the x-value of the initial point (default)
+            // or the current point (end of current time-range
+            const iterate = pointFrom(first.y, current.y);
+            return { n, previous, difference: iterate };
+        }
+        // not enough points yet, so just accumulate the current point
+        previous.push(current);
+        return { n, previous };
+    }, initialAccumulate(n)), filter(accum => nonEmptyPoint(accum.difference)), map(accum => accum.difference === undefined ? emptyPoint() : accum.difference));
+}
+function tentFn(x, mu = 1) {
+    return x < 0.5 ? mu * x : mu * (1 - x);
+}
+describe('should be able to calculate iterates', () => {
+    test('should be able to calc 1-iterates for x^2 where x is in 1..10', done => {
+        let results = [];
+        iteratesObservable(1, pointsObservable(10, x => 2 * x)).subscribe(point => results.push(point));
+        done();
+        expect(results).toHaveLength(9);
+        expect(results).toEqual([
+            { x: 2, y: 4 },
+            { x: 4, y: 6 },
+            { x: 6, y: 8 },
+            { x: 8, y: 10 },
+            { x: 10, y: 12 },
+            { x: 12, y: 14 },
+            { x: 14, y: 16 },
+            { x: 16, y: 18 },
+            { x: 18, y: 20 }
+        ]);
+    });
+    test('should be able to calc 3-iterates for x^2 where x is in 1..10', done => {
+        let results = [];
+        iteratesObservable(3, pointsObservable(10, x => 2 * x)).subscribe(point => results.push(point));
+        done();
+        expect(results).toHaveLength(7);
+        expect(results).toEqual([
+            { x: 2, y: 8 },
+            { x: 4, y: 10 },
+            { x: 6, y: 12 },
+            { x: 8, y: 14 },
+            { x: 10, y: 16 },
+            { x: 12, y: 18 },
+            { x: 14, y: 20 }
+        ]);
+    });
+    test('tent map should converge to (0, 0) for mu < 1', done => {
+        const numPoints = 100000;
+        let lastPoint = emptyPoint();
+        iteratesObservable(1, range(0, numPoints).pipe(map(x => pointFrom(x, tentFn(x / numPoints, 0.15)))))
+            .subscribe(point => lastPoint = point);
+        done();
+        expect(lastPoint.y).toBeLessThan(1e-5);
+        expect(lastPoint.x).toBeLessThan(1e-5);
+    });
+});
+describe('when calculating tent-map iterates with one new data point for each event', () => {
+    test('should be able to calc 1-iterates for tent-map chart data, when 1 point is added at a time', done => {
+        const numPoints = 10;
+        let results = [];
+        iterateObservable(range(0, numPoints).pipe(map(x => ({
+            maxTime: x,
+            maxTimes: new Map([['test1', x]]),
+            newPoints: new Map([['test1', [datumOf(x, tentFn(x / numPoints, 0.15))]]])
+        })))).subscribe(point => results.push(point));
+        done();
+        expect(results).toHaveLength(9);
+        //
+        // check the first iterate datum
+        expect(results[0].minIterate.iterateN).toEqual(0);
+        expect(results[0].minIterate.iterateN_1).toEqual(0.015);
+        expect(results[0].maxIterate.iterateN).toEqual(0);
+        expect(results[0].maxIterate.iterateN_1).toEqual(0.015);
+        expect(results[0].minIterates.has("test1")).toBe(true);
+        expect(results[0].minIterates.size).toEqual(1);
+        expect(results[0].minIterates.get("test1").time).toEqual(0);
+        expect(results[0].minIterates.get("test1").iterateN).toEqual(0);
+        expect(results[0].minIterates.get("test1").iterateN_1).toEqual(0.015);
+        expect(results[0].maxIterates.has("test1")).toBe(true);
+        expect(results[0].maxIterates.size).toEqual(1);
+        expect(results[0].maxIterates.get("test1").time).toEqual(0);
+        expect(results[0].maxIterates.get("test1").iterateN).toBeCloseTo(0, 4);
+        expect(results[0].maxIterates.get("test1").iterateN_1).toBeCloseTo(0.015, 4);
+        // check that the accumulator "newPoints" holds the previous "newPoints" for the iterate
+        expect(results[0].newPoints.has("test1")).toBe(true);
+        expect(results[0].newPoints.get("test1")).toHaveLength(1);
+        expect(results[0].newPoints.get("test1")[0].time).toEqual(0);
+        expect(results[0].newPoints.get("test1")[0].iterateN).toEqual(0);
+        expect(results[0].newPoints.get("test1")[0].iterateN_1).toBeCloseTo(0.015, 4);
+        //
+        // check the last iterate datum
+        expect(results[8].minIterate.time).toEqual(8);
+        expect(results[8].minIterate.iterateN).toEqual(0);
+        expect(results[8].minIterate.iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[8].maxIterate.time).toEqual(5);
+        expect(results[8].maxIterate.iterateN).toBeCloseTo(0.075, 4);
+        expect(results[8].maxIterate.iterateN_1).toBeCloseTo(0.075, 4);
+        expect(results[8].minIterates.has("test1")).toBe(true);
+        expect(results[8].minIterates.size).toEqual(1);
+        expect(results[8].minIterates.get("test1").time).toEqual(8);
+        expect(results[8].minIterates.get("test1").iterateN).toEqual(0);
+        expect(results[8].minIterates.get("test1").iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[8].maxIterates.has("test1")).toBe(true);
+        expect(results[8].maxIterates.size).toEqual(1);
+        expect(results[8].maxIterates.get("test1").time).toEqual(5);
+        expect(results[8].maxIterates.get("test1").iterateN).toBeCloseTo(0.075, 4);
+        expect(results[8].maxIterates.get("test1").iterateN_1).toBeCloseTo(0.075, 4);
+        // check that the accumulator "newPoints" holds the previous "newPoints" for the iterate
+        expect(results[8].newPoints.has("test1")).toBe(true);
+        expect(results[8].newPoints.get("test1")).toHaveLength(1);
+        expect(results[8].newPoints.get("test1")[0].time).toEqual(8);
+        expect(results[8].newPoints.get("test1")[0].iterateN).toBeCloseTo(0.03, 4);
+        expect(results[8].newPoints.get("test1")[0].iterateN_1).toBeCloseTo(0.015, 4);
+    });
+});
+describe('when calculating tent-map 1-iterates with two new data points for each event', () => {
+    test('should be able to calc iterates for tent-map chart data, when 2 points are added at a time', done => {
+        const numPoints = 5;
+        let results = [];
+        iterateObservable(range(0, numPoints)
+            .pipe(map(x => ({
+            maxTime: 2 * x,
+            maxTimes: new Map([['test1', 2 * x]]),
+            newPoints: new Map([
+                ['test1', [datumOf(2 * x, tentFn(2 * x / (2 * numPoints), 0.15)), datumOf(2 * x + 1, tentFn((2 * x + 1) / (2 * numPoints), 0.15))]],
+            ])
+        }))))
+            .subscribe(result => results.push(result));
+        done();
+        expect(results).toHaveLength(5);
+        expect(results.reduce((count, result) => result.newPoints.get("test1").length + count, 0)).toEqual(9);
+        //
+        // check the first iterate datum
+        expect(results[0].minIterate.iterateN).toBeCloseTo(0, 4);
+        expect(results[0].minIterate.iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[0].maxIterate.iterateN).toBeCloseTo(0, 4);
+        expect(results[0].maxIterate.iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[0].minIterates.has("test1")).toBe(true);
+        expect(results[0].minIterates.size).toEqual(1);
+        expect(results[0].minIterates.get("test1").time).toBeCloseTo(0, 4);
+        expect(results[0].minIterates.get("test1").iterateN).toBeCloseTo(0, 4);
+        expect(results[0].minIterates.get("test1").iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[0].maxIterates.has("test1")).toBe(true);
+        expect(results[0].maxIterates.size).toEqual(1);
+        expect(results[0].maxIterates.get("test1").time).toEqual(0);
+        expect(results[0].maxIterates.get("test1").iterateN).toBeCloseTo(0, 4);
+        expect(results[0].maxIterates.get("test1").iterateN_1).toBeCloseTo(0.015, 4);
+        // check that the accumulator "newPoints" holds the previous "newPoints" for the iterate
+        expect(results[0].newPoints.has("test1")).toBe(true);
+        expect(results[0].newPoints.get("test1")).toHaveLength(1);
+        expect(results[0].newPoints.get("test1")[0].time).toEqual(0);
+        expect(results[0].newPoints.get("test1")[0].iterateN).toEqual(0);
+        expect(results[0].newPoints.get("test1")[0].iterateN_1).toBeCloseTo(0.015, 4);
+        //
+        // check the last iterate datum
+        expect(results[4].minIterate.time).toEqual(8);
+        expect(results[4].minIterate.iterateN).toEqual(0);
+        expect(results[4].minIterate.iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[4].maxIterate.time).toEqual(5);
+        expect(results[4].maxIterate.iterateN).toBeCloseTo(0.075, 4);
+        expect(results[4].maxIterate.iterateN_1).toBeCloseTo(0.075, 4);
+        expect(results[4].minIterates.size).toEqual(1);
+        expect(results[4].minIterates.has("test1")).toBe(true);
+        expect(results[4].minIterates.get("test1").time).toEqual(8);
+        expect(results[4].minIterates.get("test1").iterateN).toEqual(0);
+        expect(results[4].minIterates.get("test1").iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[4].maxIterates.size).toEqual(1);
+        expect(results[4].maxIterates.has("test1")).toBe(true);
+        expect(results[4].maxIterates.get("test1").time).toEqual(5);
+        expect(results[4].maxIterates.get("test1").iterateN).toBeCloseTo(0.075, 4);
+        expect(results[4].maxIterates.get("test1").iterateN_1).toBeCloseTo(0.075, 4);
+        // check that the accumulator "newPoints" holds the previous "newPoints" for the iterate
+        expect(results[4].newPoints.has("test1")).toBe(true);
+        expect(results[4].newPoints.get("test1")).toHaveLength(2);
+        expect(results[4].newPoints.get("test1")[1].time).toEqual(8);
+        expect(results[4].newPoints.get("test1")[1].iterateN).toBeCloseTo(0.03, 4);
+        expect(results[4].newPoints.get("test1")[1].iterateN_1).toBeCloseTo(0.015, 4);
+    });
+    test('should be able to calc iterates for tent-map chart data, when 2 points are added at a time, with 2 series', done => {
+        const numPoints = 5;
+        let results = [];
+        iterateObservable(range(0, numPoints)
+            .pipe(map(x => ({
+            maxTime: 2 * x,
+            maxTimes: new Map([['test1', 2 * x]]),
+            newPoints: new Map([
+                ['test1', [datumOf(2 * x, tentFn(2 * x / (2 * numPoints), 0.15)), datumOf(2 * x + 1, tentFn((2 * x + 1) / (2 * numPoints), 0.15))]],
+                ['test2', [datumOf(2 * x, tentFn(2 * x / (2 * numPoints), 0.35)), datumOf(2 * x + 1, tentFn((2 * x + 1) / (2 * numPoints), 0.35))]],
+            ])
+        }))))
+            .subscribe(result => results.push(result));
+        done();
+        expect(results).toHaveLength(5);
+        expect(results.reduce((count, result) => result.newPoints.get("test1").length + count, 0)).toEqual(9);
+        //
+        // check the first iterate datum
+        expect(results[0].minIterate.iterateN).toBeCloseTo(0, 4);
+        expect(results[0].minIterate.iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[0].maxIterate.iterateN).toBeCloseTo(0, 4);
+        expect(results[0].maxIterate.iterateN_1).toBeCloseTo(0.035, 4);
+        expect(results[0].minIterates.size).toEqual(2);
+        expect(results[0].minIterates.has("test1")).toBe(true);
+        expect(results[0].minIterates.get("test1").time).toBeCloseTo(0, 4);
+        expect(results[0].minIterates.get("test1").iterateN).toBeCloseTo(0, 4);
+        expect(results[0].minIterates.get("test1").iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[0].minIterates.has("test2")).toBe(true);
+        expect(results[0].minIterates.get("test2").time).toBeCloseTo(0, 4);
+        expect(results[0].minIterates.get("test2").iterateN).toBeCloseTo(0, 4);
+        expect(results[0].minIterates.get("test2").iterateN_1).toBeCloseTo(0.035, 4);
+        expect(results[0].maxIterates.size).toEqual(2);
+        expect(results[0].maxIterates.has("test1")).toBe(true);
+        expect(results[0].maxIterates.get("test1").time).toEqual(0);
+        expect(results[0].maxIterates.get("test1").iterateN).toBeCloseTo(0, 4);
+        expect(results[0].maxIterates.get("test1").iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[0].maxIterates.has("test2")).toBe(true);
+        expect(results[0].maxIterates.get("test2").time).toEqual(0);
+        expect(results[0].maxIterates.get("test2").iterateN).toBeCloseTo(0, 4);
+        expect(results[0].maxIterates.get("test2").iterateN_1).toBeCloseTo(0.035, 4);
+        // check that the accumulator "newPoints" holds the previous "newPoints" for the iterate
+        expect(results[0].newPoints.has("test1")).toBe(true);
+        expect(results[0].newPoints.get("test1")).toHaveLength(1);
+        expect(results[0].newPoints.get("test1")[0].time).toEqual(0);
+        expect(results[0].newPoints.get("test1")[0].iterateN).toEqual(0);
+        expect(results[0].newPoints.get("test1")[0].iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[0].newPoints.has("test2")).toBe(true);
+        expect(results[0].newPoints.get("test2")).toHaveLength(1);
+        expect(results[0].newPoints.get("test2")[0].time).toEqual(0);
+        expect(results[0].newPoints.get("test2")[0].iterateN).toEqual(0);
+        expect(results[0].newPoints.get("test2")[0].iterateN_1).toBeCloseTo(0.035, 4);
+        //
+        // check the last iterate datum
+        expect(results[4].minIterate.time).toEqual(8);
+        expect(results[4].minIterate.iterateN).toEqual(0);
+        expect(results[4].minIterate.iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[4].maxIterate.time).toEqual(5);
+        expect(results[4].maxIterate.iterateN).toBeCloseTo(0.175, 4);
+        expect(results[4].maxIterate.iterateN_1).toBeCloseTo(0.175, 4);
+        expect(results[4].minIterates.size).toEqual(2);
+        expect(results[4].minIterates.has("test1")).toBe(true);
+        expect(results[4].minIterates.get("test1").time).toEqual(8);
+        expect(results[4].minIterates.get("test1").iterateN).toEqual(0);
+        expect(results[4].minIterates.get("test1").iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[4].minIterates.has("test2")).toBe(true);
+        expect(results[4].minIterates.get("test2").time).toEqual(8);
+        expect(results[4].minIterates.get("test2").iterateN).toEqual(0);
+        expect(results[4].minIterates.get("test2").iterateN_1).toBeCloseTo(0.035, 4);
+        expect(results[4].maxIterates.size).toEqual(2);
+        expect(results[4].maxIterates.has("test1")).toBe(true);
+        expect(results[4].maxIterates.get("test1").time).toEqual(5);
+        expect(results[4].maxIterates.get("test1").iterateN).toBeCloseTo(0.075, 4);
+        expect(results[4].maxIterates.get("test1").iterateN_1).toBeCloseTo(0.075, 4);
+        expect(results[4].maxIterates.has("test2")).toBe(true);
+        expect(results[4].maxIterates.get("test2").time).toEqual(5);
+        expect(results[4].maxIterates.get("test2").iterateN).toBeCloseTo(0.175, 4);
+        expect(results[4].maxIterates.get("test2").iterateN_1).toBeCloseTo(0.175, 4);
+        // check that the accumulator "newPoints" holds the previous "newPoints" for the iterate
+        expect(results[4].newPoints.has("test1")).toBe(true);
+        expect(results[4].newPoints.get("test1")).toHaveLength(2);
+        expect(results[4].newPoints.get("test1")[1].time).toEqual(8);
+        expect(results[4].newPoints.get("test1")[1].iterateN).toBeCloseTo(0.03, 4);
+        expect(results[4].newPoints.get("test1")[1].iterateN_1).toBeCloseTo(0.015, 4);
+        expect(results[4].newPoints.has("test2")).toBe(true);
+        expect(results[4].newPoints.get("test2")).toHaveLength(2);
+        expect(results[4].newPoints.get("test2")[1].time).toEqual(8);
+        expect(results[4].newPoints.get("test2")[1].iterateN).toBeCloseTo(0.07, 4);
+        expect(results[4].newPoints.get("test2")[1].iterateN_1).toBeCloseTo(0.035, 4);
+    });
+});
+//# sourceMappingURL=subscription.test.js.map