public DenseMatrixComplex smallestEigPositiveDefinite(ref SparseMatrixComplex A, ref SparseMatrixComplex B, ref DenseMatrixComplex x)
{
LinearSystemGenericByLib.Instance.FactorizationLU(ref A);
int n = A.Length();
DenseMatrixComplex e = new DenseMatrixComplex(n, 1);
e.Fill(new Complex(1, 0));
Complex dot = e.Dot(B * e);
double norm = Math.Sqrt(dot.Norm());
e /= new Complex(norm, 0);
//Iteratation
for (int i = 0; i < MaxEigIter; i++)
{
x = B * x;
x = LinearSystemGenericByLib.Instance.SolveByFactorizedLU(ref x);
x -= x.Dot(B * e) * e;
double newNorm = Math.Sqrt(x.Dot(B * x).Norm());
x /= new Complex(newNorm, 0);
}
LinearSystemGenericByLib.Instance.FreeSolverLUComplex();
return(x);
}
public static DenseMatrixComplex operator *(DenseMatrixComplex left, SparseMatrixComplex right)
{
//Make sure matrix dimensions are equal
if (left.columnCount != right.RowCount)
{
throw new Exception("The dimension of two matrix must be equal");
}
DenseMatrixComplex resultMatrix = new DenseMatrixComplex(left.RowCount, right.ColumnCount);
Complex[,] result = resultMatrix.datas;
for (int i = 0; i < left.rowCount; i++)
{
foreach (KeyValuePair <Pair, Complex> item in right.Datas)
{
Pair pair = item.Key;
Complex value = item.Value;
int m = pair.Key;
int n = pair.Value;
//M: mutiply index N: vector store index
result[i, n] += left[i, m] * value;
}
}
return(resultMatrix);
}
public void FlattenProcess()
{
SparseMatrixComplex Lc = BuildEnergy();
SparseMatrixComplex star0 = DECComplex.Instance.cBuildHodgeStar0Form(mesh);
Lc += new Complex(1.0e-8, 0) * star0; //[Reconsider: Complex(1.0e-8)]
//Compute parameterization
DenseMatrixComplex x = new DenseMatrixComplex(Lc.RowCount, 1);
x.Randomize(); //Initial guesses
DenseMatrixComplex result = LinearSystemDEC.Instance.smallestEigPositiveDefinite(ref Lc, ref star0, ref x);
//Assign sultion
foreach (TriMesh.Vertex v in mesh.Vertices)
{
Complex value = result[v.Index, 0];
v.Traits.Position.x = value.RealPart;
v.Traits.Position.y = value.ImagePart;
v.Traits.Position.z = 0;
}
TriMeshUtil.ScaleToUnit(mesh, 1.0);
TriMeshUtil.MoveToCenter(mesh);
}
public Complex Dot(DenseMatrixComplex right)
{
DenseMatrixComplex x = this.Transpose() * right;
Complex result = x[0, 0];
return(result);
}
public DenseMatrixComplex SolveLinerSystem(ref SparseMatrixComplex A, ref DenseMatrixComplex b)
{
if (A.RowCount != b.RowCount)
{
throw new Exception("The dimension of A and b must be agree");
}
CholmodInfo cholmodb = CholmodConverter.cConverter(ref b);
CholmodInfo cholmodA = CholmodConverter.cConverter(ref A, CholmodInfo.CholmodMatrixStorage.CCS);
double[] x = new double[2 * A.ColumnCount];
fixed(int *Index = cholmodA.rowIndex, Pt = cholmodA.colIndex)
fixed(double *val = cholmodA.values, bp = cholmodb.values, xx = x)
{
SolveRealByQR_CCS_Complex(cholmodA.RowCount,
cholmodA.ColumnCount,
cholmodA.nnz,
Pt, //Column Pointer
Index, //Row Index
val,
xx,
bp);
}
DenseMatrixComplex unknown = CholmodConverter.cConvertArrayToDenseMatrix(ref x, x.Length, 1);
cholmodA = null;
cholmodb = null;
GC.Collect();
return(unknown);
}
public void FlattenProcess()
{
SparseMatrixComplex Lc = BuildEnergy();
SparseMatrixComplex star0 = DECComplex.Instance.cBuildHodgeStar0Form(mesh);
Lc += new Complex(1.0e-8, 0) * star0; //[Reconsider: Complex(1.0e-8)]
//Compute parameterization
DenseMatrixComplex x = new DenseMatrixComplex(Lc.RowCount, 1);
x.Randomize(); //Initial guesses
DenseMatrixComplex result = LinearSystemDEC.Instance.smallestEigPositiveDefinite(ref Lc, ref star0, ref x);
//Assign sultion
foreach (TriMesh.Vertex v in mesh.Vertices)
{
Complex value = result[v.Index, 0];
v.Traits.Position.x = value.RealPart;
v.Traits.Position.y = value.ImagePart;
v.Traits.Position.z = 0;
}
TriMeshUtil.ScaleToUnit(mesh,1.0);
TriMeshUtil.MoveToCenter(mesh);
}
public double cResidual(ref SparseMatrixComplex A, ref DenseMatrixComplex b, ref DenseMatrixComplex x)
{
DenseMatrixComplex errors = (A * x - b);
double norm = errors.InifnityNorm() / x.InifnityNorm();
return(norm);
}
public DenseMatrixComplex smallestEigPositiveDefinite(ref SparseMatrixComplex A, bool ignoreConstantVector)
{
ignoreConstantVector = true;
DenseMatrixComplex x = new DenseMatrixComplex();
return(x);
}
public static DenseMatrixComplex Copy(ref DenseMatrixComplex B)
{
DenseMatrixComplex newMatrix = new DenseMatrixComplex();
newMatrix.rowCount = B.rowCount;
newMatrix.columnCount = B.columnCount;
Array.Copy(B.datas, newMatrix.datas, B.datas.Length);
return(newMatrix);
}
public static CholmodInfo cConverter(ref DenseMatrixComplex b)
{
CholmodInfo info = new CholmodInfo();
info.MatrixType = CholmodInfo.CholmodMatrixType.Dense;
b.ToArray(out info.RowCount, out info.ColumnCount, out info.values); //Normal
return(info);
}
public static DenseMatrixComplex Identity(int N)
{
DenseMatrixComplex identity = new DenseMatrixComplex(N, N);
for (int i = 0; i < N; i++)
{
identity.datas[i, i] = Complex.Identity;
}
return identity;
}
public static DenseMatrixComplex Identity(int N)
{
DenseMatrixComplex identity = new DenseMatrixComplex(N, N);
for (int i = 0; i < N; i++)
{
identity.datas[i, i] = Complex.Identity;
}
return(identity);
}
public double F_Norm()
{
DenseMatrixComplex tr = this.Transpose() * this;
double sum = 0;
for (int i = 0; i < tr.RowCount; i++)
{
sum += tr[i, i].Norm();
}
return(Math.Sqrt(sum));
}
public static DenseMatrixComplex operator *(Complex left, DenseMatrixComplex right)
{
DenseMatrixComplex result = new DenseMatrixComplex(right.rowCount, right.columnCount);
for (int i = 0; i < right.rowCount; i++)
{
for (int j = 0; j < right.columnCount; j++)
{
result.datas[i, j] = right.datas[i, j] * left;
}
}
return(result);
}
public DenseMatrixComplex Transpose()
{
DenseMatrixComplex tr = new DenseMatrixComplex(this.columnCount, this.rowCount);
for (int i = 0; i < rowCount; i++)
{
for (int j = 0; j < columnCount; j++)
{
tr.datas[j, i] = datas[i, j];
}
}
return tr;
}
public DenseMatrixComplex Transpose()
{
DenseMatrixComplex tr = new DenseMatrixComplex(this.columnCount, this.rowCount);
for (int i = 0; i < rowCount; i++)
{
for (int j = 0; j < columnCount; j++)
{
tr.datas[j, i] = datas[i, j];
}
}
return(tr);
}
public static DenseMatrixComplex operator /(DenseMatrixComplex left, Complex right)
{
//Make sure matrix dimensions are equal
DenseMatrixComplex matrix = new DenseMatrixComplex(left.RowCount, left.ColumnCount);
Complex rightInv = right.Inv();
for (int i = 0; i < left.RowCount; i++)
{
for (int j = 0; j < left.columnCount; j++)
{
matrix.datas[i, j] = left.datas[i, j] * rightInv;
}
}
return(matrix);
}
public static DenseMatrixComplex cConvertArrayToDenseMatrix(ref double[] x, int m, int n)
{
DenseMatrixComplex unknown = new DenseMatrixComplex(m, n);
int count = 0;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
Complex value = new Complex(x[2 * count], x[2 * count + 1]);
unknown[i, j] = value;
count++;
}
}
return(unknown);
}
public DenseMatrixComplex SolveByFactorizedLU(ref DenseMatrixComplex b)
{
CholmodInfo cholmodb = CholmodConverter.cConverter(ref b);
DenseMatrixComplex result = new DenseMatrixComplex(n, 1);
double[] x = new double[2 * n];
SolveLUComplex(ref cholmodb.values, ref x);
for (int i = 0; i < n; i++)
{
result[i, 0] = new Complex(x[2 * i], x[2 * i + 1]);
}
x = null;
GC.Collect();
return(result);
}
public static DenseMatrixComplex operator +(DenseMatrixComplex left, DenseMatrixComplex right)
{
//Make sure matrix dimensions are equal
if (left.columnCount != right.columnCount)
{
throw new Exception("The dimension of two matrix must be equal");
}
DenseMatrixComplex matrix = new DenseMatrixComplex(left.RowCount, left.ColumnCount);
for (int i = 0; i < left.RowCount; i++)
{
for (int j = 0; j < left.columnCount; j++)
{
matrix.datas[i, j] = left.datas[i, j] + right.datas[i, j];
}
}
return(matrix);
}
public static DenseMatrixComplex operator *(DenseMatrixComplex left, DenseMatrixComplex right)
{
//Make sure matrix dimensions are equal
if (left.columnCount != right.rowCount)
{
throw new Exception("The dimension of two matrix must be equal");
}
DenseMatrixComplex result = new DenseMatrixComplex(left.rowCount, right.columnCount);
for (int i = 0; i < left.rowCount; i++)
{
for (int j = 0; j < right.columnCount; j++)
{
for (int z = 0; z < left.columnCount; z++)
{
result.datas[i, j] += left.datas[i, z] * right.datas[z, j];
}
}
}
return(result);
}
public static DenseMatrixComplex operator *(Complex left, DenseMatrixComplex right)
{
DenseMatrixComplex result = new DenseMatrixComplex(right.rowCount, right.columnCount);
for (int i = 0; i < right.rowCount; i++)
{
for (int j = 0; j < right.columnCount; j++)
{
result.datas[i, j] = right.datas[i, j] * left;
}
}
return result;
}
public Complex Dot(DenseMatrixComplex right)
{
DenseMatrixComplex x = this.Transpose() * right;
Complex result = x[0, 0];
return result;
}
public static DenseMatrixComplex operator *(DenseMatrixComplex left, DenseMatrixComplex right)
{
//Make sure matrix dimensions are equal
if (left.columnCount != right.rowCount)
{
throw new Exception("The dimension of two matrix must be equal");
}
DenseMatrixComplex result = new DenseMatrixComplex(left.rowCount, right.columnCount);
for (int i = 0; i < left.rowCount; i++)
{
for (int j = 0; j < right.columnCount; j++)
{
for (int z = 0; z < left.columnCount; z++)
{
result.datas[i, j] += left.datas[i, z] * right.datas[z, j];
}
}
}
return result;
}
public DenseMatrixComplex SolveLinerSystem(ref SparseMatrixComplex A, ref DenseMatrixComplex b)
{
if (A.RowCount != b.RowCount)
{
throw new Exception("The dimension of A and b must be agree");
}
CholmodInfo cholmodb = CholmodConverter.cConverter(ref b);
CholmodInfo cholmodA = CholmodConverter.cConverter(ref A, CholmodInfo.CholmodMatrixStorage.CCS);
double[] x = new double[2 * A.ColumnCount];
fixed (int* Index = cholmodA.rowIndex, Pt = cholmodA.colIndex)
fixed (double* val = cholmodA.values, bp = cholmodb.values, xx = x)
{
SolveRealByQR_CCS_Complex(cholmodA.RowCount,
cholmodA.ColumnCount,
cholmodA.nnz,
Pt, //Column Pointer
Index, //Row Index
val,
xx,
bp);
}
DenseMatrixComplex unknown = CholmodConverter.cConvertArrayToDenseMatrix(ref x, x.Length, 1);
cholmodA = null;
cholmodb = null;
GC.Collect();
return unknown;
}
public static CholmodInfo cConverter(ref DenseMatrixComplex b)
{
CholmodInfo info = new CholmodInfo();
info.MatrixType = CholmodInfo.CholmodMatrixType.Dense;
b.ToArray(out info.RowCount, out info.ColumnCount, out info.values); //Normal
return info;
}
public static DenseMatrixComplex operator /(DenseMatrixComplex left, Complex right)
{
//Make sure matrix dimensions are equal
DenseMatrixComplex matrix = new DenseMatrixComplex(left.RowCount, left.ColumnCount);
Complex rightInv = right.Inv();
for (int i = 0; i < left.RowCount; i++)
{
for (int j = 0; j < left.columnCount; j++)
{
matrix.datas[i, j] = left.datas[i, j] * rightInv;
}
}
return matrix;
}
public static DenseMatrixComplex operator +(DenseMatrixComplex left, DenseMatrixComplex right)
{
//Make sure matrix dimensions are equal
if (left.columnCount != right.columnCount)
{
throw new Exception("The dimension of two matrix must be equal");
}
DenseMatrixComplex matrix = new DenseMatrixComplex(left.RowCount, left.ColumnCount);
for (int i = 0; i < left.RowCount; i++)
{
for (int j = 0; j < left.columnCount; j++)
{
matrix.datas[i, j] = left.datas[i, j] + right.datas[i, j];
}
}
return matrix;
}
public static DenseMatrixComplex Copy(ref DenseMatrixComplex B)
{
DenseMatrixComplex newMatrix = new DenseMatrixComplex();
newMatrix.rowCount = B.rowCount;
newMatrix.columnCount = B.columnCount;
Array.Copy(B.datas, newMatrix.datas, B.datas.Length);
return newMatrix;
}
public DenseMatrixComplex SolveByFactorizedLU(ref DenseMatrixComplex b)
{
CholmodInfo cholmodb = CholmodConverter.cConverter(ref b);
DenseMatrixComplex result = new DenseMatrixComplex(n, 1);
double[] x = new double[2 * n];
SolveLUComplex(ref cholmodb.values, ref x);
for (int i = 0; i < n; i++)
{
result[i, 0] = new Complex(x[2 * i], x[2 * i + 1]);
}
x = null;
GC.Collect();
return result;
}
public static DenseMatrixComplex cConvertArrayToDenseMatrix(ref double[] x, int m, int n)
{
DenseMatrixComplex unknown = new DenseMatrixComplex(m, n);
int count = 0;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
Complex value = new Complex(x[2 * count], x[2 * count + 1]);
unknown[i, j] = value;
count++;
}
}
return unknown;
}
public static DenseMatrixComplex operator *(DenseMatrixComplex left, SparseMatrixComplex right)
{
//Make sure matrix dimensions are equal
if (left.columnCount != right.RowCount)
{
throw new Exception("The dimension of two matrix must be equal");
}
DenseMatrixComplex resultMatrix = new DenseMatrixComplex(left.RowCount, right.ColumnCount);
Complex[,] result = resultMatrix.datas;
for (int i = 0; i < left.rowCount; i++)
{
foreach (KeyValuePair<Pair, Complex> item in right.Datas)
{
Pair pair = item.Key;
Complex value = item.Value;
int m = pair.Key;
int n = pair.Value;
//M: mutiply index N: vector store index
result[i, n] += left[i, m] * value;
}
}
return resultMatrix;
}
