| The SDL Component Suite is an industry leading collection of components supporting scientific and engineering computing. Please visit the SDL Web site for more information.... |
|
Home  MathPack Matrix Interface of SDL_Matrix |
|
| See also: TMat4D |   |
Interface of SDL_Matrix |
|
const
{$IFDEF PAIDVERS}
SDLVersionInfo = 'matrix_r1210_full';
IsLightEd = false;
{$ELSE}
SDLVersionInfo = 'matrix_r1210_lighted';
IsLightEd = true;
{$ENDIF}
Release = 1210;
type
ESDLMatrixError = class(ESDLError); { exception type to indicate errors }
TMatXmlTag = (xmlMatNumCols, xmlMatNumRows, xmlMatNumLayers, xmlMatNumTimeSlots,
xmlMatCell, xmlMatBegin, xmlMatEnd, xmlInvalid);
TOnCalcDistanceEvent = procedure (Sender: TObject; Row1, Row2: integer;
var Distance: double) of object;
TOnReadMat4DElementEvent = procedure (Sender: TObject; ix, iy, il, it: integer;
Value: double) of object;
TSpMatElemInt = record
colidx : longint;
rowidx : longint;
value : longint;
end;
TNormType = (ntColwise, ntRowwise, ntSpectral, ntFrobenius);
type
TMat3D = class;
{$IFDEF GE_LEV29}
[ComponentPlatformsAttribute(pidWin32 or pidWin64 or pidWin64x)]
{$ENDIF}
TIntMatrix = class (TComponent)
private
FNCol : longint; { number of columns }
FNRow : longint; { number of rows }
FAuxCol : longint;
FAuxRow : longint;
FDataID : string; { tag to identify the data }
FIsSparse : boolean; { TRUE: sparse matrix }
FNumAllocated : longint; { number of allocated sparse elements }
FAllocBy : longint; { incr. of alloc. for sparse matrix }
FSparseNumElem : longint; { number of elements in sparse matrix }
FSparseLowCol : longint;{ index of lowest column in sparse mat }
FSparseHighCol : longint;{index of highest column in sparse mat }
FSparseLowRow : longint; { index of lowest row in sparse mat }
FSparseHighRow : longint; { index of highest row in sparse mat }
SpMat : array of TSpMatElemInt;{ sparse matrix container }
{$IFNDEF SDLPUBLICMAT}
// the array Mat can be made accessible from outside by
// declaring the compiler define SDLPUBLICMAT
// please note this might be dangerous and should be done
// only for special purposes
Mat : TInt2DArray; { matrix data }
{$ENDIF}
FOnChange : TNotifyEvent;
FOnResize : TNotifyEvent;
FOnPercentDone : TOnPercentDoneEvent;
FOnSortExchange : TSortExchgEvent;
FirstCell : boolean;{flag to resize matrix during XML input }
function ProcessXmlTag (xmlTag: TMatXmlTag;
attr, cont: string): integer;
function GetVal (Nc,Nr: longint): integer;
procedure PercDone (Sender: TObject; Percent: longint);
procedure SetVal (Nc,Nr: longint; Value: integer);
procedure SetNCols (value: longint);
procedure SetNRows (value: longint);
procedure SkewKurtIntern (LowCol, LowRow, HighCol, HighRow: integer;
var Skewness, Kurtosis: double; var NumData: longint);
protected
procedure SortExchange (ExchgWhat: byte; index1, index2,
first, last: longint);
public
{$IFDEF SDLPUBLICMAT}
// the array Mat can be made accessible from outside by
// declaring the compiler define SDLPUBLICMAT
// please note this might be dangerous and should be done
// only for special purposes
Mat : TInt2DArray;
procedure SetMatExtentsAfterExternalMatChange;
{$ENDIF}
constructor Create (AOwner: TComponent); override;
constructor CreateSparse (AOwner: TComponent; AllocBy: longint);
destructor Destroy; override;
property Elem[ix,iy: longint]: integer
read GetVal write SetVal; default;
function Add (MatB: TIntMatrix): boolean;
procedure ArrayToSparse (AllocBy: longint);
procedure Changed;
procedure Clone (MatSource: TIntMatrix);
{$IFNDEF DOTNET}
function CRCofData: string;
{$ENDIF}
procedure CopyColToVec (DestVec: TIntVector;
Col, FirstRow, LastRow: integer); overload;
procedure CopyColToVec (DestVec: TIntVector;
Col, FirstRow, LastRow, DestElem: integer); overload;
procedure CopyColTo1DArray (Dest: TIntArray;
Col, FirstRow, LastRow, DestElem: integer);
procedure CopyFrom (MatSource: TIntMatrix; SourceColLo,
SourceRowLo, SourceColHi, SourceRowHi,
DestCol, DestRow: integer);
function CopyFromArray (Src: TDoubleArray; FirstElem, LastElem,
Col, Row: integer;
AsColumn: boolean): integer; overload;
function CopyFromArray (Src: TIntArray; FirstElem, LastElem,
Col, Row: integer;
AsColumn: boolean): integer; overload;
function CopyFromArray (Src: TDouble2DArray; SrcColLo, SrcRowLo,
SrcColHi, SrcRowHi,
Col, Row: integer): integer; overload;
function CopyFromArray (Src: TInt2DArray; SrcColLo, SrcRowLo,
SrcColHi, SrcRowHi,
Col, Row: integer): integer; overload;
function CopyToArray (var Dest: TDouble2DArray;
SrcColLo, SrcRowLo, SrcColHi, SrcRowHi,
DestCol, DestRow: integer): integer; overload;
function CopyToArray (var Dest: TInt2DArray;
SrcColLo, SrcRowLo, SrcColHi, SrcRowHi,
DestCol, DestRow: integer): integer; overload;
procedure CopyRowTo1DArray (Dest: TIntArray;
Row, FirstCol, LastCol, DestElem: integer);
procedure CopyRowToVec (DestVec: TIntVector;
Row, FirstCol, LastCol: integer); overload;
procedure CopyRowToVec (DestVec: TIntVector;
Row, FirstCol, LastCol, DestElem: integer); overload;
function CountValues (LowCol, HighCol, LowRow, HighRow: integer;
RangeLow, RangeHigh: integer): integer;
function CountMaskedZeros (LowCol, HighCol, LowRow, HighRow: integer;
Bitmask: longword): integer;
function Dichotomize (Threshold: integer;
var ResultArray: TBool2DArray): integer;
function DuplicateDataAsArray (var Dest: TInt2DArray): integer;
procedure EdgeVector (Orient: TOrientation;
EdgeOp: TEdgeOp; var Dest: TVector); overload;
function EdgeVector (Orient: TOrientation; EdgeOp: TEdgeOp;
EdgeIx: TIntArray; var Dest: TVector): integer; overload;
function EMult (MatB, MatRes: TIntMatrix): boolean;
procedure ExchangeColumns (c1,c2: integer);
procedure ExchangeRows (r1,r2: integer);
function ExportAsASC (FName: string;
Comment: string): Integer; overload;
function ExportAsASC (FName: string; Comment: string;
CustData: TStr2DArray): Integer; overload;
procedure Fill (value: integer); overload;
procedure Fill (LowCol, HighCol, LowRow, HighRow: integer;
value: integer); overload;
procedure FillDiag (value: integer);
procedure FillSerial (Offset, Diff: integer);
procedure Find (LowCol, HighCol, LowRow, HighRow: integer;
Value: integer; var ColIx, RowIx: integer);
function FindInSortedColumn (Col: integer;
ColIsAscending: boolean; Value: integer): integer;
function GeometricMean (LowCol, LowRow, HighCol,
HighRow: integer): double;
function HarmonicMean (LowCol, LowRow, HighCol,
HighRow: integer): double;
function ImportASC (FName: string;
var Comment: string): integer; overload;
function ImportASC (FName: string; var Comment: string;
var CustData: TStr2DArray): integer; overload;
{$IFNDEF DOTNET}
function LoadBinary (FName: string): integer;
{$ENDIF}
function LoadFromFile (FileName: string;
AdjustMatrixSize: boolean): boolean;
function LoadFromStream (InStream: TMemoryStream;
AdjustMatrixSize: boolean): boolean; overload;
function LoadFromStream (InStream: TFileStream;
AdjustMatrixSize: boolean): boolean; overload;
function LoadFromXMLFile (FName: string; DataID: string): boolean;
function LoadSparseMat (FileName:string): boolean;
function MakeValidColRange (var LowCol, HighCol: integer): integer;
function MakeValidRowRange (var LowRow, HighRow: integer): integer;
procedure MeanVar (LowCol, LowRow, HighCol, HighRow: integer;
var Mean, Variance: double);
procedure MeanVec (Dim: TDims; Means: TVector);
procedure MinMax (LowCol, LowRow, HighCol, HighRow: integer;
var Minimum, Maximum: integer);
procedure MirrorColumns;
procedure MirrorRows;
function Multiply (MatB, MatRes: TIntMatrix): boolean; overload;
function Multiply (VecB, VecRes: TIntVector): boolean; overload;
function MultiplyTransposed (MatB, MatRes: TIntMatrix): boolean;
function Percentile (prob: double; LowCol, LowRow, HighCol,
HighRow: integer): double; overload;
function Percentile (prob: double; LowCol, LowRow, HighCol,
HighRow: integer; SampleSize: integer): double; overload;
function Quartiles (LowCol, LowRow, HighCol,
HighRow: integer; var Q1, Q2, Q3: double): boolean;
{$IFNDEF DOTNET}
function ReadBinaryHeader (FName: string; var NrColumns,
NrRows: integer; var DataID: string;
var Format: integer): boolean;
{$ENDIF}
function ReadFromOpenXMLFile (var InFile: TextFile;
DataID: string): boolean;
function ReadFromXMLStream (InStream: TStream;
DataID: string): boolean;
function RemoveColumn (col: integer): boolean;
function RemoveRow (row: integer): boolean;
function Resize (Nc, Nr: longint): boolean;
procedure Resized;
function ResizeAndClear (Nc, Nr: longint): boolean;
procedure SaveAsXMLFile (FName: string; DataID: string);
{$IFNDEF DOTNET}
procedure SaveBinary (FName: string);
{$ENDIF}
procedure SaveToStream (var OutStream: TMemoryStream;
LoC,LoR,HiC,HiR: integer); overload;
procedure SaveToStream (var OutStream: TFileStream;
LoC,LoR,HiC,HiR: integer); overload;
procedure SkewKurt (LowCol, LowRow, HighCol,
HighRow: integer; var Skewness, Kurtosis: double);
procedure SkewKurtSample (LowCol, LowRow, HighCol, HighRow: integer;
var Skewness, Kurtosis: double);
procedure SAdd (Scalar: integer);
procedure SMult (Scalar: integer);
procedure SortCols (SortRowIx: integer; Ascending: boolean;
LowCol, LowRow, HighCol, HighRow: integer);
procedure SortRows (SortColIx: integer; Ascending: boolean;
LowCol, LowRow, HighCol,
HighRow: integer);
procedure SparseToArray;
function StoreOnFile
(LoC,LoR,HiC,HiR: integer;
FileName:string): boolean;
function StoreSparseMat (FileName:string): boolean;
function Subtract (MatB: TIntMatrix): boolean;
function Sum (LoC,LoR,HiC,HiR: integer): longint;
function Trace: longint;
function Transpose: boolean;
function TransposeAndMultiply
(MatB, MatRes: TIntMatrix): boolean; overload;
function TransposeAndMultiply
(VecB, VecRes: TIntVector): boolean; overload;
procedure WriteToOpenXMLFile (var OutFile : TextFile;
CreateHeader: boolean; DataID: string);
procedure WriteToXMLStream (OutStream: TStream;
CreateHeader: boolean; DataID: string);
published
property DataID: string read FDataID write FDataID;
property NrOfColumns: longint read FNCol write SetNCols;
property NrOfRows: longint read FNRow write SetNRows;
property OnChange: TNotifyEvent read FOnChange write FOnChange;
property OnResize: TNotifyEvent read FOnResize write FOnResize;
property OnSortExchange: TSortExchgEvent
read FOnSortExchange write FOnSortExchange;
property OnPercentDone: TOnPercentDoneEvent
read FOnPercentDone write FOnPercentDone;
end;
{$IFDEF GE_LEV29}
[ComponentPlatformsAttribute(pidWin32 or pidWin64 or pidWin64x)]
{$ENDIF}
TMatrix = class (TComponent)
private
FNCol : longint; { number of columns }
FNRow : longint; { number of rows }
FAuxCol : longint;
FAuxRow : longint;
FDataID : string; { tag to identify the data }
FPrecis : array[1..2] of integer; { used in StoreOnFile }
FOnChange : TNotifyEvent;
FOnResize : TNotifyEvent;
FOnSortExchange : TSortExchgEvent;
FOnCalcDist : TOnCalcDistanceEvent;
FOnPercentDone : TOnPercentDoneEvent;
{$IFNDEF SDLPUBLICMAT}
// the array Mat can be made accessible from outside by
// declaring the compiler define SDLPUBLICMAT
// please note this might be dangerous and should be done
// only for special purposes
Mat : TDouble2DArray; // array of array of double;
{$ENDIF}
FirstCell : boolean; {flag to resize matrix during XML input }
procedure PercDone (Sender: TObject; Percent: longint);
function ProcessXmlTag (xmlTag: TMatXmlTag;
attr, cont: string): integer;
function GetVal (Nc,Nr: longint): double;
procedure SetVal (Nc,Nr: longint; Value: double);
function GetFPrecis (ix: integer): integer;
procedure SetFPrecis (ix: integer; value: integer);
procedure SetNCols (value: longint);
procedure SetNRows (value: longint);
procedure SkewKurtIntern (LowCol, LowRow, HighCol, HighRow: integer;
var Skewness, Kurtosis: double; var NumData: longint);
protected
procedure AssignTo (Dest: TPersistent); override;
procedure SortExchange (ExchgWhat: byte; index1, index2,
first, last: longint);
public
{$IFDEF SDLPUBLICMAT}
// the array Mat can be made accessible from outside by
// declaring the compiler define SDLPUBLICMAT
// please note this might be dangerous and should be done
// only for special purposes
Mat : TDouble2DArray;
procedure SetMatExtentsAfterExternalMatChange;
{$ENDIF}
constructor Create (AOwner: TComponent); override;
destructor Destroy; override;
procedure Assign(Source: TPersistent); override;
property Elem[ix,iy: longint]: double
read GetVal write SetVal; default;
function Add (MatB: TMatrix): boolean;
function Balance (Tolerance: double): boolean;
function CalcDistMat (Mode: TDistMode; DMat: TMatrix): integer;
function CalcHatMatrix (var HatMat: TMatrix): integer;
procedure Changed;
function CholeskyDecomp (var MatL: TMatrix): boolean;
{$IFNDEF DOTNET}
function CRCofData: string;
{$ENDIF}
procedure CopyColTo1DArray (Dest: TDoubleArray;
Col, FirstRow, LastRow, DestElem: integer);
procedure CopyColToVec (DestVec: TVector;
Col, FirstRow, LastRow: integer); overload;
procedure CopyColToVec (DestVec: TVector;
Col, FirstRow, LastRow, DestElem: integer); overload;
procedure CopyFrom (MatSource: TMatrix;
SourceColLo, SourceRowLo,
SourceColHi, SourceRowHi,
DestCol, DestRow: integer); overload;
procedure CopyFrom (MatSource: TIntMatrix;
SourceColLo, SourceRowLo,
SourceColHi, SourceRowHi,
DestCol, DestRow: integer); overload;
procedure CopyFrom (MatSource: TMat3D;
SourceColLo, SourceRowLo,
SourceColHi, SourceRowHi,
SourceLayer,
DestCol, DestRow: integer); overload;
function CopyFromArray (Src: TDoubleArray;
FirstElem, LastElem, Col, Row: integer;
AsColumn: boolean): integer; overload;
function CopyFromArray (Src: TIntArray;
FirstElem, LastElem, Col, Row: integer;
AsColumn: boolean): integer; overload;
function CopyFromArray (Src: TDouble2DArray;
SrcColLo, SrcRowLo, SrcColHi, SrcRowHi,
Col, Row: integer): integer; overload;
function CopyFromArray (Src: Tint2DArray;
SrcColLo, SrcRowLo, SrcColHi, SrcRowHi,
Col, Row: integer): integer; overload;
procedure CopyRowTo1DArray (Dest: TDoubleArray;
Row, FirstCol, LastCol, DestElem: integer);
function CopyToArray (var Dest: TDouble2DArray;
SrcColLo, SrcRowLo, SrcColHi, SrcRowHi,
DestCol, DestRow: integer): integer; overload;
function CopyToArray (var Dest: TInt2DArray;
SrcColLo, SrcRowLo, SrcColHi, SrcRowHi,
DestCol, DestRow: integer): integer; overload;
function Correlate (OtherMat: TMatrix): double;
procedure Clone (MatSource: TMatrix);
procedure CopyFromVec (Src: TVector;
FirstElem, LastElem,
DestCol, DestRow: integer); overload;
procedure CopyFromVec (Dim: TDims; Src: TVector;
FirstElem, LastElem,
DestCol, DestRow: integer); overload;
procedure CopyFromVec (Src: TVector;
FirstElem, LastElem, DestCol, DestRow: integer;
AsColumn: boolean); overload;
procedure CopyRowToVec (DestVec: TVector;
Row, FirstCol, LastCol: integer); overload;
procedure CopyRowToVec (DestVec: TVector;
Row, FirstCol, LastCol, DestElem: integer); overload;
function CountValues (LowCol, HighCol, LowRow, HighRow: integer;
RangeLow, RangeHigh: double): integer;
function Dichotomize (Threshold: double;
var ResultArray: TBool2DArray): integer;
function DuplicateDataAsArray (var Dest: TDouble2DArray): integer;
function Square (MatRes: TMatrix; Norm: double): boolean; overload;
function Square (MatRes: TMatrix; Norm: double;
NThreads: integer): boolean; overload;
function Determinant: double;
function Diff (Order: integer; Mode: TApplyColRow): integer;
function DistanceOfObjects (Mode: TDistMode;
obj1, obj2: integer): double;
function EMult (MatB, MatRes: TMatrix): boolean;
procedure EdgeVector (Orient: TOrientation; EdgeOp: TEdgeOp;
var Dest: TVector); overload;
function EdgeVector (Orient: TOrientation; EdgeOp: TEdgeOp;
EdgeIx: TIntArray; var Dest: TVector): integer; overload;
procedure ExchangeColumns (c1,c2: integer);
procedure ExchangeRows (r1,r2: integer);
function ExportAsASC (FName: string; Precision: integer;
Comment: string): Integer; overload;
function ExportAsASC (FName: string; Precision: integer;
Comment: string;
CustData: TStr2DArray): integer; overload;
procedure Fill (value: double); overload;
procedure Fill (LowCol, HighCol, LowRow, HighRow: integer;
value: double); overload;
procedure FillDiag (value: double);
procedure FillRandomUniform (RangeLow, RangeHigh: double); overload;
procedure FillRandomUniform (LowCol, HighCol, LowRow, HighRow: integer;
RangeLow, RangeHigh: double); overload;
procedure FillRandomGauss (Mean, StdDev: double); overload;
procedure FillRandomGauss (LowCol, HighCol, LowRow, HighRow: integer;
Mean, StdDev: double); overload;
procedure FillSerial (Offset, Diff: double);
procedure Find (LowCol, HighCol, LowRow, HighRow: integer;
Value: double; var ColIx, RowIx: integer);
function FindInSortedColumn (Col: integer;
ColIsAscending: boolean; Value: double): integer;
procedure Free;
function GeometricMean (LowCol, LowRow, HighCol,
HighRow: integer): double;
function HarmonicMean (LowCol, LowRow, HighCol,
HighRow: integer): double;
function Histogram (LoX, LoY, HiX, HiY: longint;
FirstBin, LastBin, BinWidth: double;
var Histo: TIntArray; var Underflow, Overflow,
MaxCnt: longint): boolean; overload;
function Histogram (LoX, LoY, HiX, HiY: longint;
FirstBin, LastBin, BinWidth: double;
Histo: TIntVector; var Underflow, Overflow,
MaxCnt: longint): boolean; overload;
function ImportASC (FName: string;
var Comment: string): integer; overload;
function ImportASC (FName: string; var Comment: string;
var CustData: TStr2DArray): integer; overload;
function Invert: boolean;
{$IFNDEF DOTNET}
function LoadBinary (FName: string): integer;
{$ENDIF}
function LoadFromFile (FileName: string;
AdjustMatrixSize: boolean): boolean; overload;
function LoadFromFile (FileName: string; AdjustMatrixSize,
AutoDetect: boolean): boolean; overload;
function LoadFromStream (InStream: TMemoryStream;
AdjustMatrixSize: boolean): boolean; overload;
function LoadFromStream (InStream: TFileStream;
AdjustMatrixSize: boolean): boolean; overload;
function LoadFromXMLFile (FName: string; DataID: string): boolean;
function LUdecomposition (var MatL, MatU: TMatrix): boolean;
function MakeValidColRange (var LowCol, HighCol: integer): integer;
function MakeValidRowRange (var LowRow, HighRow: integer): integer;
procedure MeanCenterColumns (Means: TVector);
procedure MeanCenterRows (Means: TVector);
procedure MeanVar (LowCol, LowRow, HighCol,
HighRow: integer; var Mean,
Variance: double);
procedure MeanVec (Dim: TDims; Means: TVector);
procedure MinMax (LowCol, LowRow, HighCol,
HighRow: integer; var Minimum,
Maximum: double);
procedure MirrorColumns;
procedure MirrorRows;
function Multiply (MatB, MatRes: TMatrix): boolean; overload;
function Multiply (VecB, VecRes: TVector): boolean; overload;
function MultiplyTransposed (MatB, MatRes: TMatrix): boolean;
function Norm (nt: TNormType): double;
function Percentile (prob: double; LowCol, LowRow,
HighCol, HighRow: integer): double; overload;
function Percentile (prob: double; LowCol, LowRow, HighCol,
HighRow: integer; SampleSize: integer): double; overload;
property Precision [Index: integer]: integer
read GetFPrecis write SetFPrecis;
procedure QNormalizeColumns (RefQuant: double;
Medians, QuantDiffs: TVector);
procedure QNormalizeRows (RefQuant: double;
Medians, QuantDiffs: TVector);
function Quartiles (LowCol, LowRow, HighCol,
HighRow: integer; var Q1, Q2, Q3: double): boolean;
{$IFNDEF DOTNET}
function ReadBinaryHeader (FName: string; var NrColumns,
NrRows: integer; var DataID: string;
var Format: integer): boolean;
{$ENDIF}
function ReadFromXMLStream (InStream: TStream;
DataID: string): boolean;
function ReadFromOpenXMLFile (var InFile: TextFile;
DataID: string): boolean;
function RemoveColumn (col: integer): boolean;
function RemoveRow (row: integer): boolean;
function ResampleExtMat (SrcMat: TMatrix; colpct, rowpct: double;
BootStrap: boolean; var RndColIx,
RndRowIx: TIntArray): integer;
function Resize (Nc, Nr: longint): boolean;
procedure Resized;
function ResizeAndClear (Nc, Nr: longint): boolean;
procedure SaveAsXMLFile (FName: string; DataID: string);
{$IFNDEF DOTNET}
procedure SaveBinary (FName: string);
{$ENDIF}
procedure SaveToStream (var OutStream: TMemoryStream;
LoC,LoR,HiC,HiR: integer); overload;
procedure SaveToStream (var OutStream: TFileStream;
LoC,LoR,HiC,HiR: integer); overload;
procedure SkewKurt (LowCol, LowRow, HighCol,
HighRow: integer; var Skewness, Kurtosis: double);
procedure SkewKurtSample (LowCol, LowRow, HighCol,
HighRow: integer; var Skewness, Kurtosis: double);
procedure SAdd (Scalar: double);
procedure SMult (Scalar: double);
procedure SortCols (SortRowIx: integer; Ascending: boolean;
LowCol, LowRow, HighCol, HighRow: integer);
procedure SortRows (SortColIx: integer; Ascending: boolean;
LowCol, LowRow, HighCol,
HighRow: integer);
procedure StandardizeColumns (Means, StdDevs: TVector);
procedure StandardizeRows (Means, StdDevs: TVector);
function StoreOnFile
(LoC,LoR,HiC,HiR: integer;
FileName:string): boolean;
function Subtract (MatB: TMatrix): boolean;
function Sum (LoC,LoR,HiC,HiR: integer): double;
function Transpose: boolean;
function TransposeAndMultiply
(MatB, MatRes: TMatrix): boolean; overload;
function TransposeAndMultiply
(VecB: TVector; VecRes: TVector): boolean; overload;
function Trace: double;
procedure WriteToOpenXMLFile(var OutFile : TextFile;
CreateHeader: boolean; DataID: string);
procedure WriteToXMLStream (OutStream: TStream;
CreateHeader: boolean; DataID: string);
published
property NrOfColumns: longint read FNCol write SetNCols;
property NrOfRows: longint read FNRow write SetNRows;
property DataID: string read FDataID write FDataID;
property OnChange: TNotifyEvent read FOnChange write FOnChange;
property OnResize: TNotifyEvent read FOnResize write FOnResize;
property OnSortExchange: TSortExchgEvent
read FOnSortExchange write FOnSortExchange;
property OnCalcDistance: TOnCalcDistanceEvent
read FOnCalcDist write FOnCalcDist;
property OnPercentDone: TOnPercentDoneEvent
read FOnPercentDone write FOnPercentDone;
end;
{$IFDEF GE_LEV29}
[ComponentPlatformsAttribute(pidWin32 or pidWin64 or pidWin64x)]
{$ENDIF}
TMat3D = class (TComponent)
private
FNumX : longint; { number of columns }
FNumY : longint; { number of rows }
FNumZ : longint; { number of layers }
FAuxNx : longint;
FAuxNy : longint;
FAuxNz : longint;
FDataID : string; { tag to identify the data }
{$IFNDEF SDLPUBLICMAT}
// the array Mat can be made accessible from outside by
// declaring the compiler define SDLPUBLICMAT
// please note this might be dangerous and should be done
// only for special purposes
Mat : TDouble3DArray;
{$ENDIF}
FOnChange : TNotifyEvent;
FOnResize : TNotifyEvent;
FOnPercentDone : TOnPercentDoneEvent;
FirstCell : boolean;{flag to resize matrix during input from XML }
function ProcessXmlTag (xmlTag: TMatXmlTag; attr,
cont: string): integer;
procedure PercDone (Sender: TObject; Percent: longint);
function GetVal (Nx,Ny,Nz: longint): double;
procedure SetVal (Nx,Ny,Nz: longint; Value: double);
procedure SetNCols (value: longint);
procedure SetNRows (value: longint);
procedure SetNLayers (value: longint);
public
{$IFDEF SDLPUBLICMAT}
// the array Mat can be made accessible from outside by
// declaring the compiler define SDLPUBLICMAT
// please note this might be dangerous and should be done
// only for special purposes
Mat : TDouble3DArray;
procedure SetMatExtentsAfterExternalMatChange;
{$ENDIF}
constructor Create (AOwner: TComponent); override;
destructor Destroy; override;
procedure Changed;
procedure Clone (MatSource: TMat3D);
procedure CopyLayerToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, Layer: integer);
procedure CopyMatrixToLayer (SrcMat: TMatrix; SrcLowCol, SrcHighCol,
SrcLowRow, SrcHighRow, Layer,
LayLowCol, LayLowRow: integer);
{$IFNDEF DOTNET}
function CRCofData: string;
{$ENDIF}
property Elem[ix,iy,iz: longint]: double
read GetVal write SetVal; default;
procedure Fill (value: double);
procedure FillDiag (value: double);
procedure FillRandomUniform (RangeLow, RangeHigh: double);
procedure FillRandomGauss (Mean, StdDev: double);
procedure FillSerial (Offset, Diff: double);
procedure Find (LowCol, HighCol, LowRow, HighRow, LowLayer,
HighLayer: integer; Value: double;
var ColIx, RowIx, LayerIx: integer);
function LoadBinary (FName: string): integer;
function LoadFromXMLFile (FName: string; DataID: string): boolean;
function MakeValidColRange (var LowCol, HighCol: integer): integer;
function MakeValidRowRange (var LowRow, HighRow: integer): integer;
function MakeValidLayerRange
(var LowLayer, HighLayer: integer): integer;
procedure MeanVar (LowCol, HighCol, LowRow, HighRow,
LowLayer, HighLayer: integer;
var Mean, Variance: double);
procedure MinMax (LowCol, HighCol, LowRow, HighRow, LowLayer,
HighLayer: integer; var Minimum, Maximum: double);
function Percentile (prob: double; LowCol, HighCol,
LowRow, HighRow,
LowLayer, HighLayer: integer): double; overload;
function Percentile (prob: double; LowCol, HighCol, LowRow,
HighRow, LowLayer, HighLayer: integer;
SampleSize: integer): double; overload;
function ReadBinaryHeader (FName: string;
var NrColumns, NrRows, NrLayers, NrTimeSlots: integer;
var DataID: string; var Format: integer): boolean;
function ReadFromOpenXMLFile (var InFile: TextFile;
DataID: string): boolean;
function ReadFromXMLStream (InStream: TStream;
DataID: string): boolean;
function Resize (Nc, Nr, Nl: longint): boolean;
procedure Resized;
function ResizeAndClear (Nc, Nr, Nl: longint): boolean;
procedure SaveAsXMLFile (FName: string; DataID: string);
procedure SaveBinary (FName: string);
procedure WriteToOpenXMLFile (var OutFile : TextFile;
CreateHeader: boolean; DataID: string);
procedure WriteToXMLStream (OutStream: TStream;
CreateHeader: boolean; DataID: string);
published
property DataID: string read FDataID write FDataID;
property NrOfColumns: longint read FNumX write SetNCols;
property NrOfRows: longint read FNumY write SetNRows;
property NrOfLayers: longint read FNumZ write SetNLayers;
property OnChange: TNotifyEvent read FOnChange write FOnChange;
property OnResize: TNotifyEvent read FOnResize write FOnResize;
property OnPercentDone: TOnPercentDoneEvent
read FOnPercentDone write FOnPercentDone;
end;
{$IFNDEF DOTNET}
{$IFDEF GE_LEV29}
[ComponentPlatformsAttribute(pidWin32 or pidWin64 or pidWin64x)]
{$ENDIF}
TMat4D = class (TComponent)
private
FNumX : longint; { number of columns }
FNumY : longint; { number of rows }
FNumZ : longint; { number of layers }
FNumT : longint; { number of time slots }
FAuxNx : longint;
FAuxNy : longint;
FAuxNz : longint;
FAuxNt : longint;
FDataID : string; { tag to identify the data }
{$IFNDEF SDLPUBLICMAT}
// the array Mat can be made accessible from outside by
// declaring the compiler define SDLPUBLICMAT
// please note this might be dangerous and should be done
// only for special purposes
Mat : TDouble4DArray;
{$ENDIF}
FOnChange : TNotifyEvent;
FOnResize : TNotifyEvent;
FOnPercentDone : TOnPercentDoneEvent;
FOnReadElement : TOnReadMat4DElementEvent;
FirstCell : boolean;{flag to resize matrix during input from XML }
function ProcessXmlTag (xmlTag: TMatXmlTag; attr,
cont: string): integer;
function GetVal (Nx,Ny,Nz,Nt: longint): double;
procedure SetVal (Nx,Ny,Nz,Nt: longint; Value: double);
procedure SetNCols (value: longint);
procedure SetNRows (value: longint);
procedure SetNLayers (value: longint);
procedure SetNTSlots (value: longint);
procedure PercDone (Sender: TObject; Percent: longint);
procedure ReadElement (Sender: TObject; ix, iy, il, it: integer;
Value: double);
function LoadBinaryIntern (FName: string;
TSlotStart, TSlotEnd: integer;
PreventFmtCheck: boolean): integer;
protected
procedure AssignTo (Dest: TPersistent); override;
public
{$IFDEF SDLPUBLICMAT}
// the array Mat can be made accessible from outside by
// declaring the compiler define SDLPUBLICMAT
// please note this might be dangerous and should be done
// only for special purposes
Mat : TDouble4DArray;
procedure SetMatExtentsAfterExternalMatChange;
{$ENDIF}
function AccumulateLayer (Layer, TimeSlot: integer;
Src: TDouble2DArray): integer;
function AppendToBinaryFile (FName: string; TSlotStart,
TSlotEnd: integer): integer;
procedure Assign(Source: TPersistent); override;
constructor Create (AOwner: TComponent); override;
destructor Destroy; override;
procedure Changed;
procedure Clone (MatSource: TMat4D);
function ConvertLinTo3DAddr (LinAddr: integer;
var ix, iy, il: integer): boolean;
function CopyArrayToLayer (SrcArray: TDouble2DArray; Col, Row,
Layer, TimeSlot: integer): integer;
function Copy1DArrayToPixel (Src: TDoubleArray; Col, Row,
FirstLayer, TimeSlot: integer): integer;
procedure CopyTimeSlotToMat3D (DestMat: TMat3D; LowCol, HighCol,
LowRow, HighRow, LowLay, HighLay, TimeSlot: integer);
function CopyTimeSlotToArray (var DestMat: TDouble3DArray;
LowCol, HighCol, LowRow, HighRow, LowLay, HighLay,
TimeSlot: integer): integer;
procedure CopyMat3DToTimeSlot (SrcMat: TMat3D; SrcLowCol,
SrcHighCol, SrcLowRow, SrcHighRow, SrcLowLay,
SrcHighLay, TimeSlot, DestCol, DestRow,
DestLayer: integer);
function CopyArrayToTimeSlot (SrcMat: TDouble3DArray; SrcLowCol,
SrcHighCol, SrcLowRow, SrcHighRow, SrcLowLay, SrcHighLay,
TimeSlot, DestCol, DestRow, DestLayer: integer): integer;
procedure CopyFrom (MatSource: TMat4D;
SrcLowCol, SrcHighCol, SrcLowRow, SrcHighRow,
SrcLowLayer, SrcHighLayer, SrcLowTSlot,
SrcHighTSlot, DestCol, DestRow,
DestLayer, DestTSlot: integer);
procedure CopyLayerToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, Layer, TimeSlot: integer);
function CopyLayerToArray (var DestArray: TDouble2DArray;
LowCol, HighCol, LowRow, HighRow,
Layer, TimeSlot: integer): integer;
procedure CopyMatrixToLayer (SrcMat: TMatrix; SrcLowCol, SrcHighCol,
SrcLowRow, SrcHighRow, Layer, TimeSlot,
LayLowCol, LayLowRow: integer);
function CopyPixelTo1DArray (var Dest: TDoubleArray;
Col, Row, TimeSlot: integer): integer;
function CopyPixelToVector (var Dest: TVector;
Col, Row, TimeSlot: integer): integer;
function CopyVectorToPixel (Src: TVector; Col, Row,
FirstLayer, TimeSlot: integer): integer;
function CountValues (LowCol, HighCol, LowRow, HighRow,
LowLayer, HighLayer, LowTimeslot, HighTimeslot: integer;
RangeLow, RangeHigh: double): integer;
function CRCofData: string; overload;
function CRCofData (Sample: integer): string; overload;
procedure Cut (LowCol, HighCol, LowRow, HighRow, LowLayer, HighLayer,
LowTimeslot, HighTimeslot: integer);
procedure Resample (XDiv, XOffset, YDiv, YOffset, ZDiv, ZOffset,
TDiv, TOffset: integer; Average: boolean);
property Elem[ix,iy,iz,it: longint]: double
read GetVal write SetVal; default;
procedure Fill (value: double);
procedure FillDiag (value: double);
procedure FillLayer (Layer: integer; value: double); overload;
function FillLayer (Layer, TimeSlot: integer; Mode: integer;
par1, par2: double): integer; overload;
procedure FillRandomUniform (RangeLow, RangeHigh: double);
procedure FillRandomGauss (Mean, StdDev: double);
procedure FillSerial (Offset, Diff: double);
procedure Find (LowCol, HighCol, LowRow, HighRow, LowLayer,
HighLayer, LowTimeSlot, HighTimeSlot: integer;
Value: double;
var ColIx, RowIx, LayerIx, TimeSlotIx: integer);
function Lin3DAddr (ix, iy, il: integer): integer;
function LoadBinary (FName: string;
TSlotStart, TSlotEnd: integer): integer;
function LoadBinaryNoFmtCheck (FName: string;
TSlotStart, TSlotEnd: integer): integer;
function LoadFromXMLFile (FName: string; DataID: string): boolean;
function MakeValidColRange (var LowCol, HighCol: integer): integer;
function MakeValidRowRange (var LowRow, HighRow: integer): integer;
function MakeValidLayerRange
(var LowLayer, HighLayer: integer): integer;
function MakeValidTSlotRange
(var LowTSlot, HighTSlot: integer): integer;
procedure MaximumOfLayersToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot: integer); overload;
procedure MaximumOfLayersToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot, NThreads: integer); overload;
procedure MeanOfLayersToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot: integer); overload;
procedure MeanOfLayersToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot, NThreads: integer); overload;
function MemoryConsumed: double;
procedure MinimumOfLayersToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot: integer); overload;
procedure MinimumOfLayersToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot, NThreads: integer); overload;
procedure MinMax (LowCol, HighCol, LowRow, HighRow,
LowLayer, HighLayer, LowTimeSlot, HighTimeSlot: integer;
var Minimum, Maximum: double);
procedure MeanVar (LowCol, HighCol, LowRow, HighRow,
LowLayer, HighLayer, LowTimeSlot, HighTimeSlot: integer;
var Mean, Variance: double);
procedure MirrorColumns;
procedure MirrorRows;
procedure MirrorLayers;
procedure MirrorTimeSlots;
function MultiplyLayersByArray (FactorArray: TDouble2DArray; LowCol,
HighCol, LowRow, HighRow, LowLayer, HighLayer,
LowTimeSlot, HighTimeSlot: integer): integer;
function Percentile (prob: double; LowCol, HighCol, LowRow,
HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot: integer): double; overload;
function Percentile (prob: double; LowCol, HighCol, LowRow,
HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot: integer;
SampleSize: integer): double; overload;
function Percentile (prob: double; LowCol, HighCol, LowRow,
HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot: integer; SampleSize: integer;
AbundantVal: double): double; overload;
function ReadBinary (FName: string;
TSlotStart, TSlotEnd: integer): integer;
function ReadBinaryHeader (FName: string;
var NrColumns, NrRows, NrLayers, NrTimeSlots: integer;
var DataID: string; var Format: integer): boolean;
function ReadFromOpenXMLFile (var InFile: TextFile;
DataID: string): boolean;
function ReadLayer (FName: string; Layer, TSlot: integer): integer;
function Resize (Nc, Nr, Nl, Nt: longint): boolean;
procedure Resized;
function ResizeAndClear (Nc, Nr, Nl, Nt: longint): boolean;
function SaveBinary (FName: string;
TSlotStart, TSlotEnd: integer): integer;
procedure SaveAsXMLFile (FName: string; DataID: string);
procedure StdDevOfLayersToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot: integer); overload;
procedure StdDevOfLayersToMatrix (DestMat: TMatrix; LowCol, HighCol,
LowRow, HighRow, LowLayer, HighLayer, LowTimeSlot,
HighTimeSlot, NThreads: integer); overload;
function Sum (LowCol, HighCol, LowRow, HighRow, LowLayer,
HighLayer, LowTimeSlot, HighTimeSlot: integer): double;
function SquaredSum (LowCol, HighCol, LowRow, HighRow, LowLayer,
HighLayer, LowTimeSlot, HighTimeSlot: integer): double;
function Transpose: boolean;
procedure WriteToOpenXMLFile (var OutFile : TextFile;
CreateHeader: boolean; DataID: string);
published
property DataID: string read FDataID write FDataID;
property NrOfColumns: longint read FNumX write SetNCols;
property NrOfRows: longint read FNumY write SetNRows;
property NrOfLayers: longint read FNumZ write SetNLayers;
property NrOfTimeSlots: longint read FNumT write SetNTSlots;
property OnChange: TNotifyEvent read FOnChange write FOnChange;
property OnResize: TNotifyEvent read FOnResize write FOnResize;
property OnPercentDone: TOnPercentDoneEvent
read FOnPercentDone write FOnPercentDone;
property OnReadElement: TOnReadMat4DElementEvent
read FOnReadElement write FOnReadElement;
end;
{$ENDIF}
procedure CopyArr3DLayerToArr2D (SourceArray: TDouble3DArray;
var DestArray: TDouble2DArray;
LowCol, HighCol, LowRow, HighRow, Layer: integer);
procedure CopyArr3DLayerToMatrix (SourceArray: TDouble3DArray; DestMat: TMatrix;
LowCol, HighCol, LowRow, HighRow, Layer: integer);
procedure CopyMatrixToArray (SourceMat: TMatrix; var DestArray: TDouble2DArray;
LowCol, HighCol, LowRow, HighRow: integer);
function Read4DLayerAndAccumulate (FName: string; Layer, TSlot: integer;
var Data: TDouble2DArray): integer;
function Read4DLayer (FName: string; Layer, TSlot: integer;
var Data: TDouble2DArray): integer;
|
|
Last Update: 2023-Feb-06