{@abstract(Object algebra routines)
author: Nikolai Shokhirev )
created: June 6, 2002)
last modified: June 06, 2003)
ŠNikolai V. Shokhirev, 2002-2003
}
unit uObjAlg;

interface

uses
  uMatTypes, uTensors, uArrays, uLinAlg, uCompoundArrays;

{ Matrix transposition }
function Transpose(const M: IMatrix): IMatrix;

{ SumVt = c1*V1 + c2*V2 + . . . }
function SumVt(cc: array of TFloat; const VV: array of IVector; var err: TInt): IVector;

{ SumMt = c1*M1 + c2*M2 + . . . }
function SumMt(cc: array of TFloat; const MM: array of IMatrix; var err: TInt): IMatrix;

{ M := M + d }
procedure MtShiftDiag(const M: ITensor2D; const d: TFloat; var err: TInt);
{ M := M + D }
procedure MtAddDiag(const M: ITensor2D; const D: ITensor1D; var err: TInt);

{ Dot (scalar) product of two vectors VtxVt = VL*VR }
function VtxVt(const VL, VR: IVector; var err: TInt): TFloat;

{ vector-matrix product: VtxMt = V*M = MT*V }
function VtxMt(const VL: ITensor1D; const MR: IMatrix; var err: TInt): IVector;

{ matrix-vector product: MtxVt = M*V = V*MT }
function MtxVt(const ML: IMatrix; const VR: IVector; var err: TInt): IVector;

{ matrix-matrix product: MtxMt = ML*MR }
function MtxMt(const ML, MR: IMatrix; var err: TInt): IMatrix;

{ matrix-matrix product: MtTxMt = Transpose(ML)*MR  }
function MtTxMt(const ML, MR: IMatrix; var err: TInt): IMatrix;

{ matrix-matrix product: MtxMtT = ML*Transpose(MR) }
function MtxMtT(const ML, MR: IMatrix; var err: TInt): IMatrix;

{ matrix-matrix product: MtTxMtT = Transpose(ML)*Transpose(MR) }
function MtTxMtT(const ML, MR: IMatrix; var err: TInt): IMatrix;

{ matrix-matrix product: DxMt = DiagonalMatrix(DL)*MR }
function DxMt(const DL: IVector; const MR: IMatrix; var err: TInt): IMatrix;

{ matrix-matrix product: MtxD = ML*DiagonalMatrix(DR) }
function MtxD(const ML: IMatrix; const DR: IVector; var err: TInt): IMatrix;

{ matrix-matrix product: MtxDxMtT = M*DiagonalMatrix(D)*Transpose(M) }
function MtxDxMtT(const M: IMatrix; const D: IVector; var err: TInt): IMatrix;
{ matrix-matrix product: MtxDxMtT = Transpose(M)*DiagonalMatrix(D)*M }
function MtTxDxMt(const M: IMatrix; const D: IVector; var err: TInt): IMatrix;
{ matrix-matrix product: Mt1xDxMt2T = M*DiagonalMatrix(D)*Transpose(M) }
function Mt1xDxMt2T(const M1: IMatrix; const D: IVector; const M2: IMatrix;
                                                        var err: TInt): IMatrix;
{ matrix-matrix product: Mt1TxDxMt2 = Transpose(M)*DiagonalMatrix(D)*M }
function Mt1TxDxMt2(const M1: IMatrix; const D: IVector; const M2: IMatrix;
                                                        var err: TInt): IMatrix;

{ Complex Algebra routines with real objects:  }

{ SumCVt = c1*V1 + c2*V2,  c1=c1r+i*c1i, c2=c2r+i*c2i }
function SumCVt(c1r, c1i, c2r, c2i: TFloat; const V1, V2: ICVector; var err: TInt): ICVector;

{ SumCMt = c1*M1 + c2*M2,  c1=c1r+i*c1i, c2=c2r+i*c2i }
function SumCMt(c1r, c1i, c2r, c2i: TFloat; const M1, M2: ICMatrix; var err: TInt): ICMatrix;

{ Dot (scalar) product of two vectors CVtxCVt=VL*VR }
procedure CVtxCVt(const VL, VR: ICVector; var ReResult, ImResult: TFloat; var err: TInt);

{ vector-matrix product: CVtxCMt = V*M = MT*V  }
function CVtxCMt(const VL: ICVector; const MR: ICMatrix; var err: TInt): ICVector;

{ matrix-vector product: CMtxCVt = M*V = V*MT }
function CMtxCVt(const ML: ICMatrix; const VR: ICVector; var err: TInt): ICVector;

{ matrix-matrix product: CMtxCMt = ML*MR }
function CMtxCMt(const ML, MR: ICMatrix; var err: TInt): ICMatrix;

{ matrix-matrix product: CMtHxCMt = HConjugate(ML)*MR }
function CMtHxCMt(const ML, MR: ICMatrix; var err: TInt): ICMatrix;

{ matrix-matrix product: CMtxCMtH = ML*HConjugate(MR) }
function CMtxCMtH(const ML, MR: ICMatrix; var err: TInt): ICMatrix;

{ matrix-matrix product: DxCMt = DiagonalMatrix(DL)*MR }
function DxCMt(const DL: IVector; const MR: ICMatrix; var err: TInt): ICMatrix;

{ matrix-matrix product: CMtxD = ML*DiagonalMatrix(DR) }
function CMtxD(const ML: ICMatrix; const DR: IVector; var err: TInt): ICMatrix;

{ Diagonalization of the real symmetric matrix a.                       }
function DiagRealSystem(const a: ITensor2D; var signal: TInt;
  sort: boolean = true; vectors: boolean = true; Ascending: boolean = true;
  Epsilon : TFloat = SqrtMinFloat; IterMax: TInt = 999): IEigenSystem;

implementation


end.