scichart 2.0.2228 → 2.1.2273

package/types/TSciChart.d.ts

@@ -7,8 +7,11 @@ export declare type TSciChart = {
     SCRTFillTextureAbgr: (texture: TSRTexture, width: number, height: number, pixels: IntVector) => void;
     SCRTFillTextureFloat32: (texture: TSRTexture, width: number, height: number, pixels: FloatVector) => TSRVector4;
     SCRTSetActiveTexture: (texture: TSRTexture) => void;
-    SCRTSetActiveDoubleVector: (SCRTSetActiveDoubleVector: DoubleVector, doubleVector: number) => void;
+    SCRTSetActiveDoubleVector: (SCRTSetActiveDoubleVector: SCRTDoubleVector, doubleVector: number) => void;
     SCRTCreatePalette: (colors: IntVector) => SCRTPalette;
+    SCRTFillVectorSequential: (SCRTFillVectorSequential: SCRTDoubleVector, count: number) => void;
+    SCRTMemMove: (destPtr: number, sourcePtr: number, count: number) => void;
+    SCRTMemCopy: (destPtr: number, sourcePtr: number, count: number) => void;
     SCRTInitEngine2D: () => void;
     SCRTShutdownEngine2D: () => void;
     TSRSetMainWindowSize: (width: number, height: number) => void;
@@ -21,28 +24,49 @@ export declare type TSciChart = {
     SCRTGetScreenWidth: () => number;
     SCRTGetScreenHeight: () => number;
     SCRTSetWaterMarkProperties: (properties: SCRTWaterMarkProperties) => void;
-    SCRTSplineHelperCubicSpline: (xValues: DoubleVector, yValues: DoubleVector, xsValues: DoubleVector, ysValues: DoubleVector, initialSize: number, interpolationPoints: number, containsNAN: boolean) => void;
-    SCRTAnimationHelperWave: (yValues: DoubleVector, durationFraction: number, zeroLine: number, progress: number, ysValues: DoubleVector) => number;
-    SCRTAnimationHelperSweep: (yValues: DoubleVector, progress: number, ysValues: DoubleVector) => number;
-    SCRTAnimationHelperScale: (yValues: DoubleVector, zeroLine: number, progress: number, ysValues: DoubleVector) => number;
-    SCRTAnimationHelperFade: (yValues: DoubleVector, progress: number, ysValues: DoubleVector) => number;
+    SCRTSplineHelperCubicSpline: (xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xsValues: SCRTDoubleVector, ysValues: SCRTDoubleVector, initialSize: number, interpolationPoints: number, containsNAN: boolean) => void;
+    SCRTAnimationHelperWave: (yValues: SCRTDoubleVector, durationFraction: number, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number;
+    SCRTAnimationHelperSweep: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number;
+    SCRTAnimationHelperScale: (yValues: SCRTDoubleVector, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number;
+    SCRTAnimationHelperFade: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number;
     SCRTSetGlobalSampleChartInterface: (param0: SCRTSampleChartInterface) => void;
     SCRTGetGlobalSampleChartInterface: () => SCRTSampleChartInterface;
     SCRTSetGlobalCopyToDestinationInterface: (param0: SCRTCopyToDestinationInterface) => void;
     SCRTSetClearAlphaParams: (enabled: boolean, alpha: number) => void;
+    SCRTDoubleVector: new () => SCRTDoubleVector;
+    DoubleVector: new () => DoubleVector;
+    IntVector: new () => IntVector;
+    UIntVector: new () => UIntVector;
     eTSRTextureFormat: {
         TSR_TEXTUREFORMAT_A8B8G8R8: eTSRTextureFormat;
         TSR_TEXTUREFORMAT_R32F: eTSRTextureFormat;
     };
-    IntVector: new () => IntVector;
-    UIntVector: new () => UIntVector;
+    ResamplingMode: {
+        None: ResamplingMode;
+        MinMax: ResamplingMode;
+        Min: ResamplingMode;
+        Max: ResamplingMode;
+        Mid: ResamplingMode;
+        MinOrMax: ResamplingMode;
+        Auto: ResamplingMode;
+    };
+    ResamplingData: {
+        LinearData: ResamplingData;
+        CategoryData: ResamplingData;
+        UnevenlySpacedData: ResamplingData;
+        UnsortedData: ResamplingData;
+    };
+    SCRTDoubleResamplerMergeIndicesParams: new () => SCRTDoubleResamplerMergeIndicesParams;
+    SCRTXvaluesProvider: new () => SCRTXvaluesProvider;
     TSRVector4: (new () => TSRVector4) & (new (x: number, y: number, z: number, w: number) => TSRVector4);
     FloatVector: new () => FloatVector;
-    DoubleVector: new () => DoubleVector;
     SCRTPalette: (new () => SCRTPalette) & {
         GetNoOverrideColorCode: () => number;
     };
     SCRTDoubleArrayOperations: new () => SCRTDoubleArrayOperations;
+    ResamplingArgs: new () => ResamplingArgs;
+    SCRTDoubleArraysXyResampleOutput: new () => SCRTDoubleArraysXyResampleOutput;
+    SCRTDoubleResampler: new () => SCRTDoubleResampler;
     StringVector: new () => StringVector;
     LinearCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => LinearCoordinateCalculatorDouble;
     FlippedLinearCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => FlippedLinearCoordinateCalculatorDouble;
@@ -132,9 +156,9 @@ export declare type TSciChart = {
         IsDivisibleBy: (value: number, divisor: number) => boolean;
         Constrain: (value: number, lowerBound: number, upperBound: number) => number;
         RoundToDigits: (value: number, decimals: number) => number;
-        MinMax: (inputValues: DoubleVector) => DoubleRange;
-        MinMaxWithIndex: (inputValues: DoubleVector, startIndex: number, count: number) => DoubleRange;
-        FindIndex: (inputValues: DoubleVector, value: number, searchMode: SCRTFindIndexSearchMode, dataIsSortedAscending: boolean) => number;
+        MinMax: (inputValues: SCRTDoubleVector) => DoubleRange;
+        MinMaxWithIndex: (inputValues: SCRTDoubleVector, startIndex: number, count: number) => DoubleRange;
+        FindIndex: (inputValues: SCRTDoubleVector, value: number, searchMode: SCRTFindIndexSearchMode, dataIsSortedAscending: boolean) => number;
         LinearInterpolateI: (from: number, to: number, ratio: number) => number;
     };
     NiceDoubleScale: {
@@ -228,12 +252,24 @@ export declare type TSciChart = {
     };
     TSRCamera: new () => TSRCamera;
 };
-export declare class TSRTexture {
+export declare class SCRTDoubleVector {
+    push_back(_dNewValue: number): void;
+    resize(_iNewSize: number, _dInitialValue: number): void;
+    resizeFast(_iNewSize: number): void;
+    reserve(_iCount: number): void;
+    clear(): void;
+    size(): number;
+    capacity(): number;
+    get(_iIndex: number): number;
+    set(_iIndex: number, _dValue: number): void;
+    insertAt(_iIndex: number, _dValue: number): void;
+    removeAt(_iIndex: number): void;
+    removeRange(_iIndex: number, _iCount: number): void;
+    dataPtr(_iOffset: number): number;
     delete(): void;
 }
-export declare class eTSRTextureFormat {
-}
-export declare class IntVector {
+export declare class DoubleVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -248,7 +284,8 @@ export declare class IntVector {
     set(index: number, element: number): void;
     get(index: number): number;
 }
-export declare class UIntVector {
+export declare class IntVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -263,14 +300,8 @@ export declare class UIntVector {
     set(index: number, element: number): void;
     get(index: number): number;
 }
-export declare class TSRVector4 {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-    delete(): void;
-}
-export declare class FloatVector {
+export declare class UIntVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -285,7 +316,44 @@ export declare class FloatVector {
     set(index: number, element: number): void;
     get(index: number): number;
 }
-export declare class DoubleVector {
+export declare class TSRTexture {
+    delete(): void;
+}
+export declare class eTSRTextureFormat {
+}
+export declare class ResamplingMode {
+}
+export declare class ResamplingData {
+}
+/**
+ *WebAssembly / Native params for MergeIndices method
+ */
+export declare class SCRTDoubleResamplerMergeIndicesParams {
+    SetXInput(xInput: SCRTXvaluesProvider): void;
+    SetYInput(yInput: SCRTDoubleVector): void;
+    SetY1Input(y1Input: SCRTDoubleVector): void;
+    SetIndices(indices: IntVector): void;
+    SetXOut(xOut: SCRTDoubleVector): void;
+    SetYOut(yOut: SCRTDoubleVector): void;
+    SetY1Out(y1Out: SCRTDoubleVector): void;
+    SetY1Offset(y1Offset: number): void;
+    count: number;
+    isCategoryData: boolean;
+    delete(): void;
+}
+export declare class SCRTXvaluesProvider {
+    SetInput(input: SCRTDoubleVector): void;
+    delete(): void;
+}
+export declare class TSRVector4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    delete(): void;
+}
+export declare class FloatVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -314,14 +382,42 @@ export declare class SCRTDoubleArrayOperationIndexedResult {
     delete(): void;
 }
 export declare class SCRTDoubleArrayOperations {
-    CalculateMin(input: DoubleVector, startIndex: number, endIndex: number): number;
-    CalculateMinIndexed(input: DoubleVector, startIndex: number, endIndex: number): SCRTDoubleArrayOperationIndexedResult;
+    CalculateMin(input: SCRTDoubleVector, startIndex: number, endIndex: number): number;
+    CalculateMinIndexed(input: SCRTDoubleVector, startIndex: number, endIndex: number): SCRTDoubleArrayOperationIndexedResult;
+    delete(): void;
+}
+export declare class ResamplingArgs {
+    Reset(): void;
+    Resampling: ResamplingMode;
+    Data: ResamplingData;
+    StartIndex: number;
+    EndIndex: number;
+    ViewportWidth: number;
+    ResamplingPrecision: number;
+    MinXInclusive: number;
+    MaxXInclusive: number;
+    IsFifo: boolean;
+    FifoCapacity: number;
+    InputBaseIndex: number;
+    HasNaN: boolean;
+    ZeroLineY: number;
+    NewDataPointCount: number;
+    delete(): void;
+}
+export declare class SCRTDoubleArraysXyResampleOutput {
+    Reset(xOut: SCRTDoubleVector, yOut: SCRTDoubleVector): void;
     delete(): void;
 }
 export declare class SCRTDoubleResampler {
+    UpdateIndices(indices: IntVector, xInput: SCRTXvaluesProvider, yInput: SCRTDoubleVector, resamplingMode: ResamplingMode, resamplingArgs: ResamplingArgs): number;
+    Execute(xInput: SCRTXvaluesProvider, yInput: SCRTDoubleVector, out: SCRTDoubleArraysXyResampleOutput, indicesOut: IntVector, resamplingMode: ResamplingMode, resamplingArgs: ResamplingArgs): void;
+    RequiresReduction(resamplingArgs: ResamplingArgs): boolean;
+    MergeIndices(indices: IntVector, size1: number, size2: number, mergedIndicesOut: IntVector): number;
+    CopyValuesByIndices(params: SCRTDoubleResamplerMergeIndicesParams): void;
     delete(): void;
 }
 export declare class StringVector {
+    dataPtr(offset: number): number;
     push_back(element: string): void;
     pop_back(): void;
     size(): number;
@@ -342,6 +438,7 @@ export declare class StringVector {
 export declare class CoordinateCalculator {
     GetCoordinate(dataValue: number): number;
     GetDataValue(coordinate: number): number;
+    CanSupportMatrices(): boolean;
     delete(): void;
 }
 /**
@@ -372,16 +469,16 @@ export declare class FlippedLinearCoordinateCalculatorSingle extends CoordinateC
  *WebAssembly / Native Catetory Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Uses index not data-value for conversion
  */
 export declare class CategoryCoordinateCalculatorDouble extends CoordinateCalculator {
-    TransformDataToIndex(dataValue: number, baseXValues: DoubleVector): number;
-    TransformIndexToData(index: number, baseXValues: DoubleVector): number;
+    TransformDataToIndex(dataValue: number, baseXValues: SCRTDoubleVector): number;
+    TransformIndexToData(index: number, baseXValues: SCRTDoubleVector): number;
     delete(): void;
 }
 /**
  *WebAssembly / Native Catetory Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Uses index not data-value for conversion. Inverse of CategoryCoordinateCalculatorDouble
  */
 export declare class FlippedCategoryCoordinateCalculatorDouble extends CoordinateCalculator {
-    TransformDataToIndex(dataValue: number, baseXValues: DoubleVector): number;
-    TransformIndexToData(index: number, baseXValues: DoubleVector): number;
+    TransformDataToIndex(dataValue: number, baseXValues: SCRTDoubleVector): number;
+    TransformIndexToData(index: number, baseXValues: SCRTDoubleVector): number;
     delete(): void;
 }
 /**
@@ -404,7 +501,9 @@ export declare class SCRTLineGapMode {
 export declare class SCRTLineDrawingParams {
     SetLinesPen(linesPen: SCRTPen): void;
     SetPalettedColors(colorValues: IntVector): void;
+    Reset(): void;
     count: number;
+    containsNaN: boolean;
     verticalChart: boolean;
     forceShaderMethod: boolean;
     isDigitalLine: boolean;
@@ -425,7 +524,7 @@ export declare class SCRTPen {
  */
 export declare class SCRTLineSeriesDrawingProvider {
     DrawLines(nativeContext: SCRTRenderContext, xValues: number, yValues: number, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTLineDrawingParams): void;
-    DrawLinesVec(nativeContext: SCRTRenderContext, xValues: DoubleVector, yValues: DoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTLineDrawingParams): void;
+    DrawLinesVec(nativeContext: SCRTRenderContext, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTLineDrawingParams): void;
     delete(): void;
 }
 /**
@@ -465,6 +564,7 @@ export declare class SCRTPointDrawingParams {
     SetSpriteTexture(pointTexture: TSRTexture): void;
     SetStrokeMask(strokeMask: TSRTexture): void;
     SetPalettedColors(palettedColors: IntVector): void;
+    Reset(): void;
     count: number;
     verticalChart: boolean;
     forceShaderMethod: boolean;
@@ -476,7 +576,7 @@ export declare class SCRTPointDrawingParams {
  */
 export declare class SCRTScatterSeriesDrawingProvider {
     DrawPoints(nativeContext: SCRTRenderContext, xValues: number, yValues: number, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTPointDrawingParams): void;
-    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: DoubleVector, yValues: DoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTPointDrawingParams): void;
+    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTPointDrawingParams): void;
     delete(): void;
 }
 /**
@@ -509,7 +609,7 @@ export declare class SCRTBrush {
  *WebAssembly / Native Candlestick drawing provider, which draws batched / fast candles using our WebGL2 Rendering Engine
  */
 export declare class SCRTCandlestickSeriesDrawingProvider {
-    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: DoubleVector, openValues: DoubleVector, highValues: DoubleVector, lowValues: DoubleVector, closeValues: DoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTOhlcDrawingParams): void;
+    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: SCRTDoubleVector, openValues: SCRTDoubleVector, highValues: SCRTDoubleVector, lowValues: SCRTDoubleVector, closeValues: SCRTDoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTOhlcDrawingParams): void;
     delete(): void;
 }
 /**
@@ -532,7 +632,7 @@ export declare class SCRTMountainDrawingParams {
  *WebAssembly / Native Mountain/Area drawing provider, which draws batched / fast areas using our WebGL2 Rendering Engine
  */
 export declare class SCRTMountainSeriesDrawingProvider {
-    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: DoubleVector, yValues: DoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTMountainDrawingParams): void;
+    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTMountainDrawingParams): void;
     delete(): void;
 }
 /**
@@ -556,7 +656,7 @@ export declare class SCRTBandDrawingParams {
  *WebAssembly / Native Band polygon drawing provider, which draws batched / fast bands using our WebGL2 Rendering Engine
  */
 export declare class SCRTBandSeriesDrawingProvider {
-    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: DoubleVector, yValues: DoubleVector, y1Values: DoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTBandDrawingParams): void;
+    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, y1Values: SCRTDoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTBandDrawingParams): void;
     delete(): void;
 }
 /**
@@ -579,7 +679,7 @@ export declare class SCRTColumnDrawingParams {
  *WebAssembly / Native Stacked Columns drawing provider, which draws batched / fast stacked columns using our WebGL2 Rendering Engine
  */
 export declare class SCRTStackedColumnSeriesDrawingProvider {
-    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: DoubleVector, topValues: DoubleVector, bottomValues: DoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTStackedColumnDrawingParams): void;
+    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: SCRTDoubleVector, topValues: SCRTDoubleVector, bottomValues: SCRTDoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTStackedColumnDrawingParams): void;
     delete(): void;
 }
 /**
@@ -637,7 +737,7 @@ export declare class SCRTShadowEffect extends SCRTSeriesEffect {
  */
 export declare class SCRTColumnSeriesDrawingProvider {
     DrawPoints(nativeContext: SCRTRenderContext, xValues: number, yValues: number, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTColumnDrawingParams): void;
-    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: DoubleVector, yValues: DoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTColumnDrawingParams): void;
+    DrawPointsVec(nativeContext: SCRTRenderContext, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTColumnDrawingParams): void;
     delete(): void;
 }
 /**
@@ -645,7 +745,7 @@ export declare class SCRTColumnSeriesDrawingProvider {
  */
 export declare class SCRTBubbleSeriesDrawingProvider {
     DrawPoints(nativeContext: SCRTRenderContext, xValues: number, yValues: number, zValues: number, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTPointDrawingParams): void;
-    DrawPointsVec(nativeContext: SCRTRenderContext, _xValues: DoubleVector, yValues: DoubleVector, zValues: DoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTPointDrawingParams): void;
+    DrawPointsVec(nativeContext: SCRTRenderContext, _xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, zValues: SCRTDoubleVector, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, params: SCRTPointDrawingParams): void;
     delete(): void;
 }
 export declare class SCRT2DRenderingPipeline {
@@ -697,6 +797,7 @@ export declare class SCRTColorVertex {
     delete(): void;
 }
 export declare class VectorColorVertex {
+    dataPtr(offset: number): number;
     push_back(element: SCRTColorVertex): void;
     pop_back(): void;
     size(): number;
@@ -721,6 +822,7 @@ export declare class SCRTRectVertex {
     delete(): void;
 }
 export declare class VectorRectVertex {
+    dataPtr(offset: number): number;
     push_back(element: SCRTRectVertex): void;
     pop_back(): void;
     size(): number;
@@ -756,6 +858,7 @@ export declare class SCRTColumnVertex {
     delete(): void;
 }
 export declare class VectorColumnVertex {
+    dataPtr(offset: number): number;
     push_back(element: SCRTColumnVertex): void;
     pop_back(): void;
     size(): number;
@@ -807,6 +910,7 @@ export declare class SCRTCredentials {
     delete(): void;
 }
 export declare class WStringVector {
+    dataPtr(offset: number): number;
     push_back(element: string): void;
     pop_back(): void;
     size(): number;

package/types/TSciChart3D.d.ts

@@ -22,17 +22,20 @@ export declare type TSciChart3D = {
     SCRTSetGlobalCopyToDestinationInterface: (param0: SCRTCopyToDestinationInterface) => void;
     SCRTSetClearAlphaParams: (enabled: boolean, alpha: number) => void;
     FloatVector: new () => FloatVector;
+    SCRTDoubleVector: new () => SCRTDoubleVector;
+    DoubleVector: new () => DoubleVector;
+    IntVector: new () => IntVector;
+    UIntVector: new () => UIntVector;
     eTSRTextureFormat: {
         TSR_TEXTUREFORMAT_A8B8G8R8: eTSRTextureFormat;
         TSR_TEXTUREFORMAT_R32F: eTSRTextureFormat;
     };
-    IntVector: new () => IntVector;
-    UIntVector: new () => UIntVector;
     TSRVector4: (new () => TSRVector4) & (new (x: number, y: number, z: number, w: number) => TSRVector4);
     StringVector: new () => StringVector;
-    DoubleVector: new () => DoubleVector;
     LinearCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => LinearCoordinateCalculatorDouble;
     FlippedLinearCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => FlippedLinearCoordinateCalculatorDouble;
+    LinearCoordinateCalculatorSingle: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => LinearCoordinateCalculatorSingle;
+    FlippedLinearCoordinateCalculatorSingle: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => FlippedLinearCoordinateCalculatorSingle;
     CategoryCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, IndexMin: number, IndexMax: number) => CategoryCoordinateCalculatorDouble;
     FlippedCategoryCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, IndexMin: number, IndexMax: number) => FlippedCategoryCoordinateCalculatorDouble;
     LogarithmicCoordinateCalculator: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, LogBase: number) => LogarithmicCoordinateCalculator;
@@ -48,7 +51,7 @@ export declare type TSciChart3D = {
         IsDivisibleBy: (value: number, divisor: number) => boolean;
         Constrain: (value: number, lowerBound: number, upperBound: number) => number;
         RoundToDigits: (value: number, decimals: number) => number;
-        MinMax: (inputValues: DoubleVector) => DoubleRange;
+        MinMax: (inputValues: SCRTDoubleVector) => DoubleRange;
         LinearInterpolateI: (from: number, to: number, ratio: number) => number;
     };
     SCRTLicenseType: {
@@ -274,6 +277,7 @@ export declare type TSciChart3D = {
     };
 };
 export declare class FloatVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -291,15 +295,40 @@ export declare class FloatVector {
 export declare class TSRTexture {
     delete(): void;
 }
-export declare class TSRMesh {
+export declare class SCRTDoubleVector {
+    push_back(_dNewValue: number): void;
+    resize(_iNewSize: number, _dInitialValue: number): void;
+    resizeFast(_iNewSize: number): void;
+    reserve(_iCount: number): void;
+    clear(): void;
+    size(): number;
+    capacity(): number;
+    get(_iIndex: number): number;
+    set(_iIndex: number, _dValue: number): void;
+    insertAt(_iIndex: number, _dValue: number): void;
+    removeAt(_iIndex: number): void;
+    removeRange(_iIndex: number, _iCount: number): void;
+    dataPtr(_iOffset: number): number;
     delete(): void;
 }
-export declare class TSRIndexedMesh extends TSRMesh {
+export declare class DoubleVector {
+    dataPtr(offset: number): number;
+    push_back(element: number): void;
+    pop_back(): void;
+    size(): number;
+    resize(size: number, initialValue: number): void;
+    reserve(size: number): void;
+    clear(): void;
+    fill(element: number): void;
+    insertAt(index: number, element: number): void;
+    removeAt(index: number): void;
+    removeRange(index: number, count: number): void;
     delete(): void;
-}
-export declare class eTSRTextureFormat {
+    set(index: number, element: number): void;
+    get(index: number): number;
 }
 export declare class IntVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -315,6 +344,7 @@ export declare class IntVector {
     get(index: number): number;
 }
 export declare class UIntVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -329,6 +359,14 @@ export declare class UIntVector {
     set(index: number, element: number): void;
     get(index: number): number;
 }
+export declare class TSRMesh {
+    delete(): void;
+}
+export declare class TSRIndexedMesh extends TSRMesh {
+    delete(): void;
+}
+export declare class eTSRTextureFormat {
+}
 export declare class TSRVector4 {
     x: number;
     y: number;
@@ -337,6 +375,7 @@ export declare class TSRVector4 {
     delete(): void;
 }
 export declare class StringVector {
+    dataPtr(offset: number): number;
     push_back(element: string): void;
     pop_back(): void;
     size(): number;
@@ -357,23 +396,9 @@ export declare class StringVector {
 export declare class CoordinateCalculator {
     GetCoordinate(dataValue: number): number;
     GetDataValue(coordinate: number): number;
+    CanSupportMatrices(): boolean;
     delete(): void;
 }
-export declare class DoubleVector {
-    push_back(element: number): void;
-    pop_back(): void;
-    size(): number;
-    resize(size: number, initialValue: number): void;
-    reserve(size: number): void;
-    clear(): void;
-    fill(element: number): void;
-    insertAt(index: number, element: number): void;
-    removeAt(index: number): void;
-    removeRange(index: number, count: number): void;
-    delete(): void;
-    set(index: number, element: number): void;
-    get(index: number): number;
-}
 /**
  *WebAssembly / Native Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Double precision version.
  */
@@ -386,20 +411,32 @@ export declare class LinearCoordinateCalculatorDouble extends CoordinateCalculat
 export declare class FlippedLinearCoordinateCalculatorDouble extends CoordinateCalculator {
     delete(): void;
 }
+/**
+ *WebAssembly / Native Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Float32 version.
+ */
+export declare class LinearCoordinateCalculatorSingle extends CoordinateCalculator {
+    delete(): void;
+}
+/**
+ *WebAssembly / Native Flipped Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Float32 version. Inverse of {@link LinearCoordinateCalculatorSingle}
+ */
+export declare class FlippedLinearCoordinateCalculatorSingle extends CoordinateCalculator {
+    delete(): void;
+}
 /**
  *WebAssembly / Native Catetory Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Uses index not data-value for conversion
  */
 export declare class CategoryCoordinateCalculatorDouble extends CoordinateCalculator {
-    TransformDataToIndex(dataValue: number, baseXValues: DoubleVector): number;
-    TransformIndexToData(index: number, baseXValues: DoubleVector): number;
+    TransformDataToIndex(dataValue: number, baseXValues: SCRTDoubleVector): number;
+    TransformIndexToData(index: number, baseXValues: SCRTDoubleVector): number;
     delete(): void;
 }
 /**
  *WebAssembly / Native Catetory Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Uses index not data-value for conversion. Inverse of CategoryCoordinateCalculatorDouble
  */
 export declare class FlippedCategoryCoordinateCalculatorDouble extends CoordinateCalculator {
-    TransformDataToIndex(dataValue: number, baseXValues: DoubleVector): number;
-    TransformIndexToData(index: number, baseXValues: DoubleVector): number;
+    TransformDataToIndex(dataValue: number, baseXValues: SCRTDoubleVector): number;
+    TransformIndexToData(index: number, baseXValues: SCRTDoubleVector): number;
     delete(): void;
 }
 /**
@@ -437,6 +474,7 @@ export declare class SCRTCredentials {
     delete(): void;
 }
 export declare class WStringVector {
+    dataPtr(offset: number): number;
     push_back(element: string): void;
     pop_back(): void;
     size(): number;
@@ -645,7 +683,7 @@ export declare class SCRTPoint3DSceneEntity extends SCRTSceneEntity {
     SetPointMarkerMesh(mesh: TSRIndexedMesh): void;
     SetPointSize(pointSize: number): void;
     SetPointColor(pointColor: number): void;
-    UpdateMeshesVec(xValues: DoubleVector, yValues: DoubleVector, zValues: DoubleVector, colors: IntVector, scaleFactors: FloatVector, params: SCRTPoint3DSceneEntityParams): void;
+    UpdateMeshesVec(xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, zValues: SCRTDoubleVector, colors: IntVector, scaleFactors: FloatVector, params: SCRTPoint3DSceneEntityParams): void;
     delete(): void;
 }
 export declare class SCRTPoint3DSceneEntityWrapper {

package/utils/array.d.ts

@@ -1,4 +1,11 @@
+import { NumberArray } from "../types/NumberArray";
 export declare function getUniqueValues(array: string[]): string[];
 export declare function countUnique(iterable: string[]): number;
 export declare const areArraysEqual: (leftArray: number[], rightArray: number[]) => boolean;
 export declare function arrayRemove<T>(array: T[], item: T): T[];
+/**
+ * returns true if the array is sorted
+ * @param arr The array
+ * @param ascending If True checks for sorted ascending, if False for descending
+ */
+export declare function isArraySorted(arr: NumberArray, ascending?: boolean): boolean;

package/utils/array.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayRemove = exports.areArraysEqual = exports.countUnique = exports.getUniqueValues = void 0;
+exports.isArraySorted = exports.arrayRemove = exports.areArraysEqual = exports.countUnique = exports.getUniqueValues = void 0;
 function getUniqueValues(array) {
     var onlyUnique = function (value, index, self) {
         if (value === undefined || value === null)
@@ -41,3 +41,21 @@ function arrayRemove(array, item) {
     return array;
 }
 exports.arrayRemove = arrayRemove;
+/**
+ * returns true if the array is sorted
+ * @param arr The array
+ * @param ascending If True checks for sorted ascending, if False for descending
+ */
+function isArraySorted(arr, ascending) {
+    if (ascending === void 0) { ascending = true; }
+    var sorted = true;
+    var checkUnsortedFn = ascending ? function (i) { return arr[i] > arr[i + 1]; } : function (i) { return arr[i] < arr[i + 1]; };
+    for (var i = 0; i < arr.length - 1; i++) {
+        if (checkUnsortedFn(i)) {
+            sorted = false;
+            break;
+        }
+    }
+    return sorted;
+}
+exports.isArraySorted = isArraySorted;

package/utils/calcAverage.d.ts

@@ -1,9 +1,9 @@
-import { DoubleVector } from "../types/TSciChart";
+import { SCRTDoubleVector } from "../types/TSciChart";
 /**
  * @description Calculates average for DoubleVector
  * @param doubleVector
  * @param averageNum - number of values to respect for the average
  * @param index - index of the latest value to include, by default equals to length-1 of DoubleVector
  */
-export declare const calcAverageForDoubleVector: (doubleVector: DoubleVector, averageNum: number, index?: number) => number;
+export declare const calcAverageForDoubleVector: (doubleVector: SCRTDoubleVector, averageNum: number, index?: number) => number;
 export declare const calcAverageForArray: (ar: number[], averageNum: number, index?: number) => number;

package/utils/ccall/appendDoubleVectorFromJsArray.d.ts

@@ -0,0 +1,19 @@
+import { NumberArray } from "../../types/NumberArray";
+import { SCRTDoubleVector, TSciChart } from "../../types/TSciChart";
+export declare const SIZEOF_NUMBER = 8;
+/**
+ * Inserts the values from the source Js array into the destination wasm array (and resizes) at index destIndex
+ * @param wasmContext
+ * @param source
+ * @param dest
+ * @param destIndex
+ */
+export declare function insertDoubleVectorFromJsArray(wasmContext: TSciChart, source: NumberArray, dest: SCRTDoubleVector, destIndex: number): void;
+/**
+ * Resizes the destinationVector by jsArray.length and copies the values into it
+ * @param wasmContext
+ * @param destinationVector
+ * @param jsArray
+ * @param experimentalMethod
+ */
+export declare function appendDoubleVectorFromJsArray(wasmContext: TSciChart, destinationVector: SCRTDoubleVector, jsArray: NumberArray, experimentalMethod?: boolean): void;