object algebra

Back
{Linear algebra extra utilities (mainly for testing)
author: Nikolai Shokhirev
created: 2002.02.02
last modified 2004.06.06)
ŠNikolai V. Shokhirev, 2001-2004 }
unit uDynArrUtilsX;

interface

uses
  uMatTypes, uDynArrays;

function IsEqual(expected, actual: complex; var msg: string; eps: TFloat = 1.0e-12): boolean; overload;
function IsEqual(expected, actual: TFloat; var msg: string; eps: TFloat = 1.0e-12): boolean; overload;
function IsEqual(expected, actual: TInt; var msg: string): boolean; overload;
function IsEqual(expected, actual: boolean; var msg: string): boolean; overload;

{ result := A1 = A2 }
function SameArr(const A1, A2: IBArr1D; var msg: string): boolean; overload;
{ result := A1 = A2 }
function SameArr(const A1, A2: IBArr2D; var msg: string): boolean; overload;
{ result := A1 = A2 }
function SameArr(const A1, A2: IiArr1D; var msg: string): boolean; overload;
{ result := A1 = A2 }
function SameArr(const A1, A2: IIArr2D; var msg: string): boolean; overload;
{ result := A1 = A2 }
function SameArr(const A1, A2: IIArr3D; var msg: string): boolean; overload;
{ result := max |A1 = A2| < eps }
function SameArr(const A1, A2: IFArr1D; var msg: string; eps: TFloat): boolean; overload;
{ result := max |A1 = A2| < eps }
function SameArr(const A1, A2: IFArr2D; var msg: string; eps: TFloat): boolean; overload;
{ result := max |A1 = A2| < eps }
function SameArr(const A1, A2: IFArr3D; var msg: string; eps: TFloat): boolean; overload;
{ result := max |A1 = A2| < eps }
function SameArr(const A1, A2: ICArr1D; var msg: string; eps: TFloat): boolean; overload;
{ result := max |A1 = A2| < eps }
function SameArr(const A1, A2: ICArr2D; var msg: string; eps: TFloat): boolean; overload;

{ i-th vector of idx-th dimension of AR }
function GetArr1D(const A2D: IBArr2D; i: TInt; st: TSliceType): IBArr1D; overload;
{ i-th vector of idx-th dimension of AR }
function GetArr1D(const A2D: IIArr2D; i: TInt; st: TSliceType): IIArr1D; overload;
{ i-th vector of idx-th dimension of AR }
function GetArr1D(const A2D: IFArr2D; i: TInt; st: TSliceType): IFArr1D; overload;

{ Copy A1D to i-th vector of idx-th dimension of A2D }
procedure CopyArr1D(const A2D: IBArr2D; const A1D: IBArr1D; i: TInt; st: TSliceType); overload;
{ Copy A1D to i-th vector of idx-th dimension of A2D }
procedure CopyArr1D(const A2D: IIArr2D; const A1D: IIArr1D; i: TInt; st: TSliceType); overload;
{ Copy A1D to i-th vector of idx-th dimension of A2D }
procedure CopyArr1D(const A2D: IFArr2D; const A1D: IFArr1D; i: TInt; st: TSliceType); overload;

{ AL := AR boolean 1D}
procedure CopyAA(const AL, AR: IBArr1D); overload;
{ AL := AR boolean 2D}
procedure CopyAA(const AL, AR: IBArr2D); overload;
{ AL := AR integer 1D}
procedure CopyAA(const AL, AR: IIArr1D); overload;
{ AL := AR integer 2D}
procedure CopyAA(const AL, AR: IIArr2D); overload;
{ AL := AR integer 3D}
procedure CopyAA(const AL, AR: IIArr3D); overload;
{ AL := AR float 1D}
procedure CopyAA(const AL, AR: IFArr1D); overload;
{ AL := AR float 2D}
procedure CopyAA(const AL, AR: IFArr2D); overload;
{ AL := AR float 3D}
procedure CopyAA(const AL, AR: IFArr3D); overload;

{ i-th vector of idx-th dimension of AR }
function GetArr1D(const A2D: IBArr2D; i, idx: TInt): IBArr1D; overload;
{ i-th vector of idx-th dimension of AR }
function GetArr1D(const A2D: IIArr2D; i, idx: TInt): IIArr1D; overload;
{ i-th vector of idx-th dimension of AR }
function GetArr1D(const A2D: IFArr2D; i, idx: TInt): IFArr1D; overload;

{ Al := (i-th vector of idx-th dimension of A2D }
procedure CopyTo1D(const A1D: IBArr1D; const A2D: IBArr2D; i, idx: TInt); overload;
{ Al := (i-th vector of idx-th dimension of A2D }
procedure CopyTo1D(const A1D: IIArr1D; const A2D: IIArr2D; i, idx: TInt); overload;
{ Al := (i-th vector of idx-th dimension of A2D }
procedure CopyTo1D(const A1D: IFArr1D; const A2D: IFArr2D; i, idx: TInt); overload;
{ Al := (i-th matrix of idx-th dimension of A3D }
procedure CopyTo2D(const A2D: IIArr2D; const A3D: IIArr3D; i, idx: TInt); overload;
{ Al := (i-th matrix of idx-th dimension of A3D }
procedure CopyTo2D(const A2D: IFArr2D; const A3D: IFArr3D; i, idx: TInt); overload;

{ Al := (i-th vector of idx-th dimension of AR }
procedure CopyFrom1D(const A2D: IIArr2D; const A1D: IIArr1D; i, idx: TInt); overload;
{ Al := (i-th vector of idx-th dimension of AR }
procedure CopyFrom1D(const A2D: IFArr2D; const A1D: IFArr1D; i, idx: TInt); overload;

{ A := CxA }
procedure CxArr(C: TInt; const A: IIArr1D); overload;
{ A := CxA }
procedure CxArr(C: TInt; const A: IIArr2D); overload;
{ A := CxA }
procedure CxArr(C: TInt; const A: IIArr3D); overload;
{ A := CxA }
procedure CxArr(C: TFloat; const A: IFArr1D); overload;
{ A := CxA }
procedure CxArr(C: TFloat; const A: IFArr2D); overload;
{ A := CxA }
procedure CxArr(C: TFloat; const A: IFArr3D); overload;
{ A := CxA }
procedure CxArr(C: Complex; const A: ICArr1D); overload;
{ A := CxA }
procedure CxArr(C: Complex; const A: ICArr2D); overload;

{ A[ ] := val }
procedure Fill(const A: IBArr1D; val: boolean); overload;
{ A[ ] := val }
procedure Fill(const A: IBArr2D; val: boolean); overload;
{ A[ ] := val }
procedure Fill(const A: IIArr1D; val: TInt); overload;
{ A[ ] := val }
procedure Fill(const A: IIArr2D; val: TInt); overload;
{ A[ ] := val }
procedure Fill(const A: IIArr3D; val: TInt); overload;
{ A[ ] := val }
procedure Fill(const A: IFArr1D; val: TFloat); overload;
{ A[ ] := val }
procedure Fill(const A: IFArr2D; val: TFloat); overload;
{ A[ ] := val }
procedure Fill(const A: IFArr3D; val: TFloat); overload;
{ A[ ] := val }
procedure Fill(const A: ICArr1D; val: Complex); overload;
{ A[ ] := val }
procedure Fill(const A: ICArr2D; val: Complex); overload;

implementation

uses
  SysUtils, uDynArrUtils;

end.
Back
Generated by Lore's Source to HTML Converter ( http://www.newty.de/lsc/index.html )