Functions/procedures in LinAlg.dcu
==================================
procedure InitRealMatrix(var M: RealMatrix; Rows, Cols: integer);
procedure DestroyRealMatrix(M: RealMatrix);
procedure InitComplexMatrix(var M: ComplexMatrix; Rows, Cols: integer);
procedure DestroyComplexMatrix(M: ComplexMatrix);
procedure RealMatrix_PolishMatrix(var M: RealMatrix);
procedure ComplexMatrix_PolishMatrix(var M: ComplexMatrix);
procedure RealVector_PolishVector(var V: RealVector);
procedure ComplexVector_PolishVector(var V: ComplexVector);
procedure Random_RealMatrix(var M: RealMatrix; Range: integer);
procedure Random_ComplexMatrix(var M: ComplexMatrix; Range: integer);
procedure Copy_RealMatrix(var M: RealMatrix; M2: RealMatrix);
procedure Copy_ComplexMatrix(var M: ComplexMatrix; M2: ComplexMatrix);
procedure Redimension_RealMatrix(var M: RealMatrix; NewRow, NewCol: integer);
procedure Redimension_ComplexMatrix(var M: ComplexMatrix; NewRow, NewCol: integer);

procedure RealMatrix_Addition(var M: RealMatrix; M1, M2: RealMatrix);
procedure ComplexMatrix_Addition(var M: ComplexMatrix; M1, M2: ComplexMatrix);
procedure RealMatrix_Subtraction(var M: RealMatrix; M1, M2: RealMatrix);
procedure ComplexMatrix_Subtraction(var M: ComplexMatrix; M1, M2: ComplexMatrix);
procedure RealMatrix_Multiplication(var M: RealMatrix; M1, M2: RealMatrix);
procedure ComplexMatrix_Multiplication(var M: ComplexMatrix; M1, M2: ComplexMatrix);
procedure AddReal_ComplexMatrix(var M: ComplexMatrix; M1: RealMatrix; M2: ComplexMatrix);
procedure SubtractReal_ComplexMatrix(var M: ComplexMatrix; M1: RealMatrix; M2: ComplexMatrix);
procedure MultiplyReal_ComplexMatrix(var M: ComplexMatrix; M1: RealMatrix; M2: ComplexMatrix);
procedure MultiplyComplex_RealMatrix(var M: ComplexMatrix; M1: ComplexMatrix; M2: RealMatrix);
procedure RealMatrix_RealScalarMultiplication(var M: RealMatrix; x: extended);
procedure ComplexMatrix_ComplexScalarMultiplication(var M: ComplexMatrix; c: complex);
procedure RealMatrix_ComplexScalarMultiplication(var M: ComplexMatrix; MOrig: RealMatrix; c: complex);
procedure ComplexMatrix_RealScalarMultiplication(var M: ComplexMatrix; x: extended);
procedure RealMatrixRow_RealScalarMultiplication(var M: RealMatrix; x: extended; Row: integer);
procedure RealMatrixColumn_RealScalarMultiplication(var M: RealMatrix; x: extended; Column: integer);
procedure ComplexMatrixRow_ComplexScalarMultiplication(var M: ComplexMatrix; c: Complex; Row: integer);
procedure ComplexMatrixColumn_ComplexScalarMultiplication(var M: ComplexMatrix; c: Complex; Column: integer);

procedure RealMatrix_Transpose(var M: RealMatrix);
procedure ComplexMatrix_Transpose(var M: ComplexMatrix);
function RealMatrix_Trace(M: RealMatrix): extended;
function ComplexMatrix_Trace(M: ComplexMatrix): complex;
function RealMatrix_Norm(M: RealMatrix): extended;
function ComplexMatrix_Norm(M: ComplexMatrix): complex;
procedure ComplexMatrix_Conjugate(var M: ComplexMatrix);
procedure ComplexMatrix_HermiteConjugate(var M: ComplexMatrix);
procedure RealMatrix_ToPower(var M: RealMatrix; x: integer);
procedure ComplexMatrix_ToPower(var M: ComplexMatrix; x: integer);

procedure NilRealMatrix(var M: RealMatrix);
procedure NilComplexMatrix(var M: ComplexMatrix);
procedure RealIdentityMatrix(var M: RealMatrix);
procedure ComplexIdentityMatrix(var M: ComplexMatrix);
procedure RealDiagonalMatrix(var M: RealMatrix; V: RealVector);
procedure ComplexDiagonalMatrix(var M: ComplexMatrix; V: ComplexVector);
procedure RealHilbertMatrix(var M: RealMatrix);
procedure ComplexHilbertMatrix(var M: ComplexMatrix);
procedure FourierMatrix(var M, U: ComplexMatrix);
procedure RealVandermondeMatrix(var M: RealMatrix; V: RealVector);
procedure ComplexVandermondeMatrix(var M: ComplexMatrix; V: ComplexVector);
procedure RealAugmentedMatrix(var M: RealMatrix);
procedure ComplexAugmentedMatrix(var M: ComplexMatrix);

procedure RealToComplexMatrix(var M: ComplexMatrix; M1, M2: RealMatrix);
procedure ComplexToRealMatrix(var RPart, CPart: RealMatrix; M: ComplexMatrix);
procedure RealMatrix_SwapRows(var M: RealMatrix; Row1, Row2: integer);
procedure ComplexMatrix_SwapRows(var M: ComplexMatrix; Row1, Row2: integer);
procedure RealMatrix_SwapColumns(var M: RealMatrix; Col1, Col2: integer);
procedure ComplexMatrix_SwapColumns(var M: ComplexMatrix; Col1, Col2: integer);
procedure RealMatrix_ReplaceElement(var M: RealMatrix; Row, Col: integer; x: extended);
procedure ComplexMatrix_ReplaceElement(var M: ComplexMatrix; Row, Col: integer; c: complex);
procedure RealSubMatrix(var M: RealMatrix; MOrig: RealMatrix; Row1, Row2, Col1, Col2: integer);
procedure ComplexSubMatrix(var M: ComplexMatrix; MOrig: ComplexMatrix; Row1, Row2, Col1, Col2: integer);

procedure RealVectorToRealMatrix(var M: RealMatrix; V: RealVector);
procedure ComplexVectorToComplexMatrix(var M: ComplexMatrix; V: ComplexVector);
procedure RealMatrixToRealVector(var V: RealVector; M: RealMatrix);
procedure ComplexMatrixToComplexVector(var V: ComplexVector; M: ComplexMatrix);
procedure RealMatrixRowToRealVector(var V: RealVector; M: RealMatrix; index: integer);
procedure ComplexMatrixRowToComplexVector(var V: ComplexVector; M: ComplexMatrix; index: integer);
procedure RealMatrixColToRealVector(var V: RealVector; M: RealMatrix; index: integer);
procedure ComplexMatrixColToComplexVector(var V: ComplexVector; M: ComplexMatrix; index: integer);
procedure RealMatrixDiagonalToRealVector(var V: RealVector; M: RealMatrix);
procedure ComplexMatrixDiagonalToComplexVector(var V: ComplexVector; M: ComplexMatrix);
procedure RealMatrix_AddRow(var M: RealMatrix; V: RealVector);
procedure ComplexMatrix_AddRow(var M: ComplexMatrix; V: ComplexVector);
procedure RealMatrix_AddColumn(var M: RealMatrix; V: RealVector);
procedure ComplexMatrix_AddColumn(var M: ComplexMatrix; V: ComplexVector);
procedure RealMatrix_DeleteRow(var M: RealMatrix; Index: integer);
procedure ComplexMatrix_DeleteRow(var M: ComplexMatrix; Index: integer);
procedure RealMatrix_DeleteColumn(var M: RealMatrix; Index: integer);
procedure ComplexMatrix_DeleteColumn(var M: ComplexMatrix; Index: integer);
procedure RealMatrix_InsertRow(var M: RealMatrix; V: RealVector; index: integer);
procedure ComplexMatrix_InsertRow(var M: ComplexMatrix; V: ComplexVector; index: integer);
procedure RealMatrix_InsertColumn(var M: RealMatrix; V: RealVector; index: integer);
procedure ComplexMatrix_InsertColumn(var M: ComplexMatrix; V: ComplexVector; index: integer);
procedure RealMatrix_ReplaceRow(var M: RealMatrix; V: RealVector; index: integer);
procedure ComplexMatrix_ReplaceRow(var M: ComplexMatrix; V: ComplexVector; index: integer);
procedure RealMatrix_ReplaceColumn(var M: RealMatrix; V: RealVector; index: integer);
procedure ComplexMatrix_ReplaceColumn(var M: ComplexMatrix; V: ComplexVector; index: integer);

function RealMatrix_AreTheSame(M1, M2: RealMatrix; Error: extended): boolean;
function RealMatrix_IsOrthogonal(M: RealMatrix; Error: extended): boolean;
function RealMatrix_IsSymmetric(M: RealMatrix; Error: extended): boolean;
function RealMatrix_IsSkewSymmetric(M: RealMatrix; Error: extended): boolean;
function RealMatrix_IsNormal(M: RealMatrix; Error: extended): boolean;
function RealMatrix_IsIdemPotent(M: RealMatrix; Error: extended): boolean;
function ComplexMatrix_AreTheSame(M1, M2: ComplexMatrix; Error: extended): boolean;
function ComplexMatrix_IsOrthogonal(M: ComplexMatrix; Error: extended): boolean;
function ComplexMatrix_IsSymmetric(M: ComplexMatrix; Error: extended): boolean;
function ComplexMatrix_IsSkewSymmetric(M: ComplexMatrix; Error: extended): boolean;
function ComplexMatrix_IsNormal(M: ComplexMatrix; Error: extended): boolean;
function ComplexMatrix_IsIdemPotent(M: ComplexMatrix; Error: extended): boolean;

procedure InitRealVector(var V: RealVector; Dimension: integer);
procedure DestroyRealVector(V: RealVector);
procedure InitComplexVector(var V: ComplexVector; Dimension: integer);
procedure DestroyComplexVector(V: ComplexVector);
procedure NilRealVector(var V: RealVector);
procedure NilComplexVector(var V: ComplexVector);
procedure Random_RealVector(var V: RealVector; Range: integer);
procedure Random_ComplexVector(var V: ComplexVector; Range: integer);
procedure Copy_RealVector(var V: RealVector; V2: RealVector);
procedure Copy_ComplexVector(var V: ComplexVector; V2: ComplexVector);
procedure Redimension_RealVector(var V: RealVector; NewDimension: integer);
procedure Redimension_ComplexVector(var V: ComplexVector; NewDimension: integer);
procedure RealToComplexVector(var V: ComplexVector; V1, V2: RealVector);
procedure ComplexToRealVector(var RPart, CPart: RealVector; V: ComplexVector);

procedure RealVector_AddElement(var V: RealVector; x: extended);
procedure ComplexVector_AddElement(var V: ComplexVector; c: complex);
procedure RealVector_SwapElements(var V: RealVector; index1, index2: integer);
procedure ComplexVector_SwapElements(var V: ComplexVector; index1, index2: integer);
procedure RealVector_ReplaceElement(var V: RealVector; Index: integer; x: extended);
procedure ComplexVector_ReplaceElement(var V: ComplexVector; Index: integer; c: complex);
procedure RealVector_InsertElement(var V: RealVector; Index: integer; x: extended);
procedure ComplexVector_InsertElement(var V: ComplexVector; Index: integer; c: complex);
procedure RealVector_DeleteElement(var V: RealVector; Index: integer);
procedure ComplexVector_DeleteElement(var V: ComplexVector; Index: integer);
procedure RealSubVector(var V: RealVector; VOrig: RealVector; index1, index2: integer);
procedure ComplexSubVector(var V: ComplexVector; VOrig: ComplexVector; index1, index2: integer);

function RealVector_Norm(V: RealVector): extended;
function ComplexVector_Norm(V: ComplexVector): complex;
function RealVector_Distance(V1, V2: RealVector): extended;
function ComplexVector_Distance(V1, V2: ComplexVector): complex;
procedure RealUnit_Vector(var V: RealVector);
procedure ComplexUnit_Vector(var V: ComplexVector);
function RealVector_Angle(V1, V2: RealVector): extended;
function ComplexVector_Angle(V1, V2: ComplexVector): complex;
function RealVector_DotProduct(V1, V2: RealVector): extended;
function ComplexVector_DotProduct(V1, V2: ComplexVector): complex;
procedure RealVector_CrossProduct(var V: RealVector; V1, V2: RealVector);
procedure ComplexVector_CrossProduct(var V: ComplexVector; V1, V2: ComplexVector);
procedure RealVector_RealScalarMultiplication(var V: RealVector; x: extended);
procedure ComplexVector_ComplexScalarMultiplication(var V: ComplexVector; c: complex);
procedure RealVector_ComplexScalarMultiplication(var V: ComplexVector; VOrig: RealVector; c: complex);
procedure ComplexVector_RealScalarMultiplication(var V: ComplexVector; x: extended);

procedure RealVector_Addition(var V: Realvector; V1, V2: RealVector);
procedure ComplexVector_Addition(var V: Complexvector; V1, V2: ComplexVector);
procedure RealVector_Subtraction(var V: Realvector; V1, V2: RealVector);
procedure ComplexVector_Subtraction(var V: ComplexVector; V1, V2: ComplexVector);
procedure AddReal_ComplexVector(var V: ComplexVector; V1: RealVector; V2: ComplexVector);
procedure SubtractReal_ComplexVector(var V: ComplexVector; V1: RealVector; V2: ComplexVector);

procedure TwoDimensionalRotationRealMatrix(var M: RealMatrix; Angle: extended);
procedure ThreeDimensionalRotationRealMatrix(var M: RealMatrix; Angle: extended; Axis: cardinal);

Functions/procedures in LinAlgP.dcu
===================================
procedure RealMatrix_GaussNormalForm(var M: RealMatrix);
procedure RealMatrix_HermiteNormalForm(var M: RealMatrix);
procedure RealMatrix_Inverse(var M: RealMatrix);
procedure ComplexMatrix_GaussNormalForm(var M: ComplexMatrix);
procedure ComplexMatrix_HermiteNormalForm(var M: ComplexMatrix);
procedure ComplexMatrix_Inverse(var M: ComplexMatrix);
function RealMatrix_Determinant(M: RealMatrix): extended;
function ComplexMatrix_Determinant(M: ComplexMatrix): complex;
function RealMatrix_NumberOfNilRows(M: RealMatrix): integer;
function ComplexMatrix_NumberOfNilRows(M: ComplexMatrix): integer;
function RealMatrix_Rank(M: RealMatrix): integer;
function ComplexMatrix_Rank(M: ComplexMatrix): integer;
procedure RealMatrix_Minor(var Minor: RealMatrix; M: RealMatrix; Row, Col: integer);
procedure ComplexMatrix_Minor(var Minor: ComplexMatrix; M: ComplexMatrix; Row, Col: integer);
function RealMatrix_CoFactor(M: RealMatrix; Row, Col: integer): extended;
function ComplexMatrix_CoFactor(M: ComplexMatrix; Row, Col: integer): complex;
procedure RealMatrix_Adjoint(var M: RealMatrix);
procedure ComplexMatrix_Adjoint(var M: ComplexMatrix);

function RealVector_RowNorm(V: RealVector): extended;
function ComplexVector_RowNorm(V: ComplexVector): extended;
function RealVector_ColumnNorm(V: RealVector): extended;
function ComplexVector_ColumnNorm(V: ComplexVector): extended;
function RealMatrix_RowNorm(M: RealMatrix): extended;
function ComplexMatrix_RowNorm(M: ComplexMatrix): extended;
function RealMatrix_ColumnNorm(M: RealMatrix): extended;
function ComplexMatrix_ColumnNorm(M: ComplexMatrix): extended;
function RealMatrix_ConditionNumber(M: RealMatrix): extended;
function ComplexMatrix_ConditionNumber(M: ComplexMatrix): extended;

procedure RealMatrix_BalanceMatrix(var M: RealMatrix);
procedure RealMatrix_HessenbergForm(var M: RealMatrix);
procedure RealFrobeniusMatrix(var M: RealMatrix; V: RealVector);
procedure RealMatrix_Eigenvalues(var V: ComplexVector; M: RealMatrix);
procedure RealMatrix_CharacteristicEquation(var V: RealVector; M: RealMatrix);
procedure RealMatrix_EigenVectors(var CM: ComplexMatrix; M: RealMatrix; eigenval: complex);

procedure RealMatrix_SingularValueDecomposition(var A, V: RealMatrix; var w: RealVector);

procedure RealMatrix_LUDecomposition1(var L, U: RealMatrix; M: RealMatrix);
procedure RealMatrix_LUDecomposition2(var LU: RealMatrix; M: RealMatrix);
procedure RealMatrix_ExtractLandUMatrix(var L, U: RealMatrix; LU: RealMatrix);
procedure ComplexMatrix_LUDecomposition1(var L, U: ComplexMatrix; M: ComplexMatrix);
procedure ComplexMatrix_LUDecomposition2(var LU: ComplexMatrix; M: ComplexMatrix);
procedure ComplexMatrix_ExtractLandUMatrix(var L, U: ComplexMatrix; LU: ComplexMatrix);

procedure RealSysOfEquations(var M: RealMatrix; CoM: RealMatrix; CoV: RealVector; var NumOfSolutions: integer);
procedure ComplexSysOfEquations(var M: ComplexMatrix; CoM: ComplexMatrix; CoV: ComplexVector;var NumOfSolutions: integer);
procedure RealSysOfEquationsLeastSquare(var V: RealVector; CoM: RealMatrix; CoV: RealVector);
procedure ComplexSysOfEquationsLeastSquare(var V: ComplexVector; CoM: ComplexMatrix; CoV: ComplexVector);
procedure RealSysOfEquationsAccuracyTest(var ResArray: RealVector; CoM: RealMatrix; X, CoV: RealVector);
procedure ComplexSysOfEquationsAccuracyTest(var ResArray: ComplexVector; CoM: ComplexMatrix;
          X, CoV: ComplexVector);

procedure RealMatrix_GramSchmidt(var M: RealMatrix);
procedure RealMatrix_QRDecomposition(var Q, R: RealMatrix; M: RealMatrix);
procedure ComplexMatrix_GramSchmidt(var M: ComplexMatrix);
procedure ComplexMatrix_QRDecomposition(var Q, R: ComplexMatrix; M: ComplexMatrix);

Functions/procedures in LinAlgS.dcu
===================================
procedure InitSparseRealMatrix(var M: SparseRealMatrix; NumOfElements: integer);
procedure InitSparseComplexMatrix(var M: SparseComplexMatrix; NumOfElements: integer);
procedure DestroySparseRealMatrix(M: SparseRealMatrix);
procedure DestroySparseComplexMatrix(M: SparseComplexMatrix);
procedure SparseRealMatrix_SortElements(var MS: SparseRealMatrix);
procedure SparseComplexMatrix_SortElements(var MS: SparseComplexMatrix);
procedure SparseRealMatrix_GetMatrixDimensions(MS: SparseRealMatrix; var Row, Col: integer);
procedure SparseComplexMatrix_GetMatrixDimensions(MS: SparseComplexMatrix; var Row, Col: integer);
function SparseRealMatrix_DoesElementExists(MS: SparseRealMatrix; Element: RealMatrixCell): boolean;
function SparseComplexMatrix_DoesElementExists(MS: SparseComplexMatrix; Element: ComplexMatrixCell): boolean;
function SparseRealMatrix_DoesRowExists(MS: SparseRealMatrix; Row: integer): boolean;
function SparseComplexMatrix_DoesRowExists(MS: SparseComplexMatrix; Row: integer): boolean;
function SparseRealMatrix_DoesColumnExists(MS: SparseRealMatrix; Col: integer): boolean;
function SparseComplexMatrix_DoesColumnExists(MS: SparseComplexMatrix; Col: integer): boolean;
function SparseRealMatrix_GetElementPosition(MS: SparseRealMatrix; Element: RealMatrixCell): integer;
function SparseComplexMatrix_GetElementPosition(MS: SparseComplexMatrix; Element: ComplexMatrixCell): integer;
function SparseRealMatrix_GetRowStartIndex(MS: SparseRealMatrix; Row: integer): integer;
function SparseComplexMatrix_GetRowStartIndex(MS: SparseComplexMatrix; Row: integer): integer;
function SparseRealMatrix_GetRowEndIndex(MS: SparseRealMatrix; Row: integer): integer;
function SparseComplexMatrix_GetRowEndIndex(MS: SparseComplexMatrix; Row: integer): integer;
procedure SparseRealMatrix_GetRow(var MSRow: SparseRealMatrix; MS: SparseRealMatrix; Row: integer);
procedure SparseComplexMatrix_GetRow(var MSRow: SparseComplexMatrix; MS: SparseComplexMatrix; Row: integer);

procedure SparseRealMatrixToRealMatrix(var MR: RealMatrix; MS: SparseRealMatrix);
procedure SparseComplexMatrixToComplexMatrix(var MC: ComplexMatrix; MS: SparseComplexMatrix);
procedure RealMatrixToSparseRealMatrix(var MS: SparseRealMatrix; MR: RealMatrix; MinValue: extended);
procedure ComplexMatrixToSparseComplexMatrix(var MS: SparseComplexMatrix; MR: ComplexMatrix; MinValue: extended);
procedure Copy_SparseRealMatrix(var M: SparseRealMatrix; M2: SparseRealMatrix);
procedure Copy_SparseComplexMatrix(var M: SparseComplexMatrix; M2: SparseComplexMatrix);
procedure Redimension_SparseRealMatrix(var MS: SparseRealMatrix; NewDimension: integer);
procedure Redimension_SparseComplexMatrix(var MS: SparseComplexMatrix; NewDimension: integer);

procedure SparseRealMatrix_AddElement(var MS: SparseRealMatrix; Element: RealMatrixCell);
procedure SparseComplexMatrix_AddElement(var MS: SparseComplexMatrix; Element: ComplexMatrixCell);
procedure SparseRealMatrix_DeleteElement(var MS: SparseRealMatrix; Element: RealMatrixCell);
procedure SparseComplexMatrix_DeleteElement(var MS: SparseComplexMatrix; Element: ComplexMatrixCell);
procedure SparseRealMatrix_DeleteRow(var MS: SparseRealMatrix; Row: integer);
procedure SparseComplexMatrix_DeleteRow(var MS: SparseComplexMatrix; Row: integer);
procedure SparseRealMatrix_SetElement(var MS: SparseRealMatrix; Element: RealMatrixCell);
procedure SparseComplexMatrix_SetElement(var MS: SparseComplexMatrix; Element: ComplexMatrixCell);
function SparseRealMatrix_GetElement(MS: SparseRealMatrix; Element: RealMatrixCell): extended;
function SparseComplexMatrix_GetElement(MS: SparseComplexMatrix; Element: ComplexMatrixCell): complex;
procedure SparseRealMatrix_SwapElements(var MS: SparseRealMatrix; Element1, Element2: RealMatrixCell);
procedure SparseComplexMatrix_SwapElements(var MS: SparseComplexMatrix; Element1, Element2: ComplexMatrixCell);
procedure SparseRealMatrix_RealScalarMultiplication(var MS: SparseRealMatrix; x: extended);
procedure SparseComplexMatrix_ComplexScalarMultiplication(var MS: SparseComplexMatrix; x: complex);
procedure SparseRealMatrixRow_RealScalarMultiplication(var MS: SparseRealMatrix; x: extended; Row: integer);
procedure SparseComplexMatrixRow_ComplexScalarMultiplication(var MS: SparseComplexMatrix; x: complex; Row: integer);
procedure SparseRealMatrixColumn_RealScalarMultiplication(var MS: SparseRealMatrix; x: extended; Column: integer);
procedure SparseComplexMatrixColumn_ComplexScalarMultiplication(var MS: SparseComplexMatrix; x: complex; Column: integer);

procedure SparseRealMatrix_Addition(var MS: SparseRealMatrix; M1, M2: SparseRealMatrix);
procedure SparseComplexMatrix_Addition(var MS: SparseComplexMatrix; M1, M2: SparseComplexMatrix);
procedure SparseRealMatrix_Subtraction(var MS: SparseRealMatrix; M1, M2: SparseRealMatrix);
procedure SparseComplexMatrix_Subtraction(var MS: SparseComplexMatrix; M1, M2: SparseComplexMatrix);
function SparseRealMatrix_SumOfElements(MS: SparseRealMatrix): extended;
function SparseComplexMatrix_SumOfElements(MS: SparseComplexMatrix): complex;
procedure SparseRealMatrix_Multiplication(var MS: SparseRealMatrix; var M1, M2: SparseRealMatrix);
procedure SparseComplexMatrix_Multiplication(var MS: SparseComplexMatrix; var M1, M2: SparseComplexMatrix);

procedure SparseRealMatrix_Transpose(var MS: SparseRealMatrix);
procedure SparseComplexMatrix_Transpose(var MS: SparseComplexMatrix);
procedure SparseComplexMatrix_Conjugate(var MS: SparseComplexMatrix);
procedure SparseComplexMatrix_HermiteConjugate(var MS: SparseComplexMatrix);
function SparseRealMatrix_Norm(MS: SparseRealMatrix): extended;
function SparseComplexMatrix_Norm(MS: SparseComplexMatrix): complex;
function SparseRealMatrix_Trace(MS: SparseRealMatrix): extended;
function SparseComplexMatrix_Trace(MS: SparseComplexMatrix): complex;

procedure SparseRealMatrix_SwapRows(var MS: SparseRealMatrix; Row1, Row2: integer);
procedure SparseComplexMatrix_SwapRows(var MS: SparseComplexMatrix; Row1, Row2: integer);
procedure SparseRealMatrix_SwapColumns(var MS: SparseRealMatrix; Col1, Col2: integer);
procedure SparseComplexMatrix_SwapColumns(var MS: SparseComplexMatrix; Col1, Col2: integer);

function SparseRealMatrix_MaxValue(MS: SparseRealMatrix): RealMatrixCell;
function SparseRealMatrix_RowMaxValue(MS: SparseRealMatrix; Row: integer): RealMatrixCell;
function SparseRealMatrix_ColumnMaxValue(MS: SparseRealMatrix; Col: integer): RealMatrixCell;
function SparseRealMatrix_MinValue(MS: SparseRealMatrix): RealMatrixCell;
function SparseRealMatrix_RowMinValue(MS: SparseRealMatrix; Row: integer): RealMatrixCell;
function SparseRealMatrix_ColumnMinValue(MS: SparseRealMatrix; Col: integer): RealMatrixCell;

procedure SparseRealMatrix_DeleteZeros(var MS: SparseRealMatrix; MinValue: extended);
procedure SparseComplexMatrix_DeleteZeros(var MS: SparseComplexMatrix; MinValue: extended);
