Interface of SDL_Openarrays

const
{$IFDEF PAIDVERS}
  SDLVersionInfo = 'openarrays_r1210_full';
  IsLightEd = false;
{$ELSE}
  SDLVersionInfo = 'openarrays_r1210_lighted';
  IsLightEd = true;
{$ENDIF}
  Release = 1210;


function AbsValArray (var Arr: TIntArray): integer; overload;
function AbsValArray (var Arr: TInt2DArray): integer; overload;
function AbsValArray (var Arr: TInt3DArray): integer; overload;
function AbsValArray (var Arr: TInt4DArray): integer; overload;
function AbsValArray (var Arr: TDoubleArray): integer; overload;
function AbsValArray (var Arr: TDouble2DArray): integer; overload;
function AbsValArray (var Arr: TDouble3DArray): integer; overload;
function AbsValArray (var Arr: TDouble4DArray): integer; overload;

function AccumulateArray (var Arr: TIntArray; Src: TIntArray;
                          Wgt: integer): integer; overload;
function AccumulateArray (var Arr: TInt2DArray; Src: TInt2DArray;
                          Wgt: integer): integer; overload;
function AccumulateArray (var Arr: TInt3DArray; Src: TInt3DArray;
                          Wgt: integer): integer; overload;
function AccumulateArray (var Arr: TInt4DArray; Src: TInt4DArray;
                          Wgt: integer): integer; overload;
function AccumulateArray (var Arr: TDoubleArray; Src: TDoubleArray;
                          Wgt: double): integer; overload;
function AccumulateArray (var Arr: TDouble2DArray; Src: TDouble2DArray;
                          Wgt: double): integer; overload;
function AccumulateArray (var Arr: TDouble3DArray; Src: TDouble3DArray;
                          Wgt: double): integer; overload;
function AccumulateArray (var Arr: TDouble4DArray; Src: TDouble4DArray;
                          Wgt: double): integer; overload;

function AddArrays (Arr1, Arr2: TIntArray;
                    var Sum: TIntArray): integer; overload;
function AddArrays (Arr1, Arr2: TInt2DArray;
                    var Sum: TInt2DArray): integer; overload;
function AddArrays (Arr1, Arr2: TInt3DArray;
                    var Sum: TInt3DArray): integer; overload;
function AddArrays (Arr1, Arr2: TInt4DArray;
                    var Sum: TInt4DArray): integer; overload;
function AddArrays (Arr1, Arr2: TDoubleArray;
                    var Sum: TDoubleArray): integer; overload;
function AddArrays (Arr1, Arr2: TDouble2DArray;
                    var Sum: TDouble2DArray): integer; overload;
function AddArrays (Arr1, Arr2: TDouble3DArray;
                    var Sum: TDouble3DArray): integer; overload;
function AddArrays (Arr1, Arr2: TDouble4DArray;
                    var Sum: TDouble4DArray): integer; overload;

function AddScalarToArray (Arr: TIntArray; Scalar: integer;
                    var Sum: TIntArray): integer; overload;
function AddScalarToArray (Arr: TInt2DArray; Scalar: integer;
                    var Sum: TInt2DArray): integer; overload;
function AddScalarToArray (Arr: TInt3DArray; Scalar: integer;
                    var Sum: TInt3DArray): integer; overload;
function AddScalarToArray (Arr: TInt4DArray; Scalar: integer;
                    var Sum: TInt4DArray): integer; overload;
function AddScalarToArray (Arr: TDoubleArray; Scalar: double;
                    var Sum: TDoubleArray): integer; overload;
function AddScalarToArray (Arr: TDouble2DArray; Scalar: double;
                    var Sum: TDouble2DArray): integer; overload;
function AddScalarToArray (Arr: TDouble3DArray; Scalar: double;
                    var Sum: TDouble3DArray): integer; overload;
function AddScalarToArray (Arr: TDouble4DArray; Scalar: double;
                    var Sum: TDouble4DArray): integer; overload;

function BoolToNumArray (Src: TBoolArray; FalseValue, TrueValue: integer;
                    var Dst: TIntArray): integer; overload;
function BoolToNumArray (Src: TBoolArray; FalseValue, TrueValue: double;
                    var Dst: TDoubleArray): integer; overload;
function BoolToNumArray (Src: TBool2DArray; FalseValue, TrueValue: integer;
                    var Dst: TInt2DArray): integer; overload;
function BoolToNumArray (Src: TBool2DArray; FalseValue, TrueValue: double;
                    var Dst: TDouble2DArray): integer; overload;

procedure BoundingRect (Arr: TInt2DArray;
                        var Left, Right, Bottom, Top: integer); overload;
procedure BoundingRect (Arr: TDouble2DArray;
                        var Left, Right, Bottom, Top: integer); overload;

function CalcHatMatrix (Arr: TDouble2DArray; var HatMat: TDouble2DArray): integer;

function CheckLinearity (Data: TIntArray; var Discont: TIntArray): integer; overload;
function CheckLinearity (Data: TDoubleArray; Tol: double;
                         var Discont: TIntArray): integer; overload;

function CloneArray (Src: TBoolArray; var Dst: TBoolArray): integer; overload;
function CloneArray (Src: TBool2DArray; var Dst: TBool2DArray): integer; overload;
function CloneArray (Src: TDoubleArray; var Dst: TDoubleArray): integer; overload;
function CloneArray (Src: TDouble2DArray;
                     var Dst: TDouble2DArray): integer; overload;
function CloneArray (Src: TDouble3DArray;
                     var Dst: TDouble3DArray): integer; overload;
function CloneArray (Src: TDouble4DArray;
                     var Dst: TDouble4DArray): integer; overload;
function CloneArray (Src: TIntArray; var Dst: TIntArray): integer; overload;
function CloneArray (Src: TInt2DArray; var Dst: TInt2DArray): integer; overload;
function CloneArray (Src: TInt3DArray; var Dst: TInt3DArray): integer; overload;
function CloneArray (Src: TInt4DArray; var Dst: TInt4DArray): integer; overload;
function CloneArray (Src: TDoubleArray; var Dst: TIntArray): integer; overload;
function CloneArray (Src: TDouble2DArray;
                     var Dst: TInt2DArray): integer; overload;
function CloneArray (Src: TDouble3DArray;
                     var Dst: TInt3DArray): integer; overload;
function CloneArray (Src: TDouble4DArray;
                     var Dst: TInt4DArray): integer; overload;
function CloneArray (Src: TIntArray; var Dst: TDoubleArray): integer; overload;
function CloneArray (Src: TInt2DArray;
                     var Dst: TDouble2DArray): integer; overload;
function CloneArray (Src: TInt3DArray;
                     var Dst: TDouble3DArray): integer; overload;
function CloneArray (Src: TInt4DArray;
                     var Dst: TDouble4DArray): integer; overload;
function CloneArray (Src: TSingleArray; var Dst: TDoubleArray): integer; overload;
function CloneArray (Src: TDoubleArray; var Dst: TSingleArray): integer; overload;

function CloneAndReverseArray (Src: TBoolArray;
                               var Dst: TBoolArray): integer; overload;
function CloneAndReverseArray (Src: TIntArray;
                               var Dst: TIntArray): integer; overload;
function CloneAndReverseArray (Src: TDoubleArray;
                               var Dst: TDoubleArray): integer; overload;
function CloneAndReverseArray (Src: TIntArray;
                               var Dst: TDoubleArray): integer; overload;
function CloneAndReverseArray (Src: TDoubleArray;
                               var Dst: TIntArray): integer; overload;
function CloneAndReverseArray (Src: TSingleArray;
                               var Dst: TDoubleArray): integer; overload;
function CloneAndReverseArray (Src: TDoubleArray;
                               var Dst: TSingleArray): integer; overload;

function ConvertToColorMap (var DataArray: TInt2DArray;
                            ColPal: TColorArray): integer;

function Copy2DColTo1DArray (Src: TDouble2DArray; Col, FirstRow, LastRow: integer;
                             var Dest: TDoubleArray; DestElem: integer): integer;
function Copy2DRowTo1DArray (Src: TDouble2DArray; Row, FirstCol, LastCol: integer;
                             var Dest: TDoubleArray; DestElem: integer): integer;

function CopyArray (Src: TBoolArray; DstElem: integer;
                    var Dst: TBoolArray): integer; overload;
function CopyArray (Src: TBool2DArray; DstCol, DstRow: integer;
                    var Dst: TBool2DArray): integer; overload;

function CopyArray (Src: TintArray; SrcElemLo, SrcElemHi,
                    DstElem: integer; var Dst: TintArray): integer; overload;
function CopyArray (Src: TintArray; DstElem: integer;
                    var Dst: TintArray): integer; overload;
function CopyArray (Src: Tint2DArray; DstCol, DstRow: integer;
                    var Dst: Tint2DArray): integer; overload;
function CopyArray (Src: Tint2DArray; SrcColLo, SrcRowLo, SrcColHi,
                    SrcRowHi, DstCol, DstRow: integer;
                    var Dst: Tint2DArray): integer; overload;
function CopyArray (Src: Tint3DArray; DstCol, DstRow,
                    DstLayer: integer; var Dst: Tint3DArray): integer; overload;
function CopyArray (Src: Tint3DArray; SrcColLo, SrcRowLo, SrcLayerLo, SrcColHi,
                    SrcRowHi, SrcLayerHi, DstCol, DstRow, DstLayer: integer;
                    var Dst: Tint3DArray): integer; overload;
function CopyArray (Src: Tint4DArray; DstCol, DstRow, DstLayer,
                    DstTSlot: integer; var Dst: Tint4DArray): integer; overload;
function CopyArray (Src: Tint4DArray; SrcColLo, SrcRowLo, SrcLayerLo, SrcTSlotLo,
                    SrcColHi, SrcRowHi, SrcLayerHi, SrcTSlotHi, DstCol,
                    DstRow, DstLayer, DstTSlot: integer;
                    var Dst: Tint4DArray): integer; overload;

function CopyArray (Src: TDoubleArray; SrcElemLo, SrcElemHi,
                    DstElem: integer; var Dst: TDoubleArray): integer; overload;
function CopyArray (Src: TDoubleArray; DstElem: integer;
                    var Dst: TDoubleArray): integer; overload;
function CopyArray (Src: TDouble2DArray; DstCol, DstRow: integer;
                    var Dst: TDouble2DArray): integer; overload;
function CopyArray (Src: TDouble2DArray; SrcColLo, SrcRowLo, SrcColHi,
                    SrcRowHi, DstCol, DstRow: integer;
                    var Dst: TDouble2DArray): integer; overload;
function CopyArray (Src: TDouble3DArray; DstCol, DstRow,
                    DstLayer: integer; var Dst: TDouble3DArray): integer; overload;
function CopyArray (Src: TDouble3DArray; SrcColLo, SrcRowLo, SrcLayerLo, SrcColHi,
                    SrcRowHi, SrcLayerHi, DstCol, DstRow, DstLayer: integer;
                    var Dst: TDouble3DArray): integer; overload;
function CopyArray (Src: TDouble4DArray; DstCol, DstRow, DstLayer,
                    DstTSlot: integer; var Dst: TDouble4DArray): integer; overload;
function CopyArray (Src: TDouble4DArray; SrcColLo, SrcRowLo, SrcLayerLo,
                    SrcTSlotLo, SrcColHi, SrcRowHi, SrcLayerHi, SrcTSlotHi, DstCol,
                    DstRow, DstLayer, DstTSlot: integer;
                    var Dst: TDouble4DArray): integer; overload;

function CopyArrayColumn (SrcArr: TBool2DArray; Col, RowLo,
                    RowHi: integer; var DstArr: TBoolArray): integer; overload;
function CopyArrayColumn (SrcArr: TInt2DArray; Col, RowLo,
                    RowHi: integer; var DstArr: TIntArray): integer; overload;
function CopyArrayColumn (SrcArr: TDouble2DArray; Col, RowLo,
                    RowHi: integer; var DstArr: TDoubleArray): integer; overload;
function CopyArrayRow (SrcArr: TBool2DArray; Row, ColLo,
                    ColHi: integer; var DstArr: TBoolArray): integer; overload;
function CopyArrayRow (SrcArr: TInt2DArray; Row, ColLo,
                    ColHi: integer; var DstArr: TIntArray): integer; overload;
function CopyArrayRow (SrcArr: TDouble2DArray; Row, ColLo,
                    ColHi: integer; var DstArr: TDoubleArray): integer; overload;

function CopyToArrayColumn (SrcVec: TDoubleArray; FirstElem, LastELem,
                    CellCol, CellRow: integer;
                    var DstArr: TDouble2DArray): integer; overload;
function CopyToArrayColumn (SrcVec: TIntArray; FirstElem, LastELem,
                    CellCol, CellRow: integer;
                    var DstArr: TInt2DArray): integer; overload;
function CopyToArrayColumn (SrcVec: TBoolArray; FirstElem, LastELem,
                    CellCol, CellRow: integer;
                    var DstArr: TBool2DArray): integer; overload;
function CopyToArrayRow (SrcVec: TDoubleArray; FirstElem, LastELem,
                    CellCol, CellRow: integer;
                    var DstArr: TDouble2DArray): integer; overload;
function CopyToArrayRow (SrcVec: TIntArray; FirstElem, LastELem,
                    CellCol, CellRow: integer;
                    var DstArr: TInt2DArray): integer; overload;
function CopyToArrayRow (SrcVec: TBoolArray; FirstElem, LastELem,
                    CellCol, CellRow: integer;
                    var DstArr: TBool2DArray): integer; overload;

function CountTrueCellsOfArray (Arr: TBoolArray): integer; overload;
function CountTrueCellsOfArray (Arr: TBool2DArray): integer; overload;
function CountTrueCellsOfArray (Arr: TBool2DArray; FirstCol, LastCol,
                    FirstRow, LastRow: integer): integer; overload;

function CountValues (Arr: TDoubleArray; LowElem, HighElem: integer;
                    RangeLow, RangeHigh: double): integer; overload;
function CountValues (Arr: TDouble2DArray; LowCol, HighCol,
                    LowRow, HighRow: integer;
                    RangeLow, RangeHigh: double): integer; overload;
function CountValues (Arr: TDouble3DArray; LowCol, HighCol, LowRow, HighRow,
                    LowLayer, HighLayer: integer;
                    RangeLow, RangeHigh: double): integer; overload;
function CountValues (Arr: TDouble4DArray; LowCol, HighCol, LowRow, HighRow,
                    LowLayer, HighLayer, LowTSlot, HighTSlot: integer;
                    RangeLow, RangeHigh: double): integer; overload;
function CountValues (Arr: TIntArray; LowElem, HighElem: integer;
                    RangeLow, RangeHigh: integer): integer; overload;
function CountValues (Arr: TInt2DArray; LowCol, HighCol, LowRow, HighRow: integer;
                    RangeLow, RangeHigh: integer): integer; overload;
function CountValues (Arr: TInt3DArray; LowCol, HighCol, LowRow, HighRow,
                    LowLayer, HighLayer: integer;
                    RangeLow, RangeHigh: integer): integer; overload;
function CountValues (Arr: TInt4DArray; LowCol, HighCol, LowRow, HighRow,
                    LowLayer, HighLayer, LowTSlot, HighTSlot: integer;
                    RangeLow, RangeHigh: integer): integer; overload;

function CreateMaskShape (var MaskArray: TBool2DArray; Shape: TShapeKind;
                          Params: TIntArray): integer;

function Determinant (InData: TDouble2DArray): double;

function DichotomizeArray (Arr: TDouble2DArray; Threshold: double;
                    var Res: TBool2DArray): integer; overload;
function DichotomizeArray (Arr: TDouble2DArray; Thresh1, Thresh2: double;
                    var Res: TBool2DArray): integer; overload;
function DichotomizeArray (Arr: TInt2DArray; Threshold: integer;
                    var Res: TBool2DArray): integer; overload;
function DichotomizeArray (Arr: TInt2DArray; Thresh1, Thresh2: integer;
                    var Res: TBool2DArray): integer; overload;
function DichotomizeArray (Arr: TIntArray; Threshold: integer;
                    var Res: TBoolArray): integer; overload;
function DichotomizeArray (Arr: TIntArray; Thresh1, Thresh2: integer;
                    var Res: TBoolArray): integer; overload;

function DiscretizeArray (var Mat: TDouble2DArray; NLevels: integer;
                    InLow, InHigh, OutLow, OutHigh: double): integer;

function DistanceOfObjects (Mat: TDouble2DArray;
                    Mode: TDistMode; obj1, obj2: integer;
                    feat1, feat2: integer; var dist: double): integer;

function EdgeVector (Src: TInt2DArray; Orient: TOrientation; EdgeOp: TEdgeOp;
                     var Dest: TDoubleArray): integer; overload;
function EdgeVector (Src: TInt2DArray; Orient: TOrientation; EdgeOp: TEdgeOp;
                     EdgeIx: TIntArray; var Dest: TDoubleArray): integer; overload;
function EdgeVector (Src: TDouble2DArray; Orient: TOrientation; EdgeOp: TEdgeOp;
                     var Dest: TDoubleArray): integer; overload;
function EdgeVector (Src: TDouble2DArray; Orient: TOrientation; EdgeOp: TEdgeOp;
                     EdgeIx: TIntArray; var Dest: TDoubleArray): integer; overload;

function EigenDecomposition (Data: TDouble2DArray; SortEV: boolean;
                    var EigenVectors: TDouble2DArray;
                    var EigenValues: TDoubleArray): integer;

function EqualArrays (Mat1, Mat2: TIntArray): boolean; overload;
function EqualArrays (Mat1, Mat2: TInt2DArray): boolean; overload;
function EqualArrays (Mat1, Mat2: TInt3DArray): boolean; overload;
function EqualArrays (Mat1, Mat2: TInt4DArray): boolean; overload;

function FillArray (var Arr: TBool2DArray; Value: boolean): integer; overload;
function FillArray (var Arr: TBoolArray; Value: boolean): integer; overload;

function FillArray (var Dst: TIntArray; Value: integer): integer; overload;
function FillArray (var Dst: TIntArray; Value: integer;
                    DstElemLo, DstElemHi: integer): integer; overload;
function FillArray (var Dst: TInt2DArray; Value: integer): integer; overload;
function FillArray (var Dst: TInt2DArray; Value: integer; DstColLo, DstRowLo,
                    DstColHi, DstRowHi: integer): integer; overload;
function FillArray (var Dst: TInt3DArray; Value: integer): integer; overload;
function FillArray (var Dst: TInt3DArray; Value: integer;
                    DstColLo, DstRowLo, DstLayerLo,
                    DstColHi, DstRowHi, DstLayerHi: integer): integer; overload;
function FillArray (var Dst: TInt4DArray; Value: integer): integer; overload;
function FillArray (var Dst: TInt4DArray; Value: integer; DstColLo, DstRowLo,
                    DstLayerLo, DstTSlotLo, DstColHi, DstRowHi,
                    DstLayerHi, DstTSlotHi: integer): integer; overload;

function FillArray (var Dst: TDoubleArray; Value: double): integer; overload;
function FillArray (var Dst: TDoubleArray; Value: double;
                    DstElemLo, DstElemHi: integer): integer; overload;
function FillArray (var Dst: TDouble2DArray; Value: double): integer; overload;
function FillArray (var Dst: TDouble2DArray; Value: double; DstColLo, DstRowLo,
                    DstColHi, DstRowHi: integer): integer; overload;
function FillArray (var Dst: TDouble3DArray; Value: double): integer; overload;
function FillArray (var Dst: TDouble3DArray; Value: double;
                    DstColLo, DstRowLo, DstLayerLo,
                    DstColHi, DstRowHi, DstLayerHi: integer): integer; overload;
function FillArray (var Dst: TDouble4DArray; Value: double): integer; overload;
function FillArray (var Dst: TDouble4DArray; Value: double; DstColLo,
                    DstRowLo, DstLayerLo, DstTSlotLo, DstColHi, DstRowHi,
                    DstLayerHi, DstTSlotHi: integer): integer; overload;

function FillArrayMasked (var Mat: TDouble2DArray; Value: double;
                          MaskArray: TBool2DArray): integer; overload;
function FillArrayMasked (var Mat: TInt2DArray; Value: integer;
                          MaskArray: TBool2DArray): integer; overload;

function FillArraySerial (var Mat: TIntArray): integer; overload;
function FillArraySerial (var Mat: TInt2DArray): integer; overload;
function FillArraySerial (var Mat: TInt3DArray): integer; overload;
function FillArraySerial (var Mat: TDoubleArray): integer; overload;
function FillArraySerial (var Mat: TDouble2DArray): integer; overload;
function FillArraySerial (var Mat: TDouble3DArray): integer; overload;
function FillArraySerial (var Mat: TIntArray;
                          Offset, Diff: integer): integer; overload;
function FillArraySerial (var Mat: TInt2DArray;
                          Offset, Diff: integer): integer; overload;
function FillArraySerial (var Mat: TInt3DArray;
                          Offset, Diff: integer): integer; overload;
function FillArraySerial (var Mat: TDoubleArray;
                          Offset, Diff: double): integer; overload;
function FillArraySerial (var Mat: TDouble2DArray;
                          Offset, Diff: double): integer; overload;
function FillArraySerial (var Mat: TDouble3DArray;
                          Offset, Diff: double): integer; overload;
function FillArraySerial (var Mat: TDouble4DArray;
                          Offset, Diff: double): integer; overload;

function FillDiagArray (var Mat: TDouble2DArray; Diag: double): integer; overload;
function FillDiagArray (var Mat: TDouble3DArray; Diag: double): integer; overload;
function FillDiagArray (var Mat: TDouble4DArray; Diag: double): integer; overload;
function FillDiagArray (var Mat: TInt2DArray; Diag: integer): integer; overload;
function FillDiagArray (var Mat: TInt3DArray; Diag: integer): integer; overload;
function FillDiagArray (var Mat: TInt4DArray; Diag: integer): integer; overload;


function FillRandomNormal (var Arr: TDoubleArray;
                    Mean, StdDev: double): integer; overload;
function FillRandomNormal (var Arr: TDouble2DArray;
                    Mean, StdDev: double): integer; overload;
function FillRandomNormal (var Arr: TDouble3DArray;
                    Mean, StdDev: double): integer; overload;
function FillRandomNormal (var Arr: TDouble4DArray;
                    Mean, StdDev: double): integer; overload;

function FillRandomUniform (var Arr: TDoubleArray;
                    RangeLow, RangeHigh: double): integer; overload;
function FillRandomUniform (var Arr: TDouble2DArray;
                    RangeLow, RangeHigh: double): integer; overload;
function FillRandomUniform (var Arr: TDouble3DArray;
                    RangeLow, RangeHigh: double): integer; overload;
function FillRandomUniform (var Arr: TDouble4DArray;
                    RangeLow, RangeHigh: double): integer; overload;
function FillRandomUniform (var Arr: TIntArray;
                    RangeLow, RangeHigh: integer): integer; overload;
function FillRandomUniform (var Arr: TIntArray; RangeLow, RangeHigh: integer;
                    DupsAllowed: boolean): integer; overload;
function FillRandomUniform (var Arr: TInt2DArray;
                    RangeLow, RangeHigh: integer): integer; overload;
function FillRandomUniform (var Arr: TInt3DArray;
                    RangeLow, RangeHigh: integer): integer; overload;
function FillRandomUniform (var Arr: TInt4DArray;
                    RangeLow, RangeHigh: integer): integer; overload;

function FindInArray (Value: integer; Arr: TIntArray): integer; overload;
function FindInArray (Value: string; Arr: TStrArray;
                      IgnoreCase, SubStringSearch: boolean): integer; overload;

function FindInSortedArray (Value: double; Arr: TDoubleArray;
                    Ascending: boolean): integer;

function FlipDimArray (var Arr: TintArray; Index: integer): integer; overload;
function FlipDimArray (var Arr: Tint2DArray; Index: integer): integer; overload;
function FlipDimArray (var Arr: Tint3DArray; Index: integer): integer; overload;
function FlipDimArray (var Arr: Tint4DArray; Index: integer): integer; overload;
function FlipDimArray (var Arr: TDoubleArray; Index: integer): integer; overload;
function FlipDimArray (var Arr: TDouble2DArray; Index: integer): integer; overload;
function FlipDimArray (var Arr: TDouble3DArray; Index: integer): integer; overload;
function FlipDimArray (var Arr: TDouble4DArray; Index: integer): integer; overload;

function FloodFillArray (px, py: integer; Target: integer;
                    CommonEdgeRequired: boolean; var Data: TInt2DArray;
                    var ATop, ABot, ALeft, ARight: integer): integer; overload;
function FloodFillArray (px, py: integer; Tolerance: double; Target: double;
                    CommonEdgeRequired: boolean; var Data: TDouble2DArray;
                    var ATop, ABot, ALeft, ARight: integer): integer; overload;

function FrequDistOfArray (Data: TDouble2DArray; LoX, LoY, HiX, HiY: longint;
                    FirstBin, LastBin, BinWidth: double; var FrequDist: TIntArray;
                    var Underflow, Overflow, MaxCnt: longint): integer; overload;
function FrequDistOfArray (Data: TDoubleArray; LoX, HiX: longint;
                    FirstBin, LastBin, BinWidth: double; var FrequDist: TIntArray;
                    var Underflow, Overflow, MaxCnt: longint): integer; overload;
function FrequDistOfArray (Data: TDouble2DArray; Mask: TBool2DArray; LoX, LoY,
                    HiX, HiY: longint; FirstBin, LastBin, BinWidth: double;
                    var FrequDist: TIntArray; var Underflow, Overflow,
                    MaxCnt: longint): integer; overload;

function IncArray (var Arr: TIntArray; Scalar: integer): integer; overload;
function IncArray (var Arr: TInt2DArray; Scalar: integer): integer; overload;
function IncArray (var Arr: TInt3DArray; Scalar: integer): integer; overload;
function IncArray (var Arr: TInt4DArray; Scalar: integer): integer; overload;
function IncArray (var Arr: TDoubleArray; Scalar: double): integer; overload;
function IncArray (var Arr: TDouble2DArray; Scalar: double): integer; overload;
function IncArray (var Arr: TDouble3DArray; Scalar: double): integer; overload;
function IncArray (var Arr: TDouble4DArray; Scalar: double): integer; overload;

function InvertArray (var Arr: TBoolArray): integer; overload;
function InvertArray (var Arr: TBool2DArray): integer; overload;
function InvertArray (var Arr: TDouble2DArray): integer; overload;

function IsDichotomous (Data: TDoubleArray; var v1, v2: double): boolean; overload;
function IsDichotomous (Data: TIntArray; var v1, v2: integer): boolean; overload;

function IsStrictlyMonotone (data: TIntArray): boolean; overload;
function IsStrictlyMonotone (data: TDoubleArray): boolean; overload;
function IsMonotone (data: TIntArray): boolean; overload;
function IsMonotone (data: TDoubleArray): boolean; overload;

function ListCellPositions (Arr: TBoolArray; value: boolean;
                            MaxCellCnt, Offset: integer;
                            var CellPos: TIntArray): integer; overload;
function ListCellPositions (Arr: TBool2DArray; value: boolean;
                            MaxCellCnt, Offset: integer;
                            var CellPos: TInt2dArray): integer; overload;

function LoadArray (FName: string; var Arr: TIntArray;
                    var Comment: string): integer; overload;
function LoadArray (FName: string; var Arr: TInt2DArray;
                    var Comment: string): integer; overload;
function LoadArray (FName: string; var Arr: TInt3DArray;
                    var Comment: string): integer; overload;
function LoadArray (FName: string; var Arr: TDoubleArray;
                    var Comment: string): integer; overload;
function LoadArray (FName: string; var Arr: TDouble2DArray;
                    var Comment: string): integer; overload;
function LoadArray (FName: string; var Arr: TDouble3DArray;
                    var Comment: string): integer; overload;

function LoadBinaryArray (FName: string; var Arr: TDouble2DArray;
                 var DataID: string; CheckFormat: boolean): integer; overload;
function LoadBinaryArray (FName: string; var Arr: TInt2DArray;
                 var DataID: string; CheckFormat: boolean): integer; overload;
function LoadBinaryArray (FName: string; var Arr: TDouble3DArray;
                 var DataID: string; CheckFormat: boolean): integer; overload;
function LoadBinaryArray (FName: string; var Arr: TDouble4DArray;
                 var DataID: string; CheckFormat: boolean): integer; overload;

function LocalMean (Data: TIntArray; index, NNeighbors,
                    LimitLow, LimitHigh: integer): double; overload;
function LocalMean (Data: TDoubleArray; index, NNeighbors,
                    LimitLow, LimitHigh: integer): double; overload;
function LocalMedian (Data: TIntArray; index, NNeighbors,
                      LimitLow, LimitHigh: integer): double; overload;
function LocalMedian (Data: TDoubleArray; index, NNeighbors,
                      LimitLow, LimitHigh: integer): double; overload;

function LUdecomposition (data: TDouble2DArray;
                          var MatL, MatU: TDouble2DArray): integer;
function LUPdecomposition (data: TDouble2DArray;
                           var MatL, MatU: TDouble2DArray; var MatP: TInt2DArray;
                           var NumPerm: integer): integer;

function MaxArray (Arr: TIntArray): integer; overload;
function MaxArray (Arr: TIntArray; var ix: integer): integer; overload;
function MaxArray (Arr: TInt2DArray): integer; overload;
function MaxArray (Arr: TInt2DArray; var ix, iy: integer): integer; overload;
function MaxArray (Arr: TInt3DArray): integer; overload;
function MaxArray (Arr: TInt4DArray): integer; overload;
function MaxArray (Arr: TDoubleArray): double; overload;
function MaxArray (Arr: TDoubleArray; var ix: integer): double; overload;
function MaxArray (Arr: TDouble2DArray): double; overload;
function MaxArray (Arr: TDouble2DArray; var ix, iy: integer): double; overload;
function MaxArray (Arr: TDouble3DArray): double; overload;
function MaxArray (Arr: TDouble4DArray): double; overload;

function MeanAbsDev (Data: TDoubleArray; Mode: integer;
                     var CentralPoint: double): double; overload;
function MeanAbsDev (Data: TIntArray; Mode: integer;
                     var CentralPoint: double): double; overload;

function MeanArray (Arr: TDoubleArray; ElemLo, ElemHi: integer;
                    var Mean: double): integer; overload;
function MeanArray (Arr: TDouble2DArray; ColLo, RowLo, ColHi, RowHi: integer;
                    var Mean: double): integer; overload;
function MeanArray (Arr: TDouble3DArray; ColLo, RowLo, LayerLo,
                    ColHi, RowHi, LayerHi: integer;
                    var Mean: double): integer; overload;
function MeanArray (Arr: TDouble4DArray; ColLo, RowLo, LayerLo, TSlotLo,
                    ColHi, RowHi, LayerHi, TSlotHi: integer;
                    var Mean: double): integer; overload;
function MeanArray (Arr: TIntArray; ElemLo, ElemHi: integer;
                    var Mean: double): integer; overload;
function MeanArray (Arr: TInt2DArray; ColLo, RowLo, ColHi, RowHi: integer;
                    var Mean: double): integer; overload;
function MeanArray (Arr: TInt3DArray; ColLo, RowLo, LayerLo,
                    ColHi, RowHi, LayerHi: integer;
                    var Mean: double): integer; overload;
function MeanArray (Arr: TInt4DArray; ColLo, RowLo, LayerLo, TSlotLo,
                    ColHi, RowHi, LayerHi, TSlotHi: integer;
                    var Mean: double): integer; overload;

procedure MeanCenterColumnsOfArray (Data: TDouble2DArray; var means: TDoubleArray);
procedure MeanCenterRowsOfArray (Data: TDouble2DArray; var means: TDoubleArray);

function MeanVarArray (Arr: TDoubleArray; FirstIx, LastIx: integer;
                    var Mean, Vari: double): integer; overload;
function MeanVarArray (Arr: TDouble2DArray; LowCol, LowRow, HighCol,
                    HighRow: integer; var Mean, Vari: double): integer; overload;
function MeanVarArray (Arr: TIntArray; FirstIx, LastIx: integer;
                    var Mean, Vari: double): integer; overload;
function MeanVarArray (Arr: TInt2DArray; LowCol, LowRow, HighCol, HighRow: integer;
                    var Mean, Vari: double): integer; overload;



function MinArray (Arr: TIntArray): integer; overload;
function MinArray (Arr: TIntArray; var ix: integer): integer; overload;
function MinArray (Arr: TInt2DArray): integer; overload;
function MinArray (Arr: TInt2DArray; var ix, iy: integer): integer; overload;
function MinArray (Arr: TInt3DArray): integer; overload;
function MinArray (Arr: TInt4DArray): integer; overload;
function MinArray (Arr: TDoubleArray): double; overload;
function MinArray (Arr: TDoubleArray; var ix: integer): double; overload;
function MinArray (Arr: TDouble2DArray): double; overload;
function MinArray (Arr: TDouble2DArray; var ix, iy: integer): double; overload;
function MinArray (Arr: TDouble3DArray): double; overload;
function MinArray (Arr: TDouble4DArray): double; overload;

function MinMaxArray (Arr: TSingleArray;
                      var MinVal, MaxVal: double): integer; overload;
{$IFDEF GE_LEV18}
function MinMaxArray (Arr: array of double;
                      var MinVal, MaxVal: double): integer; overload;
{$ENDIF}
function MinMaxArray (Arr: TDoubleArray;
                      var MinVal, MaxVal: double): integer; overload;
function MinMaxArray (Arr: TDouble2DArray;
                      var MinVal, MaxVal: double): integer; overload;
function MinMaxArray (Arr: TDouble3DArray;
                      var MinVal, MaxVal: double): integer; overload;
function MinMaxArray (Arr: TDouble4DArray;
                      var MinVal, MaxVal: double): integer; overload;
function MinMaxArray (Arr: TDoubleArray; FirstIx, LastIx: integer;
                      var MinVal, MaxVal: double;
                      var MinIx, MaxIx: integer): integer; overload;
function MinMaxArray (Arr: TDouble2DArray; LowCol, LowRow,
                      HighCol, HighRow: integer; var MinVal, MaxVal: double;
                      var MinCol, MinRow,
                      MaxCol, MaxRow: integer): integer; overload;
function MinMaxArray (Arr: array of integer;
                      var MinVal, MaxVal: integer): integer; overload;
function MinMaxArray (Arr: TIntArray;
                      var MinVal, MaxVal: integer): integer; overload;
function MinMaxArray (Arr: TInt2DArray;
                      var MinVal, MaxVal: integer): integer; overload;
function MinMaxArray (Arr: TInt3DArray;
                      var MinVal, MaxVal: integer): integer; overload;
function MinMaxArray (Arr: TInt4DArray;
                      var MinVal, MaxVal: integer): integer; overload;
function MinMaxArray (Arr: TIntArray; FirstIx, LastIx: integer;
                      var MinVal, MaxVal: integer;
                      var MinIx, MaxIx: integer): integer; overload;
function MinMaxArray (Arr: TInt2DArray; LowCol, LowRow, HighCol, HighRow: integer;
                      var MinVal, MaxVal: integer; var MinCol, MinRow,
                      MaxCol, MaxRow: integer): integer; overload;
function MultiplyArrays (Arr1, Arr2: TDouble2DArray;
                    var Product: TDouble2DArray): integer; overload;
function MultiplyArrays (Arr1: TInt2DArray; Arr2: TDouble2DArray;
                    var Product: TDouble2DArray): integer; overload;
function MultiplyArrays (Arr1: TDouble2DArray; Arr2: TInt2DArray;
                    var Product: TDouble2DArray): integer; overload;
function MultiplyArrays (Arr1, Arr2: TDoubleArray;
                    var Product: TDouble2DArray): integer; overload;
function MultiplyArrays (Arr1, Arr2: TInt2DArray;
                    var Product: TInt2DArray): integer; overload;
function MultiplyArrays (Arr1, Arr2: TIntArray;
                    var Product: TInt2DArray): integer; overload;

function MultiplyArrayByScalar (Arr: TDoubleArray; Scalar: double;
                    var Product: TDoubleArray): integer; overload;
function MultiplyArrayByScalar (var Arr: TDoubleArray;
                    Scalar: double): integer; overload;
function MultiplyArrayByScalar (Arr: TDouble2DArray; Scalar: double;
                    var Product: TDouble2DArray): integer; overload;
function MultiplyArrayByScalar (var Arr: TDouble2DArray;
                    Scalar: double): integer; overload;
function MultiplyArrayByScalar (Arr: TDouble3DArray; Scalar: double;
                    var Product: TDouble3DArray): integer; overload;
function MultiplyArrayByScalar (var Arr: TDouble3DArray;
                    Scalar: double): integer; overload;
function MultiplyArrayByScalar (Arr: TDouble4DArray; Scalar: double;
                    var Product: TDouble4DArray): integer; overload;
function MultiplyArrayByScalar (var Arr: TDouble4DArray;
                    Scalar: double): integer; overload;
function MultiplyArrayByScalar (Arr: TIntArray; Scalar: integer;
                    var Product: TIntArray): integer; overload;
function MultiplyArrayByScalar (var Arr: TIntArray;
                    Scalar: integer): integer; overload;
function MultiplyArrayByScalar (Arr: TInt2DArray; Scalar: integer;
                    var Product: TInt2DArray): integer; overload;
function MultiplyArrayByScalar (var Arr: TInt2DArray;
                    Scalar: integer): integer; overload;
function MultiplyArrayByScalar (Arr: TInt3DArray; Scalar: integer;
                    var Product: TInt3DArray): integer; overload;
function MultiplyArrayByScalar (var Arr: TInt3DArray;
                    Scalar: integer): integer; overload;
function MultiplyArrayByScalar (Arr: TInt4DArray; Scalar: integer;
                    var Product: TInt4DArray): integer; overload;
function MultiplyArrayByScalar (var Arr: TInt4DArray;
                    Scalar: integer): integer; overload;

function MultiplyArraysElemw (Arr1, Arr2: TDouble2DArray;
                    var Product: TDouble2DArray): integer; overload;
function MultiplyArraysElemw (Arr1, Arr2: TDoubleArray;
                    var Product: TDoubleArray): integer; overload;
function MultiplyArraysElemw (Arr1, Arr2: TInt2DArray;
                    var Product: TInt2DArray): integer; overload;
function MultiplyArraysElemw (Arr1, Arr2: TIntArray;
                    var Product: TIntArray): integer; overload;

function NormalizeColumns (var Arr: TDouble2DArray): integer;
function NormalizeRows (var Arr: TDouble2DArray): integer;

function PearsonCorrCoeffColsOfArray (Arr: TDouble2DArray;
                    col1, col2: integer): double;

function PercentileArray (prob: double; Arr: TDoubleArray): double; overload;
function PercentileArray (prob: double; Arr: TDoubleArray;
                    First, Last: integer): double; overload;
function PercentileArray (prob: double; Arr: TDouble2DArray; FirstCol, FirstRow,
                    LastCol, LastRow: integer): double; overload;
function PercentileArray (prob: double; Arr: TIntArray): double; overload;

function PermuteArray (Data: TDouble2DArray; PermMat: TInt2DArray;
                       Mode: TApplyColRow; TransposeP: boolean;
                       var PData: TDouble2DArray): integer;

function ReadBinaryArrayHeader (FName: string; var NrColumns, NrRows,
                    NrLayers, NrTSlots: integer; var DataID: string;
                    var Format: integer): boolean;

function ReciprocalArray (var Arr: TDoubleArray;
                          InDefVal: double): integer; overload;
function ReciprocalArray (var Arr: TDouble2DArray;
                          InDefVal: double): integer; overload;
function ReciprocalArray (var Arr: TDouble3DArray;
                          InDefVal: double): integer; overload;
function ReciprocalArray (var Arr: TDouble4DArray;
                          InDefVal: double): integer; overload;

function RemoveColumn (var Mat: TDouble2DArray; col: integer): boolean; overload;
function RemoveColumn (var Mat: TInt2DArray; col: integer): boolean; overload;

function RemoveRow (var Mat: TDouble2DArray; row: integer): boolean; overload;
function RemoveRow (var Mat: TInt2DArray; row: integer): boolean; overload;

function RescaleArray (var Arr: TDoubleArray; First, Last: integer;
               Mode: TRescaleMode; var Par1, Par2: double): integer; overload;
function RescaleArray (var Arr: TDouble2DArray;
               LowCol, LowRow, HighCol, HighRow: integer;
               Mode: TRescaleMode; var Par1, Par2: double): integer; overload;

function Resample2DArray (SrcMat: TDouble2DArray; var DstMat: TDouble2DArray;
               colpct, rowpct: double; BootStrap: boolean;
               var RndColIx, RndRowIx: TIntArray): integer;

{$IFDEF GE_LEV18}
function SaveArrayAsImg (FName: string; Data: TInt2DArray;
                         MagFact: integer): integer;
{$ENDIF}

procedure SaveBinaryArray (FName: string; Arr: TInt2DArray;
                           DataID: string); overload;
procedure SaveBinaryArray (FName: string; Arr: TDouble2DArray;
                           DataID: string); overload;
procedure SaveBinaryArray (FName: string; Arr: TDouble3DArray;
                           DataID: string); overload;
procedure SaveBinaryArray (FName: string; Arr: TDouble4DArray;
                           DataID: string); overload;

procedure SerializeArray (Src: TInt2DArray; RowWise: boolean;
                          var Dst: TIntArray); overload;
procedure SerializeArray (Src: TDouble2DArray; RowWise: boolean;
                          var Dst: TDoubleArray); overload;

function ShuffleArray (var Data: TIntArray): integer; overload;
function ShuffleArray (var Data: TDoubleArray): integer; overload;

function SortAndRemoveDuplicates (var Data: TIntArray;
                                  Ascending: boolean): integer;

function SortArray (Ascending: boolean; var Data: TDoubleArray;
                    var Index: TIntArray): integer; overload;
function SortArray (Ascending: boolean; var Data: TIntArray;
                    var Index: TIntArray): integer; overload;

function StdDevArray (Arr: TDoubleArray; ElemLo, ElemHi: integer;
                    var SDVal: double): integer; overload;
function StdDevArray (Arr: TDouble2DArray; ColLo, RowLo, ColHi, RowHi: integer;
                    var SDVal: double): integer; overload;
function StdDevArray (Arr: TDouble3DArray; ColLo, RowLo, LayerLo,
                    ColHi, RowHi, LayerHi: integer;
                    var SDVal: double): integer; overload;
function StdDevArray (Arr: TDouble4DArray; ColLo, RowLo, LayerLo, TSlotLo,
                    ColHi, RowHi, LayerHi, TSlotHi: integer;
                    var SDVal: double): integer; overload;
function StdDevArray (Arr: TIntArray; ElemLo, ElemHi: integer;
                    var SDVal: double): integer; overload;
function StdDevArray (Arr: TInt2DArray; ColLo, RowLo, ColHi, RowHi: integer;
                    var SDVal: double): integer; overload;
function StdDevArray (Arr: TInt3DArray; ColLo, RowLo, LayerLo,
                    ColHi, RowHi, LayerHi: integer;
                    var SDVal: double): integer; overload;
function StdDevArray (Arr: TInt4DArray; ColLo, RowLo, LayerLo, TSlotLo,
                    ColHi, RowHi, LayerHi, TSlotHi: integer;
                    var SDVal: double): integer; overload;

function StoreArray (FName: string; Arr: TDoubleArray;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TDouble2DArray;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TDouble3DArray;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TDouble4DArray;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TDouble3DArray; InsertIndices: boolean;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TDouble4DArray; InsertIndices: boolean;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TIntArray;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TInt2DArray;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TInt3DArray;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TInt4DArray;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TInt3DArray; InsertIndices: boolean;
                    Comment: string): integer; overload;
function StoreArray (FName: string; Arr: TInt4DArray; InsertIndices: boolean;
                    Comment: string): integer; overload;

function SubtractArrays (Arr1, Arr2: TDoubleArray;
                    var Difference: TDoubleArray): integer; overload;
function SubtractArrays (Arr1, Arr2: TDouble2DArray;
                    var Difference: TDouble2DArray): integer; overload;
function SubtractArrays (Arr1, Arr2: TDouble3DArray;
                    var Difference: TDouble3DArray): integer; overload;
function SubtractArrays (Arr1, Arr2: TDouble4DArray;
                    var Difference: TDouble4DArray): integer; overload;
function SubtractArrays (Arr1, Arr2: TIntArray;
                    var Difference: TIntArray): integer; overload;
function SubtractArrays (Arr1, Arr2: TInt2DArray;
                    var Difference: TInt2DArray): integer; overload;
function SubtractArrays (Arr1, Arr2: TInt3DArray;
                    var Difference: TInt3DArray): integer; overload;
function SubtractArrays (Arr1, Arr2: TInt4DArray;
                    var Difference: TInt4DArray): integer; overload;

function SumArrayMasked (Mat: TInt2DArray; MaskArray: TBool2DArray;
                         var Sum: double): integer; overload;
function SumArrayMasked (Mat: TDouble2DArray; MaskArray: TBool2DArray;
                         var Sum: double): integer; overload;

function SumOfSquaredDiffs (Arr1, Arr2: TDoubleArray): double; overload;
function SumOfSquaredDiffs (Arr1: TDoubleArray; Arr2: TDouble2DArray;
                            Column: integer): double; overload;

function TraceOfArray (Arr: TInt2DArray; var TrVal: integer): integer; overload;
function TraceOfArray (Arr: TDouble2DArray; var TrVal: double): integer; overload;

function TransposeArray (var Arr: TBool2DArray): integer; overload;
function TransposeArray (var Arr: TInt2DArray): integer; overload;
function TransposeArray (var Arr: TDouble2DArray): integer; overload;

function VectorDotProduct (Vec1, Vec2: TDoubleArray;
                    var Product: double): integer; overload;
function VectorDotProduct (Vec1, Vec2: TIntArray;
                    var Product: integer): integer; overload;
function VectorCrossProduct (Vec1, Vec2: TDoubleArray;
                    var Product: TDoubleArray): integer; overload;
function VectorCrossProduct (Vec1, Vec2: TIntArray;
                    var Product: TIntArray): integer; overload;

// the following implementations are deprecated (see help for details)
function CopyVectorToArrayColumn (SrcVec: TDoubleArray; FirstElem, LastELem,
              CellCol, CellRow: integer;
              var DstArr: TDouble2DArray): integer; overload;
function CopyVectorToArrayColumn (SrcVec: TIntArray; FirstElem, LastELem,
              CellCol, CellRow: integer;
              var DstArr: TInt2DArray): integer; overload;
function CopyVectorToArrayColumn (SrcVec: TBoolArray; FirstElem, LastELem,
              CellCol, CellRow: integer;
              var DstArr: TBool2DArray): integer; overload;
function CopyVectorToArrayRow (SrcVec: TDoubleArray; FirstElem, LastELem,
              CellCol, CellRow: integer;
              var DstArr: TDouble2DArray): integer; overload;
function CopyVectorToArrayRow (SrcVec: TIntArray; FirstElem, LastELem,
              CellCol, CellRow: integer;
              var DstArr: TInt2DArray): integer; overload;
function CopyVectorToArrayRow (SrcVec: TBoolArray; FirstElem, LastELem,
              CellCol, CellRow: integer;
              var DstArr: TBool2DArray): integer; overload;