public void GeneralMatrixChangeEventTest()
{
GeneralMatrix<int> matrix = new GeneralMatrix<int>(new int[3, 3] { { 1, 2, 3 }, { 2, 1, 2 }, { 3, 2, 1 } });
Subscribe(matrix);
matrix[0, 1] = 5;
Unsubscribe(matrix);
Assert.AreEqual<string>("GeneralMatrix", message);
}
public static void WriteMatrix(GeneralMatrix m)
{
if (m==null)
return;
for(int i = 0;i<m.RowDimension;++i)
{
for(int j = 0;j<m.ColumnDimension;++j)
{
Console.Write("{0} ",m.GetElement(i,j));
}
Console.WriteLine();
}
}
/// <summary>QR Decomposition, computed by Householder reflections.</summary>
/// <param name="A"> Rectangular matrix
/// </param>
/// <returns> Structure to access R and the Householder vectors and compute Q.
/// </returns>
public QRDecomposition(GeneralMatrix A)
{
// Initialize.
QR = A.ArrayCopy;
m = A.RowDimension;
n = A.ColumnDimension;
Rdiag = new double[n];
// Main loop.
for (int k = 0; k < n; k++)
{
// Compute 2-norm of k-th column without under/overflow.
double nrm = 0;
for (int i = k; i < m; i++)
{
nrm = Maths.Hypot(nrm, QR[i][k]);
}
if (nrm != 0.0)
{
// Form k-th Householder vector.
if (QR[k][k] < 0)
{
nrm = - nrm;
}
for (int i = k; i < m; i++)
{
QR[i][k] /= nrm;
}
QR[k][k] += 1.0;
// Apply transformation to remaining columns.
for (int j = k + 1; j < n; j++)
{
double s = 0.0;
for (int i = k; i < m; i++)
{
s += QR[i][k] * QR[i][j];
}
s = (- s) / QR[k][k];
for (int i = k; i < m; i++)
{
QR[i][j] += s * QR[i][k];
}
}
}
Rdiag[k] = - nrm;
}
}
/// <summary>Cholesky algorithm for symmetric and positive definite matrix.</summary>
/// <param name="Arg"> Square, symmetric matrix.
/// </param>
/// <returns> Structure to access L and isspd flag.
/// </returns>
public CholeskyDecomposition(GeneralMatrix Arg)
{
// Initialize.
double[][] A = Arg.Array;
n = Arg.RowDimension;
L = new double[n][];
for (int i = 0; i < n; i++)
{
L[i] = new double[n];
}
isspd = (Arg.ColumnDimension == n);
// Main loop.
for (int j = 0; j < n; j++)
{
double[] Lrowj = L[j];
double d = 0.0;
for (int k = 0; k < j; k++)
{
double[] Lrowk = L[k];
double s = 0.0;
for (int i = 0; i < k; i++)
{
s += Lrowk[i] * Lrowj[i];
}
Lrowj[k] = s = (A[j][k] - s) / L[k][k];
d = d + s * s;
isspd = isspd & (A[k][j] == A[j][k]);
}
d = A[j][j] - d;
isspd = isspd & (d > 0.0);
L[j][j] = System.Math.Sqrt(System.Math.Max(d, 0.0));
for (int k = j + 1; k < n; k++)
{
L[j][k] = 0.0;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="p0">First point on route, in projected (metric) coordinates relative to projection origin</param>
/// <param name="q0">First point on map, in pixels</param>
/// <param name="p1">Second point on route, in projected (metric) coordinates relative to projection origin</param>
/// <param name="q1">Second point on map, in pixels</param>
/// <param name="fallbackMatrix">Matrix to use if calculation fails due to singular matrix</param>
/// <param name="useRotation">If true, assumes orthogonal map and calculates scale and rotation. If false, calculates different scale in x and y directions and no rotation.</param>
/// <returns></returns>
public static GeneralMatrix CalculateTransformationMatrix(PointD p0, PointD q0, PointD p1, PointD q1, GeneralMatrix fallbackMatrix, bool useRotation)
{
try
{
if (useRotation)
{
// note that we need to mirror y pixel value in x axis
double angleDifferece = GetAngleR(p1 - p0, new PointD(q1.X, -q1.Y) - new PointD(q0.X, -q0.Y));
double lengthQ = DistancePointToPoint(q0, q1);
double lengthP = DistancePointToPoint(p0, p1);
double scaleFactor = lengthP == 0 ? 0 : lengthQ / lengthP;
double cos = Math.Cos(angleDifferece);
double sin = Math.Sin(angleDifferece);
// translation to origo in metric space
var a = new GeneralMatrix(3, 3);
a.SetElement(0, 0, 1);
a.SetElement(0, 1, 0);
a.SetElement(0, 2, -p0.X);
a.SetElement(1, 0, 0);
a.SetElement(1, 1, 1);
a.SetElement(1, 2, -p0.Y);
a.SetElement(2, 0, 0);
a.SetElement(2, 1, 0);
a.SetElement(2, 2, 1);
// rotation
var b = new GeneralMatrix(3, 3);
b.SetElement(0, 0, cos);
b.SetElement(0, 1, -sin);
b.SetElement(0, 2, 0);
b.SetElement(1, 0, sin);
b.SetElement(1, 1, cos);
b.SetElement(1, 2, 0);
b.SetElement(2, 0, 0);
b.SetElement(2, 1, 0);
b.SetElement(2, 2, 1);
// scaling, note that we need to mirror y scale around x axis
var c = new GeneralMatrix(3, 3);
c.SetElement(0, 0, scaleFactor);
c.SetElement(0, 1, 0);
c.SetElement(0, 2, 0);
c.SetElement(1, 0, 0);
c.SetElement(1, 1, -scaleFactor);
c.SetElement(1, 2, 0);
c.SetElement(2, 0, 0);
c.SetElement(2, 1, 0);
c.SetElement(2, 2, 1);
// translation from origo to pixel space
var d = new GeneralMatrix(3, 3);
d.SetElement(0, 0, 1);
d.SetElement(0, 1, 0);
d.SetElement(0, 2, q0.X);
d.SetElement(1, 0, 0);
d.SetElement(1, 1, 1);
d.SetElement(1, 2, q0.Y);
d.SetElement(2, 0, 0);
d.SetElement(2, 1, 0);
d.SetElement(2, 2, 1);
return(d * c * b * a);
}
else // useRotation == false
{
var m1 = new GeneralMatrix(2, 2);
m1.SetElement(0, 0, p0.X);
m1.SetElement(0, 1, 1);
m1.SetElement(1, 0, p1.X);
m1.SetElement(1, 1, 1);
var v1 = new GeneralMatrix(2, 1);
v1.SetElement(0, 0, q0.X);
v1.SetElement(1, 0, q1.X);
var t1 = m1.Inverse() * v1;
var m2 = new GeneralMatrix(2, 2);
m2.SetElement(0, 0, p0.Y);
m2.SetElement(0, 1, 1);
m2.SetElement(1, 0, p1.Y);
m2.SetElement(1, 1, 1);
var v2 = new GeneralMatrix(2, 1);
v2.SetElement(0, 0, q0.Y);
v2.SetElement(1, 0, q1.Y);
var t2 = m2.Inverse() * v2;
var t = new GeneralMatrix(3, 3);
t.SetElement(0, 0, t1.GetElement(0, 0));
t.SetElement(0, 1, 0);
t.SetElement(0, 2, t1.GetElement(1, 0));
t.SetElement(1, 0, 0);
t.SetElement(1, 1, t2.GetElement(0, 0));
t.SetElement(1, 2, t2.GetElement(1, 0));
t.SetElement(2, 0, 0);
t.SetElement(2, 1, 0);
t.SetElement(2, 2, 1);
return(t);
}
}
catch (Exception)
{
return((GeneralMatrix)fallbackMatrix.Clone());
}
}
public static PointD ToPointD(GeneralMatrix _3x1Matrix)
{
return(new PointD(_3x1Matrix.GetElement(0, 0), _3x1Matrix.GetElement(1, 0)));
}
public Transformation(GeneralMatrix transformationMatrix, LongLat projectionOrigin)
{
TransformationMatrix = transformationMatrix;
ProjectionOrigin = projectionOrigin;
}
void OnFrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
using (var frame = e.FrameReference.AcquireFrame())
{
if ((frame != null) && (frame.BodyCount > 0))
{
if ((this.bodies == null) || (this.bodies.Length != frame.BodyCount))
{
this.bodies = new Body[frame.BodyCount];
}
frame.GetAndRefreshBodyData(this.bodies); // Sensor will reveive 6 body -> this mean for 6 people
for (int i = 0; i < brushes.Length; i++)
{
if (this.bodies[i].IsTracked) // For this testing will only get 1 body that is tracked
{
this.bodyDrawers[i].DrawFrame(this.bodies[i]);
if (count < dt)
{
rBody[count] = this.bodies[i];
}
else
{
// Calculate R Variance every 30 Frame Body
calcRVariance();
// Set the counter back to 0 (restart the frame tracked count)
// Set body hist
count = 0;
rBody[count] = this.bodies[i];
}
if ((count + 1) % dt == 0 && count != 0) // Calculate every dt frame
{
// Hitung sudut dari sensor kamera RULA
this.calculateAngle(this.bodies[i]);
// Lakukan perhitungan RULA
this.calculateRulaEngine();
}
// Initialize Xk-1
if (first)
{
if (count + 1 == dt - 1)
{
for (int c = 0; c < Xk.Length; c++)
{
GeneralMatrix StateMatrix = GeneralMatrix.Random(6, 1);
StateMatrix.SetElement(0, 0, rBody[count].Joints[GlobalVal.BodyPart[c]].Position.X);
StateMatrix.SetElement(1, 0, rBody[count].Joints[GlobalVal.BodyPart[c]].Position.Y);
StateMatrix.SetElement(2, 0, rBody[count].Joints[GlobalVal.BodyPart[c]].Position.Z);
StateMatrix.SetElement(3, 0, 1);
StateMatrix.SetElement(4, 0, 1);
StateMatrix.SetElement(5, 0, 1);
Xk[c] = StateMatrix;
}
first = false;
}
}
// Count the frame
count += 1;
}
else
{
this.bodyDrawers[i].ClearFrame();
}
}
}
}
}
/// <summary>
/// Converts a map image pixel coordinate to a longitude and latitude coordinate
/// </summary>
/// <param name="mapImagePosition">Map pixel coordinate, referring to unzoomed map without any borders and image header</param>
/// <returns></returns>
public LongLat GetLongLatForMapImagePosition(PointD mapImagePosition, GeneralMatrix averageTransformationMatrixInverse)
{
var projectedPosition = LinearAlgebraUtil.Transform(mapImagePosition, averageTransformationMatrixInverse);
return(LongLat.Deproject(projectedPosition, ProjectionOrigin));
}
static void Unsubscribe(GeneralMatrix<int> matrix)
{
matrix.ElementChanged -= ElementChanged;
}
public RubineRecognizer()
{
_weights = new GeneralMatrix(1, 1);
_weights_0 = new List <double>();
_classNames = new List <string>();
}
public void InitData()
{
A = new GeneralMatrix(columnwise, validld);
T = new GeneralMatrix(tvals);
}
public void MultiplyZero()
{
GeneralMatrix Z = new GeneralMatrix(A.RowDimension, A.ColumnDimension);
Assert.IsTrue(GeneralTests.Check(A.Multiply(0.0), Z));
}
public static void Main(System.String[] argv)
{
/*
| Tests LU, QR, SVD and symmetric Eig decompositions.
|
| n = order of magic square.
| trace = diagonal sum, should be the magic sum, (n^3 + n)/2.
| max_eig = maximum eigenvalue of (A + A')/2, should equal trace.
| rank = linear algebraic rank,
| should equal n if n is odd, be less than n if n is even.
| cond = L_2 condition number, ratio of singular values.
| lu_res = test of LU factorization, norm1(L*U-A(p,:))/(n*eps).
| qr_res = test of QR factorization, norm1(Q*R-A)/(n*eps).
*/
print("\n Test of GeneralMatrix Class, using magic squares.\n");
print(" See MagicSquareExample.main() for an explanation.\n");
print("\n n trace max_eig rank cond lu_res qr_res\n\n");
System.DateTime start_time = System.DateTime.Now;
double eps = System.Math.Pow(2.0, -52.0);
for (int n = 3; n <= 32; n++)
{
print(fixedWidthIntegertoString(n, 7));
GeneralMatrix M = magic(n);
//UPGRADE_WARNING: Narrowing conversions may produce unexpected results in C#. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1042"'
int t = (int)M.Trace();
print(fixedWidthIntegertoString(t, 10));
EigenvalueDecomposition E = new EigenvalueDecomposition(M.Add(M.Transpose()).Multiply(0.5));
double[] d = E.RealEigenvalues;
print(fixedWidthDoubletoString(d[n - 1], 14, 3));
int r = M.Rank();
print(fixedWidthIntegertoString(r, 7));
double c = M.Condition();
print(c < 1 / eps ? fixedWidthDoubletoString(c, 12, 3):" Inf");
LUDecomposition LU = new LUDecomposition(M);
GeneralMatrix L = LU.L;
GeneralMatrix U = LU.U;
int[] p = LU.Pivot;
GeneralMatrix R = L.Multiply(U).Subtract(M.GetMatrix(p, 0, n - 1));
double res = R.Norm1() / (n * eps);
print(fixedWidthDoubletoString(res, 12, 3));
QRDecomposition QR = new QRDecomposition(M);
GeneralMatrix Q = QR.Q;
R = QR.R;
R = Q.Multiply(R).Subtract(M);
res = R.Norm1() / (n * eps);
print(fixedWidthDoubletoString(res, 12, 3));
print("\n");
}
System.DateTime stop_time = System.DateTime.Now;
double etime = (stop_time.Ticks - start_time.Ticks) / 1000.0;
print("\nElapsed Time = " + fixedWidthDoubletoString(etime, 12, 3) + " seconds\n");
print("Adios\n");
}
/// <summary>Generate magic square test matrix. *</summary>
public static GeneralMatrix magic(int n)
{
double[][] M = new double[n][];
for (int i = 0; i < n; i++)
{
M[i] = new double[n];
}
// Odd order
if ((n % 2) == 1)
{
int a = (n + 1) / 2;
int b = (n + 1);
for (int j = 0; j < n; j++)
{
for (int i = 0; i < n; i++)
{
M[i][j] = n * ((i + j + a) % n) + ((i + 2 * j + b) % n) + 1;
}
}
// Doubly Even Order
}
else if ((n % 4) == 0)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < n; i++)
{
if (((i + 1) / 2) % 2 == ((j + 1) / 2) % 2)
{
M[i][j] = n * n - n * i - j;
}
else
{
M[i][j] = n * i + j + 1;
}
}
}
// Singly Even Order
}
else
{
int p = n / 2;
int k = (n - 2) / 4;
GeneralMatrix A = magic(p);
for (int j = 0; j < p; j++)
{
for (int i = 0; i < p; i++)
{
double aij = A.GetElement(i, j);
M[i][j] = aij;
M[i][j + p] = aij + 2 * p * p;
M[i + p][j] = aij + 3 * p * p;
M[i + p][j + p] = aij + p * p;
}
}
for (int i = 0; i < p; i++)
{
for (int j = 0; j < k; j++)
{
double t = M[i][j]; M[i][j] = M[i + p][j]; M[i + p][j] = t;
}
for (int j = n - k + 1; j < n; j++)
{
double t = M[i][j]; M[i][j] = M[i + p][j]; M[i + p][j] = t;
}
}
double t2 = M[k][0]; M[k][0] = M[k + p][0]; M[k + p][0] = t2;
t2 = M[k][k]; M[k][k] = M[k + p][k]; M[k + p][k] = t2;
}
return(new GeneralMatrix(M));
}
// this is the straight forward implementation of the kabsch algorithm.
// see http://en.wikipedia.org/wiki/Kabsch_algorithm for a detailed explanation.
public void Evaluate(int SpreadMax)
{
FOutput.SliceCount = 1;
Matrix4x4 mOut;
if (FInputP.SliceCount > 0 && FInputQ.SliceCount > 0 && FInputEnabled[0])
{
// ======================== STEP 1 ========================
// translate both sets so that their centroids coincides with the origin
// of the coordinate system.
double[] meanP = new double[3] {
0.0, 0.0, 0.0
}; // mean of first point set
for (int i = 0; i < FInputP.SliceCount; i++)
{
meanP[0] += FInputP[i].x;
meanP[1] += FInputP[i].y;
meanP[2] += FInputP[i].z;
}
meanP[0] /= FInputP.SliceCount;
meanP[1] /= FInputP.SliceCount;
meanP[2] /= FInputP.SliceCount;
double[][] centroidP = new double[3][] { new double[] { meanP[0] }, new double[] { meanP[1] }, new double[] { meanP[2] } };
GeneralMatrix mCentroidP = new GeneralMatrix(centroidP);
double[][] arrayP = new double[FInputP.SliceCount][];
for (int i = 0; i < FInputP.SliceCount; i++)
{
arrayP[i] = new double[3];
arrayP[i][0] = FInputP[i].x - meanP[0]; // subtract the mean values from the incoming pointset
arrayP[i][1] = FInputP[i].y - meanP[1];
arrayP[i][2] = FInputP[i].z - meanP[2];
}
// this is the matrix of the first pointset translated to the origin of the coordinate system
GeneralMatrix P = new GeneralMatrix(arrayP);
double[] meanQ = new double[3] {
0.0, 0.0, 0.0
}; // mean of second point set
for (int i = 0; i < FInputQ.SliceCount; i++)
{
meanQ[0] += FInputQ[i].x;
meanQ[1] += FInputQ[i].y;
meanQ[2] += FInputQ[i].z;
}
meanQ[0] /= FInputQ.SliceCount;
meanQ[1] /= FInputQ.SliceCount;
meanQ[2] /= FInputQ.SliceCount;
double[][] centroidQ = new double[3][] { new double[] { meanQ[0] }, new double[] { meanQ[1] }, new double[] { meanQ[2] } };
GeneralMatrix mCentroidQ = new GeneralMatrix(centroidQ);
double[][] arrayQ = new double[FInputQ.SliceCount][];
for (int i = 0; i < FInputQ.SliceCount; i++)
{
arrayQ[i] = new double[3];
arrayQ[i][0] = FInputQ[i].x - meanQ[0]; // subtract the mean values from the incoming pointset
arrayQ[i][1] = FInputQ[i].y - meanQ[1];
arrayQ[i][2] = FInputQ[i].z - meanQ[2];
}
// this is the matrix of the second pointset translated to the origin of the coordinate system
GeneralMatrix Q = new GeneralMatrix(arrayQ);
// ======================== STEP2 ========================
// calculate a covariance matrix A and compute the optimal rotation matrix
GeneralMatrix A = P.Transpose() * Q;
SingularValueDecomposition svd = A.SVD();
GeneralMatrix U = svd.GetU();
GeneralMatrix V = svd.GetV();
// calculate determinant for a special reflexion case.
double det = (V * U.Transpose()).Determinant();
double[][] arrayD = new double[3][] { new double[] { 1, 0, 0 },
new double[] { 0, 1, 0 },
new double[] { 0, 0, 1 } };
arrayD[2][2] = det < 0 ? -1 : 1; // multiply 3rd column with -1 if determinant is < 0
GeneralMatrix D = new GeneralMatrix(arrayD);
// now we can compute the rotation matrix:
GeneralMatrix R = V * D * U.Transpose();
// ======================== STEP3 ========================
// calculate the translation:
GeneralMatrix T = mCentroidP - R.Inverse() * mCentroidQ;
// ================== OUTPUT TRANSFORM ===================
mOut.m11 = (R.Array)[0][0];
mOut.m12 = (R.Array)[0][1];
mOut.m13 = (R.Array)[0][2];
mOut.m14 = 0;
mOut.m21 = (R.Array)[1][0];
mOut.m22 = (R.Array)[1][1];
mOut.m23 = (R.Array)[1][2];
mOut.m24 = 0;
mOut.m31 = (R.Array)[2][0];
mOut.m32 = (R.Array)[2][1];
mOut.m33 = (R.Array)[2][2];
mOut.m34 = 0;
mOut.m41 = (T.Array)[0][0];
mOut.m42 = (T.Array)[1][0];
mOut.m43 = (T.Array)[2][0];
mOut.m44 = 1;
FOutput[0] = mOut;
}
//FLogger.Log(LogType.Debug, T.Array[2][0].ToString());
}
private void calculateCCMInverse()
{
this.ccmInverse = ccm.Inverse();
}
private void updateWeightsSize()
{
this.weights = new GeneralMatrix(this.classes.Count, this.classes[0].CovarianceMatrix.RowDimension, 0.0);
this.weights_0 = new List <double>(this.classes.Count);
}
public void setTranslation(GeneralMatrix gm)
{
setTranslation(gm.Array[0]);
}
/// <summary>Least squares solution of A*X = B</summary>
/// <param name="B"> A Matrix with as many rows as A and any number of columns.
/// </param>
/// <returns> X that minimizes the two norm of Q*R*X-B.
/// </returns>
/// <exception cref="System.ArgumentException"> Matrix row dimensions must agree.
/// </exception>
/// <exception cref="System.SystemException"> Matrix is rank deficient.
/// </exception>
public virtual GeneralMatrix Solve(GeneralMatrix B)
{
if (B.RowDimension != m)
{
throw new System.ArgumentException("GeneralMatrix row dimensions must agree.");
}
if (!this.FullRank)
{
throw new System.SystemException("Matrix is rank deficient.");
}
// Copy right hand side
int nx = B.ColumnDimension;
double[][] X = B.ArrayCopy;
// Compute Y = transpose(Q)*B
for (int k = 0; k < n; k++)
{
for (int j = 0; j < nx; j++)
{
double s = 0.0;
for (int i = k; i < m; i++)
{
s += QR[i][k] * X[i][j];
}
s = (- s) / QR[k][k];
for (int i = k; i < m; i++)
{
X[i][j] += s * QR[i][k];
}
}
}
// Solve R*X = Y;
for (int k = n - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k][j] /= Rdiag[k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * QR[i][k];
}
}
}
return (new GeneralMatrix(X, n, nx).GetMatrix(0, n - 1, 0, nx - 1));
}
private void FrmProcessLoad(object sender, EventArgs e)
{
//insertLog("\nENTER FUNC()=> private void FrmProcess_Load(...)");
//_____START CALCULATING AHP
log.Clear();
log.Text += "[START] Kalkulasi Kriteria...";
if (CalculatePcmCriteria())
{
InsertLog("[OK] Nilai Consistency Ratio dapat diterima\n");
}
else
{
InsertLog("[ERROR] Nilai Consistency Ratio tidak dapat diterima\n" +
"Proses tidak dapat dilanjutkan");
// ReSharper disable RedundantJumpStatement
return;
// ReSharper restore RedundantJumpStatement
}
InsertLog("\n[START] Kalkulasi kandidat...");
var dt = _dbConnect.GetRecord(string.Format("SELECT kode,nama " +
"FROM tbl_kriteria " +
"WHERE aktif='{0}' " +
"ORDER BY kode", "True"));
int countCandidate = _dbConnect.intExecuteScalar("SELECT COUNT(*) " +
"FROM tbl_anggota");
//inisialisasi AHP model
AHPModel model = new AHPModel(dt.Rows.Count, countCandidate);
//add kriteria
model.AddCriteria(_criteria);
//untuk masing-masing kriteria..
for (int i = 0; i < dt.Rows.Count; i++)
{
int kodeKriteria = int.Parse(dt.Rows[i][0].ToString());
var dtA = _dbConnect.GetRecord(string.Format("SELECT kode_kriteria_item " +
"FROM tbl_anggota_kriteria_items " +
"WHERE kode_kriteria={0} " +
"ORDER BY kode_anggota", kodeKriteria));
double[][] arrayKandidatBobot = new double[dtA.Rows.Count][];
//kalkulasikan nilai dari matrix kriteria anggota
for (int k = 0; k < dtA.Rows.Count; k++)
{
arrayKandidatBobot[k] = new double[dtA.Rows.Count];
int kodeA = int.Parse(dtA.Rows[k][0].ToString());
for (int l = 0; l < dtA.Rows.Count; l++)
{
if (k == l)
{
//nilai = 1
arrayKandidatBobot[k][l] = 1;
}
else if (k > l)
{
//nilai 0
arrayKandidatBobot[k][l] = 0;
}
else
{
int kodeB = int.Parse(dtA.Rows[l][0].ToString());
arrayKandidatBobot[k][l] = GetNilaiKriteriaItem(kodeA, kodeB);
}
}
}
if (dtA.Rows.Count <= 2)
{
InsertLog("Kandidat <= dari 2, maka tidak perlu dilakukan pengecekan Consistency Index(CI)");
}
else
{
//periksa apakah Pair Comparation matrix untuk kriteria ini punya CI <= CI_acceptableValue ?
if (CalculatePcm(arrayKandidatBobot))
{
InsertLog(string.Format("[OK] Nilai Consistency Ratio untuk {0} dapat diterima\n", dt.Rows[i][1]));
}
else
{
InsertLog("[ERROR] Nilai Consistency Ratio tidak dapat diterima\n" +
"Proses tidak dapat dilanjutkan");
// ReSharper disable RedundantJumpStatement
return;
// ReSharper restore RedundantJumpStatement
}
}
model.AddCriterionRatedChoices(i, arrayKandidatBobot);
}
model.CalculateModel();
GeneralMatrix calcCriteria = model.CalculatedCriteria;
GeneralMatrix results = model.ModelResult;
GeneralMatrix choices = model.CalculatedChoices;
//choices: SF 42%, Orlando31%, NY 27%
//Assert.AreEqual(31, System.Math.Round(choices.GetElement(0, 0) * 100, 0));
//Assert.AreEqual(42, System.Math.Round(choices.GetElement(1, 0) * 100, 0));
//Assert.AreEqual(27, System.Math.Round(choices.GetElement(2, 0) * 100, 0));
//clear all rows on gridview
dtGridView.Columns.Clear();
var dgvColumnKriteria = new DataGridViewTextBoxColumn
{
HeaderText = "Kriteria",
Name = "kriteria",
SortMode = DataGridViewColumnSortMode.NotSortable
};
int colKriteria = dtGridView.Columns.Add(dgvColumnKriteria);
dtGridView.Columns[colKriteria].Frozen = true;
var dgvColumnWeight = new DataGridViewTextBoxColumn
{
HeaderText = "Berat",
Name = "Weight",
SortMode = DataGridViewColumnSortMode.NotSortable
};
dtGridView.Columns.Add(dgvColumnWeight);
// calcCriteria : weight cantik -> kaya
// result : choise yayu (cantik -> kaya)
// grace (cantik -> kaya)
// fitri (cantik -> kaya)
// choices :Composite Weight (Yayu ->Fitri)
//insert candidate name
var dtKandidat = _dbConnect.GetRecord("SELECT nama " +
"FROM tbl_anggota " +
"ORDER BY kode");
for (int a = 0; a < dtKandidat.Rows.Count; a++)
{
var dgvColumn = new DataGridViewTextBoxColumn
{
HeaderText = dtKandidat.Rows[a][0].ToString(),
Name = string.Format("kandidat-{0}", a),
SortMode = DataGridViewColumnSortMode.NotSortable
};
dtGridView.Columns.Add(dgvColumn);
}
var dtKriteria = _dbConnect.GetRecord("SELECT nama " +
"FROM tbl_kriteria " +
"ORDER BY kode");
//string[] chartSeriesArray = new string[dtKriteria.Rows.Count];
chart1.Series.Clear();
chart1.ChartAreas[0].BackColor = Color.LightBlue;
chart1.ChartAreas[0].BackSecondaryColor = Color.White;
chart1.ChartAreas[0].BackGradientStyle = GradientStyle.TopBottom;
chart1.ChartAreas[0].BorderColor = Color.Black;
chart1.ChartAreas[0].BorderDashStyle = ChartDashStyle.Solid;
chart1.ChartAreas[0].BorderWidth = 1;
chart1.ChartAreas[0].ShadowOffset = 4;
//chart1.ChartAreas[0].Area3DStyle.Enable3D = true;
//chart1.ChartAreas[0].Area3DStyle.Inclination = 90;
//chart1.ChartAreas[0].Area3DStyle.Rotation = 45;
chart1.ChartAreas[0].Area3DStyle.LightStyle = LightStyle.Simplistic;
chart1.Legends[0].BackColor = Color.LightBlue;
chart1.Legends[0].BackSecondaryColor = Color.White;
chart1.Legends[0].BackGradientStyle = GradientStyle.DiagonalLeft;
chart1.Legends[0].BorderColor = Color.Black;
chart1.Legends[0].BorderWidth = 1;
chart1.Legends[0].BorderDashStyle = ChartDashStyle.Solid;
chart1.Legends[0].ShadowOffset = 2;
for (int i = 0; i < dtKriteria.Rows.Count; i++)
{
//add new ros
dtGridView.Rows.Add(1);
dtGridView[0, i].Value = dtKriteria.Rows[i][0].ToString();
string seriesName = dtKriteria.Rows[i][0].ToString();
this.chart1.Series.Add(seriesName);
//gunakan ini untuk swith axis -> chart1.Series[seriesName].ChartType = SeriesChartType.Bar;
chart1.Series[seriesName].ChartType = SeriesChartType.Column;
chart1.Series[seriesName].BorderWidth = 0;
chart1.Series[seriesName].ShadowOffset = 3;
dtGridView[1, i].Value = System.Math.Round(calcCriteria.GetElement(i, 0), 4);
for (int j = 0; j < dtKandidat.Rows.Count; j++)
{
double val = results.GetElement(j, i);
dtGridView[j + 2, i].Value = System.Math.Round(val, 4);
string kandidateName = dtKandidat.Rows[j][0].ToString();
chart1.Series[seriesName].Points.AddXY(kandidateName, val);
}
}
//composite weight
dtGridView.Rows.Add(1);
dtGridView[0, dtGridView.Rows.Count - 1].Value = "Composite Weight";
for (int b = 0; b < dtKandidat.Rows.Count; b++)
{
dtGridView[b + 2, dtGridView.Rows.Count - 1].Value = string.Format("{0}", System.Math.Round(choices.GetElement(b, 0), 3), System.Math.Round(choices.GetElement(b, 0) * 100, 0));
}
}
public void MatricesAdditionDifferentAddendsSizesTest()
{
GeneralMatrix<int> matrix1 = new GeneralMatrix<int>(new int[3, 4] { { 1, 2, 3, 4 }, { 2, 1, 2, 4 }, { 3, 2, 1, 4 } });
GeneralMatrix<int> matrix2 = new GeneralMatrix<int>(new int[3, 3] { { 1, 2, 3 }, { 2, 1, 2 }, { 3, 2, 1 } });
matrix1.SumWith(matrix2, AdditionMethod);
}
public void AddCriteria(GeneralMatrix matrix)
{
_criteria = ExpandUtility(matrix);
}
/// <summary>
/// QR�ֽⷨ
/// </summary>
/// <param name="st7"></param>
public void CalculateTrans7Param3(List<Coords7ST> st7)
{
double[][] A = new double[0][];
double[][] B = new double[0][];
InitMatrixAB(ref A, ref B, st7);
GeneralMatrix matrixA = new GeneralMatrix(A);
GeneralMatrix matrixB = new GeneralMatrix(B);
QRDecomposition qrDecp = matrixA.QRD();
GeneralMatrix q = qrDecp.Q;
GeneralMatrix r = qrDecp.R;
GeneralMatrix matrixParam = r.Inverse().Multiply(q.Transpose()).Multiply(matrixB);
this.Set4Param(matrixParam.GetElement(0, 0), matrixParam.GetElement(1, 0), matrixParam.GetElement(2, 0), matrixParam.GetElement(6, 0));
this.SetRotationParam(matrixParam.GetElement(3, 0), matrixParam.GetElement(4, 0), matrixParam.GetElement(5, 0));
}
public void AddCriteria(double[][] matrix)
{
GeneralMatrix newMatrix = new GeneralMatrix(matrix);
AddCriteria(newMatrix);
}
/// <summary>
/// Creating a new document using the specified map, route, laps, initial transformation matrix and document settings, and adding one new session with the specified route and laps.
/// </summary>
/// <param name="map"></param>
/// <param name="route"></param>
/// <param name="laps"></param>
/// <param name="initialTransformationMatrix"></param>
/// <param name="settings"></param>
public Document(Map map, Route route, LapCollection laps, GeneralMatrix initialTransformationMatrix, DocumentSettings settings)
: this(map, route, laps, initialTransformationMatrix, null, settings)
{
}
public void AddCriterionRatedChoices(int criterionId, double[][] matrix)
{
GeneralMatrix gMatrix = new GeneralMatrix(matrix);
AddCriterionRatedChoices(criterionId, gMatrix);
}
/// <summary>
///
/// </summary>
/// <param name="p0">First point on route</param>
/// <param name="q0">First point on map</param>
/// <param name="p1">Second point on route</param>
/// <param name="q1">Second point on map</param>
/// <param name="p2">Third point on route</param>
/// <param name="q2">Third point on map</param>
/// <param name="fallbackMatrix">Matrix to use if calculation fails due to singular matrix</param>
/// <returns></returns>
public static GeneralMatrix CalculateTransformationMatrix(PointD p0, PointD q0, PointD p1, PointD q1, PointD p2, PointD q2, GeneralMatrix fallbackMatrix)
{
try
{
var m = new GeneralMatrix(3, 3);
m.SetElement(0, 0, p0.X);
m.SetElement(0, 1, p0.Y);
m.SetElement(0, 2, 1.0);
m.SetElement(1, 0, p1.X);
m.SetElement(1, 1, p1.Y);
m.SetElement(1, 2, 1.0);
m.SetElement(2, 0, p2.X);
m.SetElement(2, 1, p2.Y);
m.SetElement(2, 2, 1.0);
var v1 = new GeneralMatrix(3, 1);
v1.SetElement(0, 0, q0.X);
v1.SetElement(1, 0, q1.X);
v1.SetElement(2, 0, q2.X);
var t1 = m.Inverse() * v1;
var v2 = new GeneralMatrix(3, 1);
v2.SetElement(0, 0, q0.Y);
v2.SetElement(1, 0, q1.Y);
v2.SetElement(2, 0, q2.Y);
var t2 = m.Inverse() * v2;
var v3 = new GeneralMatrix(3, 1);
v3.SetElement(0, 0, 1.0);
v3.SetElement(1, 0, 1.0);
v3.SetElement(2, 0, 1.0);
var t3 = m.Inverse() * v3;
var t = new GeneralMatrix(3, 3);
t.SetElement(0, 0, t1.GetElement(0, 0));
t.SetElement(0, 1, t1.GetElement(1, 0));
t.SetElement(0, 2, t1.GetElement(2, 0));
t.SetElement(1, 0, t2.GetElement(0, 0));
t.SetElement(1, 1, t2.GetElement(1, 0));
t.SetElement(1, 2, t2.GetElement(2, 0));
t.SetElement(2, 0, t3.GetElement(0, 0));
t.SetElement(2, 1, t3.GetElement(1, 0));
t.SetElement(2, 2, t3.GetElement(2, 0));
return(t);
}
catch (Exception)
{
return((GeneralMatrix)fallbackMatrix.Clone());
}
}
private void computeaccCalButton_Click(object sender, EventArgs e)
{
int i, j;
calStatusText.Text = "Computing Calibration...";
// Construct D matrix
// D = [x.^2, y.^2, z.^2, x.*y, x.*z, y.*z, x, y, z, ones(N,1)];
for (i = 0; i < SAMPLES; i++)
{
// x^2 term
D.SetElement(i, 0, loggedData[i, 0] * loggedData[i, 0]);
// y^2 term
D.SetElement(i, 1, loggedData[i, 1] * loggedData[i, 1]);
// z^2 term
D.SetElement(i, 2, loggedData[i, 2] * loggedData[i, 2]);
// x*y term
D.SetElement(i, 3, loggedData[i, 0] * loggedData[i, 1]);
// x*z term
D.SetElement(i, 4, loggedData[i, 0] * loggedData[i, 2]);
// y*z term
D.SetElement(i, 5, loggedData[i, 1] * loggedData[i, 2]);
// x term
D.SetElement(i, 6, loggedData[i, 0]);
// y term
D.SetElement(i, 7, loggedData[i, 1]);
// z term
D.SetElement(i, 8, loggedData[i, 2]);
// Constant term
D.SetElement(i, 9, 1);
}
// QR=triu(qr(D))
QRDecomposition QR = new QRDecomposition(D);
// [U,S,V] = svd(D)
SingularValueDecomposition SVD = new SingularValueDecomposition(QR.R);
GeneralMatrix V = SVD.GetV();
GeneralMatrix A = new GeneralMatrix(3, 3);
double[] p = new double[V.RowDimension];
for (i = 0; i < V.RowDimension; i++)
{
p[i] = V.GetElement(i, V.ColumnDimension - 1);
}
/*
* A = [p(1) p(4)/2 p(5)/2;
* p(4)/2 p(2) p(6)/2;
* p(5)/2 p(6)/2 p(3)];
*/
if (p[0] < 0)
{
for (i = 0; i < V.RowDimension; i++)
{
p[i] = -p[i];
}
}
A.SetElement(0, 0, p[0]);
A.SetElement(0, 1, p[3] / 2);
A.SetElement(1, 2, p[4] / 2);
A.SetElement(1, 0, p[3] / 2);
A.SetElement(1, 1, p[1]);
A.SetElement(1, 2, p[5] / 2);
A.SetElement(2, 0, p[4] / 2);
A.SetElement(2, 1, p[5] / 2);
A.SetElement(2, 2, p[2]);
CholeskyDecomposition Chol = new CholeskyDecomposition(A);
GeneralMatrix Ut = Chol.GetL();
GeneralMatrix U = Ut.Transpose();
double[] bvect = { p[6] / 2, p[7] / 2, p[8] / 2 };
double d = p[9];
GeneralMatrix b = new GeneralMatrix(bvect, 3);
GeneralMatrix v = Ut.Solve(b);
double vnorm_sqrd = v.GetElement(0, 0) * v.GetElement(0, 0) + v.GetElement(1, 0) * v.GetElement(1, 0) + v.GetElement(2, 0) * v.GetElement(2, 0);
double s = 1 / Math.Sqrt(vnorm_sqrd - d);
GeneralMatrix c = U.Solve(v);
for (i = 0; i < 3; i++)
{
c.SetElement(i, 0, -c.GetElement(i, 0));
}
U = U.Multiply(s);
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
calMat[i, j] = U.GetElement(i, j);
}
}
for (i = 0; i < 3; i++)
{
bias[i] = c.GetElement(i, 0);
}
accAlignment00.Text = calMat[0, 0].ToString();
accAlignment01.Text = calMat[0, 1].ToString();
accAlignment02.Text = calMat[0, 2].ToString();
accAlignment10.Text = calMat[1, 0].ToString();
accAlignment11.Text = calMat[1, 1].ToString();
accAlignment12.Text = calMat[1, 2].ToString();
accAlignment20.Text = calMat[2, 0].ToString();
accAlignment21.Text = calMat[2, 1].ToString();
accAlignment22.Text = calMat[2, 2].ToString();
biasX.Text = bias[0].ToString();
biasY.Text = bias[1].ToString();
biasZ.Text = bias[2].ToString();
calStatusText.Text = "Done";
flashCommitButton.Enabled = true;
accAlignmentCommitButton.Enabled = true;
}
public static PointF ToPointF(GeneralMatrix _3x1Matrix)
{
return(new PointF((float)_3x1Matrix.GetElement(0, 0), (float)_3x1Matrix.GetElement(1, 0)));
}
public CoordinateMapping()
{
m_transform = GeneralMatrix.Identity(3, 3);
}
public static PointD Transform(PointD p, GeneralMatrix transformationMatrix)
{
return(ConvertUtil.ToPointD(transformationMatrix * ConvertUtil.To3x1Matrix(p)));
}
public void Clear()
{
m_transform = GeneralMatrix.Identity(3, 3);
}
public TransformMatrix(GeneralMatrix gm) : base(4, 4)
{
this.SetMatrix(gm);
}
/// <summary>Solve A*X = B</summary>
/// <param name="B"> A Matrix with as many rows as A and any number of columns.
/// </param>
/// <returns> X so that L*L'*X = B
/// </returns>
/// <exception cref="System.ArgumentException"> Matrix row dimensions must agree.
/// </exception>
/// <exception cref="System.SystemException"> Matrix is not symmetric positive definite.
/// </exception>
public virtual GeneralMatrix Solve(GeneralMatrix B)
{
if (B.RowDimension != n)
{
throw new System.ArgumentException("Matrix row dimensions must agree.");
}
if (!isspd)
{
throw new System.SystemException("Matrix is not symmetric positive definite.");
}
// Copy right hand side.
double[][] X = B.ArrayCopy;
int nx = B.ColumnDimension;
// Solve L*Y = B;
for (int k = 0; k < n; k++)
{
for (int i = k + 1; i < n; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * L[i][k];
}
}
for (int j = 0; j < nx; j++)
{
X[k][j] /= L[k][k];
}
}
// Solve L'*X = Y;
for (int k = n - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k][j] /= L[k][k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * L[k][i];
}
}
}
return new GeneralMatrix(X, n, nx);
}
/// <summary>
/// multiply normalized priority matrix by sum of average rows
/// </summary>
/// <param name="argMatrix"></param>
/// <param name="selection"></param>
/// <returns></returns>
private GeneralMatrix FCalc(GeneralMatrix argMatrix, GeneralMatrix selection)
{
GeneralMatrix matrix = argMatrix.Multiply(selection);
return(matrix.ArrayRightDivide(selection));
}
public void GeneralMatrixSetterTest()
{
GeneralMatrix<int> matrix = new GeneralMatrix<int>(new int[3, 4] { { 1, 2, 3, 4 }, { 2, 1, 2, 4 }, { 3, 2, 1, 4 } });
matrix[0, 3] = 5;
matrix[1, 1] = 10;
Assert.AreEqual<int>(5, matrix[0, 3]);
Assert.AreEqual<int>(10, matrix[1, 1]);
}
private byte[] CreateSessionData(Session session)
{
var sessionStream = new MemoryStream();
var sessionWriter = new BinaryWriter(sessionStream);
// route
var routeStream = new MemoryStream();
var routeWriter = new BinaryWriter(routeStream);
// which attributes to include for each waypoint
var attributes = WaypointAttribute.Position | WaypointAttribute.Time;
if (session.Route.ContainsWaypointAttribute(BusinessEntities.WaypointAttribute.HeartRate))
{
attributes |= WaypointAttribute.HeartRate;
}
if (session.Route.ContainsWaypointAttribute(BusinessEntities.WaypointAttribute.Altitude))
{
attributes |= WaypointAttribute.Altitude;
}
routeWriter.Write((UInt16)attributes);
// any extra length in bytes for future elements for each waypoint
routeWriter.Write((UInt16)0);
// number of route segments in this route
routeWriter.Write((UInt32)session.Route.Segments.Count);
foreach (var routeSegment in session.Route.Segments)
{
// number of waypoints in this route segment
routeWriter.Write((UInt32)routeSegment.Waypoints.Count);
var lastTime = DateTime.MinValue;
foreach (var waypoint in routeSegment.Waypoints)
{
// position: 8 bytes
WriteLongLat(waypoint.LongLat, routeWriter);
// time and tome type: 1 + 2-8 bytes
WriteTimeTypeAndTime(waypoint.Time, lastTime, routeWriter);
lastTime = waypoint.Time;
// heart rate: 1 byte
if ((((UInt16)attributes) & ((UInt16)WaypointAttribute.HeartRate)) == (UInt16)WaypointAttribute.HeartRate)
{
routeWriter.Write((byte)(waypoint.HeartRate.HasValue ? Math.Min(Math.Max(waypoint.HeartRate.Value, byte.MinValue), byte.MaxValue) : byte.MinValue));
}
// altitude: 2 bytes
if ((((UInt16)attributes) & ((UInt16)WaypointAttribute.Altitude)) == (UInt16)WaypointAttribute.Altitude)
{
routeWriter.Write((Int16)(waypoint.Altitude.HasValue ? Math.Min(Math.Max(waypoint.Altitude.Value, Int16.MinValue), Int16.MaxValue) : 0));
}
}
}
sessionWriter.Write((byte)Tags.Route);
sessionWriter.Write((UInt32)routeStream.Length);
sessionWriter.Write(routeStream.ToArray());
routeWriter.Close();
routeStream.Close();
routeStream.Dispose();
// handles
// TODO: adjust for zoom
var handleStream = new MemoryStream();
var handleWriter = new BinaryWriter(handleStream);
handleWriter.Write((UInt32)session.Handles.Length);
foreach (var handle in session.Handles)
{
// transformation matrix
var scaleMatrix = new GeneralMatrix(new[] { PercentualSize, 0, 0, 0, PercentualSize, 0, 0, 0, 1 }, 3);
var scaledTM = scaleMatrix * handle.TransformationMatrix;
for (var i = 0; i < 3; i++)
{
for (var j = 0; j < 3; j++)
{
handleWriter.Write(scaledTM.GetElement(i, j));
}
}
// parameterized location
handleWriter.Write((UInt32)handle.ParameterizedLocation.SegmentIndex);
handleWriter.Write(handle.ParameterizedLocation.Value);
// pixel location
handleWriter.Write(PercentualSize * handle.Location.X);
handleWriter.Write(PercentualSize * handle.Location.Y);
// type
handleWriter.Write((Int16)handle.Type);
}
sessionWriter.Write((byte)Tags.Handles);
sessionWriter.Write((UInt32)handleStream.Length);
sessionWriter.Write(handleStream.ToArray());
handleWriter.Close();
handleStream.Close();
handleStream.Dispose();
// projection origin
sessionWriter.Write((byte)Tags.ProjectionOrigin);
sessionWriter.Write((UInt32)8);
WriteLongLat(session.ProjectionOrigin, sessionWriter);
// laps
var lapStream = new MemoryStream();
var lapWriter = new BinaryWriter(lapStream);
lapWriter.Write((UInt32)session.Laps.Count);
foreach (var lap in session.Laps)
{
// time
lapWriter.Write(lap.Time.ToUniversalTime().ToBinary());
// type
lapWriter.Write((byte)lap.LapType);
}
sessionWriter.Write((byte)Tags.Laps);
sessionWriter.Write((UInt32)lapStream.Length);
sessionWriter.Write(lapStream.ToArray());
lapWriter.Close();
lapStream.Close();
lapStream.Dispose();
// session info
var sessionInfoStream = new MemoryStream();
var sessionInfoWriter = new BinaryWriter(sessionInfoStream);
// never change the order or remove field that has already been added!
WriteString(session.SessionInfo.Person.Name, sessionInfoWriter);
WriteString(session.SessionInfo.Person.Club, sessionInfoWriter);
sessionInfoWriter.Write(session.SessionInfo.Person.Id);
WriteString(session.SessionInfo.Description, sessionInfoWriter);
sessionWriter.Write((byte)Tags.SessionInfo);
sessionWriter.Write((UInt32)sessionInfoStream.Length);
sessionWriter.Write(sessionInfoStream.ToArray());
sessionInfoWriter.Close();
sessionInfoStream.Close();
sessionInfoStream.Dispose();
// map reading info
var mapReadingsList = session.Route.GetMapReadingsList();
if (mapReadingsList != null)
{
var mapReadingInfoStream = new MemoryStream();
var mapReadingInfoWriter = new BinaryWriter(mapReadingInfoStream);
var lastTime = DateTime.MinValue;
foreach (var mapReading in mapReadingsList)
{
WriteTimeTypeAndTime(mapReading, lastTime, mapReadingInfoWriter);
}
sessionWriter.Write((byte)Tags.MapReadingInfo);
sessionWriter.Write((UInt32)mapReadingInfoStream.Length);
sessionWriter.Write(mapReadingInfoStream.ToArray());
mapReadingInfoWriter.Close();
mapReadingInfoStream.Close();
mapReadingInfoStream.Dispose();
}
var data = sessionStream.ToArray();
sessionWriter.Close();
sessionStream.Close();
sessionStream.Dispose();
return(data);
}
public void MatricesAdditionCallingWithNullSecondAddendTest()
{
GeneralMatrix<int> matrix1 = new GeneralMatrix<int>(new int[3, 4] { { 1, 2, 3, 4 }, { 2, 1, 2, 4 }, { 3, 2, 1, 4 } });
GeneralMatrix<int> matrix2 = null;
matrix1.SumWith(matrix2, AdditionMethod);
}
/// <summary>Construct the singular value decomposition</summary>
/// <param name="Arg"> Rectangular matrix
/// </param>
/// <returns> Structure to access U, S and V.
/// </returns>
public SingularValueDecomposition(GeneralMatrix Arg)
{
// Derived from LINPACK code.
// Initialize.
double[][] A = Arg.ArrayCopy;
m = Arg.RowDimension;
n = Arg.ColumnDimension;
int nu = System.Math.Min(m, n);
s = new double[System.Math.Min(m + 1, n)];
U = new double[m][];
for (int i = 0; i < m; i++)
{
U[i] = new double[nu];
}
V = new double[n][];
for (int i2 = 0; i2 < n; i2++)
{
V[i2] = new double[n];
}
double[] e = new double[n];
double[] work = new double[m];
bool wantu = true;
bool wantv = true;
// Reduce A to bidiagonal form, storing the diagonal elements
// in s and the super-diagonal elements in e.
int nct = System.Math.Min(m - 1, n);
int nrt = System.Math.Max(0, System.Math.Min(n - 2, m));
for (int k = 0; k < System.Math.Max(nct, nrt); k++)
{
if (k < nct)
{
// Compute the transformation for the k-th column and
// place the k-th diagonal in s[k].
// Compute 2-norm of k-th column without under/overflow.
s[k] = 0;
for (int i = k; i < m; i++)
{
s[k] = Maths.Hypot(s[k], A[i][k]);
}
if (s[k] != 0.0)
{
if (A[k][k] < 0.0)
{
s[k] = - s[k];
}
for (int i = k; i < m; i++)
{
A[i][k] /= s[k];
}
A[k][k] += 1.0;
}
s[k] = - s[k];
}
for (int j = k + 1; j < n; j++)
{
if ((k < nct) & (s[k] != 0.0))
{
// Apply the transformation.
double t = 0;
for (int i = k; i < m; i++)
{
t += A[i][k] * A[i][j];
}
t = (- t) / A[k][k];
for (int i = k; i < m; i++)
{
A[i][j] += t * A[i][k];
}
}
// Place the k-th row of A into e for the
// subsequent calculation of the row transformation.
e[j] = A[k][j];
}
if (wantu & (k < nct))
{
// Place the transformation in U for subsequent back
// multiplication.
for (int i = k; i < m; i++)
{
U[i][k] = A[i][k];
}
}
if (k < nrt)
{
// Compute the k-th row transformation and place the
// k-th super-diagonal in e[k].
// Compute 2-norm without under/overflow.
e[k] = 0;
for (int i = k + 1; i < n; i++)
{
e[k] = Maths.Hypot(e[k], e[i]);
}
if (e[k] != 0.0)
{
if (e[k + 1] < 0.0)
{
e[k] = - e[k];
}
for (int i = k + 1; i < n; i++)
{
e[i] /= e[k];
}
e[k + 1] += 1.0;
}
e[k] = - e[k];
if ((k + 1 < m) & (e[k] != 0.0))
{
// Apply the transformation.
for (int i = k + 1; i < m; i++)
{
work[i] = 0.0;
}
for (int j = k + 1; j < n; j++)
{
for (int i = k + 1; i < m; i++)
{
work[i] += e[j] * A[i][j];
}
}
for (int j = k + 1; j < n; j++)
{
double t = (- e[j]) / e[k + 1];
for (int i = k + 1; i < m; i++)
{
A[i][j] += t * work[i];
}
}
}
if (wantv)
{
// Place the transformation in V for subsequent
// back multiplication.
for (int i = k + 1; i < n; i++)
{
V[i][k] = e[i];
}
}
}
}
// Set up the final bidiagonal matrix or order p.
int p = System.Math.Min(n, m + 1);
if (nct < n)
{
s[nct] = A[nct][nct];
}
if (m < p)
{
s[p - 1] = 0.0;
}
if (nrt + 1 < p)
{
e[nrt] = A[nrt][p - 1];
}
e[p - 1] = 0.0;
// If required, generate U.
if (wantu)
{
for (int j = nct; j < nu; j++)
{
for (int i = 0; i < m; i++)
{
U[i][j] = 0.0;
}
U[j][j] = 1.0;
}
for (int k = nct - 1; k >= 0; k--)
{
if (s[k] != 0.0)
{
for (int j = k + 1; j < nu; j++)
{
double t = 0;
for (int i = k; i < m; i++)
{
t += U[i][k] * U[i][j];
}
t = (- t) / U[k][k];
for (int i = k; i < m; i++)
{
U[i][j] += t * U[i][k];
}
}
for (int i = k; i < m; i++)
{
U[i][k] = - U[i][k];
}
U[k][k] = 1.0 + U[k][k];
for (int i = 0; i < k - 1; i++)
{
U[i][k] = 0.0;
}
}
else
{
for (int i = 0; i < m; i++)
{
U[i][k] = 0.0;
}
U[k][k] = 1.0;
}
}
}
// If required, generate V.
if (wantv)
{
for (int k = n - 1; k >= 0; k--)
{
if ((k < nrt) & (e[k] != 0.0))
{
for (int j = k + 1; j < nu; j++)
{
double t = 0;
for (int i = k + 1; i < n; i++)
{
t += V[i][k] * V[i][j];
}
t = (- t) / V[k + 1][k];
for (int i = k + 1; i < n; i++)
{
V[i][j] += t * V[i][k];
}
}
}
for (int i = 0; i < n; i++)
{
V[i][k] = 0.0;
}
V[k][k] = 1.0;
}
}
// Main iteration loop for the singular values.
int pp = p - 1;
int iter = 0;
double eps = System.Math.Pow(2.0, - 52.0);
while (p > 0)
{
int k, kase;
// Here is where a test for too many iterations would go.
// This section of the program inspects for
// negligible elements in the s and e arrays. On
// completion the variables kase and k are set as follows.
// kase = 1 if s(p) and e[k-1] are negligible and k<p
// kase = 2 if s(k) is negligible and k<p
// kase = 3 if e[k-1] is negligible, k<p, and
// s(k), ..., s(p) are not negligible (qr step).
// kase = 4 if e(p-1) is negligible (convergence).
for (k = p - 2; k >= - 1; k--)
{
if (k == - 1)
{
break;
}
if (System.Math.Abs(e[k]) <= eps * (System.Math.Abs(s[k]) + System.Math.Abs(s[k + 1])))
{
e[k] = 0.0;
break;
}
}
if (k == p - 2)
{
kase = 4;
}
else
{
int ks;
for (ks = p - 1; ks >= k; ks--)
{
if (ks == k)
{
break;
}
double t = (ks != p?System.Math.Abs(e[ks]):0.0) + (ks != k + 1?System.Math.Abs(e[ks - 1]):0.0);
if (System.Math.Abs(s[ks]) <= eps * t)
{
s[ks] = 0.0;
break;
}
}
if (ks == k)
{
kase = 3;
}
else if (ks == p - 1)
{
kase = 1;
}
else
{
kase = 2;
k = ks;
}
}
k++;
// Perform the task indicated by kase.
switch (kase)
{
// Deflate negligible s(p).
case 1:
{
double f = e[p - 2];
e[p - 2] = 0.0;
for (int j = p - 2; j >= k; j--)
{
double t = Maths.Hypot(s[j], f);
double cs = s[j] / t;
double sn = f / t;
s[j] = t;
if (j != k)
{
f = (- sn) * e[j - 1];
e[j - 1] = cs * e[j - 1];
}
if (wantv)
{
for (int i = 0; i < n; i++)
{
t = cs * V[i][j] + sn * V[i][p - 1];
V[i][p - 1] = (- sn) * V[i][j] + cs * V[i][p - 1];
V[i][j] = t;
}
}
}
}
break;
// Split at negligible s(k).
case 2:
{
double f = e[k - 1];
e[k - 1] = 0.0;
for (int j = k; j < p; j++)
{
double t = Maths.Hypot(s[j], f);
double cs = s[j] / t;
double sn = f / t;
s[j] = t;
f = (- sn) * e[j];
e[j] = cs * e[j];
if (wantu)
{
for (int i = 0; i < m; i++)
{
t = cs * U[i][j] + sn * U[i][k - 1];
U[i][k - 1] = (- sn) * U[i][j] + cs * U[i][k - 1];
U[i][j] = t;
}
}
}
}
break;
// Perform one qr step.
case 3:
{
// Calculate the shift.
double scale = System.Math.Max(System.Math.Max(System.Math.Max(System.Math.Max(System.Math.Abs(s[p - 1]), System.Math.Abs(s[p - 2])), System.Math.Abs(e[p - 2])), System.Math.Abs(s[k])), System.Math.Abs(e[k]));
double sp = s[p - 1] / scale;
double spm1 = s[p - 2] / scale;
double epm1 = e[p - 2] / scale;
double sk = s[k] / scale;
double ek = e[k] / scale;
double b = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1) / 2.0;
double c = (sp * epm1) * (sp * epm1);
double shift = 0.0;
if ((b != 0.0) | (c != 0.0))
{
shift = System.Math.Sqrt(b * b + c);
if (b < 0.0)
{
shift = - shift;
}
shift = c / (b + shift);
}
double f = (sk + sp) * (sk - sp) + shift;
double g = sk * ek;
// Chase zeros.
for (int j = k; j < p - 1; j++)
{
double t = Maths.Hypot(f, g);
double cs = f / t;
double sn = g / t;
if (j != k)
{
e[j - 1] = t;
}
f = cs * s[j] + sn * e[j];
e[j] = cs * e[j] - sn * s[j];
g = sn * s[j + 1];
s[j + 1] = cs * s[j + 1];
if (wantv)
{
for (int i = 0; i < n; i++)
{
t = cs * V[i][j] + sn * V[i][j + 1];
V[i][j + 1] = (- sn) * V[i][j] + cs * V[i][j + 1];
V[i][j] = t;
}
}
t = Maths.Hypot(f, g);
cs = f / t;
sn = g / t;
s[j] = t;
f = cs * e[j] + sn * s[j + 1];
s[j + 1] = (- sn) * e[j] + cs * s[j + 1];
g = sn * e[j + 1];
e[j + 1] = cs * e[j + 1];
if (wantu && (j < m - 1))
{
for (int i = 0; i < m; i++)
{
t = cs * U[i][j] + sn * U[i][j + 1];
U[i][j + 1] = (- sn) * U[i][j] + cs * U[i][j + 1];
U[i][j] = t;
}
}
}
e[p - 2] = f;
iter = iter + 1;
}
break;
// Convergence.
case 4:
{
// Make the singular values positive.
if (s[k] <= 0.0)
{
s[k] = (s[k] < 0.0?- s[k]:0.0);
if (wantv)
{
for (int i = 0; i <= pp; i++)
{
V[i][k] = - V[i][k];
}
}
}
// Order the singular values.
while (k < pp)
{
if (s[k] >= s[k + 1])
{
break;
}
double t = s[k];
s[k] = s[k + 1];
s[k + 1] = t;
if (wantv && (k < n - 1))
{
for (int i = 0; i < n; i++)
{
t = V[i][k + 1]; V[i][k + 1] = V[i][k]; V[i][k] = t;
}
}
if (wantu && (k < m - 1))
{
for (int i = 0; i < m; i++)
{
t = U[i][k + 1]; U[i][k + 1] = U[i][k]; U[i][k] = t;
}
}
k++;
}
iter = 0;
p--;
}
break;
}
}
}
/// <summary>
/// 计算四参数
/// </summary>
/// <param name="st4"></param>
public void CalculateTrans4Param(List<Coords4ST> st4)
{
int count = st4.Count;
double[][] A = new double[count * 2][];
for (int i = 0; i < count * 2; i++)
{
A[i] = new double[4];
}
double[][] B = new double[count * 2][];
for (int i = 0; i < count * 2; i++)
{
B[i] = new double[1];
}
int idx = 0;
for (int i = 0; i < count * 2; i = i + 2)
{
A[i][0] = 1; A[i][1] = 0; A[i][2] = st4[idx].SourceX; A[i][3] = -st4[idx].SourceY;
A[i + 1][0] = 0; A[i + 1][1] = 1; A[i + 1][2] = st4[idx].SourceY; A[i + 1][3] = st4[idx].SourceX;
B[i][0] = st4[idx].TargetX;
B[i + 1][0] = st4[idx].TargetY;
idx = idx + 1;
}
GeneralMatrix matrixA = new GeneralMatrix(A);
GeneralMatrix matrixB = new GeneralMatrix(B);
GeneralMatrix matrixParm = matrixA.Inverse().Multiply(matrixB);
this.dx = matrixParm.GetElement(0, 0);
this.dy = matrixParm.GetElement(1, 0);
this.arf = Math.Atan(matrixParm.GetElement(3, 0) / matrixParm.GetElement(2, 0));
this.k = matrixParm.GetElement(3, 0) / Math.Sin(this.arf);
}
public void MatricesAdditionCallingOnNullReferenceTest()
{
GeneralMatrix<int> matrix1 = null;
GeneralMatrix<int> matrix2 = new GeneralMatrix<int>(new int[3, 4] { { 1, 2, 3, 4 }, { 2, 1, 2, 4 }, { 3, 2, 1, 4 } });
matrix1.SumWith(matrix2, AdditionMethod);
}
/// <summary>Solve A*X = B</summary>
/// <param name="B"> A Matrix with as many rows as A and any number of columns.
/// </param>
/// <returns> X so that L*U*X = B(piv,:)
/// </returns>
/// <exception cref="System.ArgumentException"> Matrix row dimensions must agree.
/// </exception>
/// <exception cref="System.SystemException"> Matrix is singular.
/// </exception>
public virtual GeneralMatrix Solve(GeneralMatrix B)
{
if (B.RowDimension != m)
{
throw new System.ArgumentException("Matrix row dimensions must agree.");
}
if (!this.IsNonSingular)
{
throw new System.SystemException("Matrix is singular.");
}
// Copy right hand side with pivoting
int nx = B.ColumnDimension;
GeneralMatrix Xmat = B.GetMatrix(piv, 0, nx - 1);
double[][] X = Xmat.Array;
// Solve L*Y = B(piv,:)
for (int k = 0; k < n; k++)
{
for (int i = k + 1; i < n; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * LU[i][k];
}
}
}
// Solve U*X = Y;
for (int k = n - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k][j] /= LU[k][k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * LU[i][k];
}
}
}
return Xmat;
}
public void MatricesAdditionCallingWithAdditionRuleTest()
{
GeneralMatrix<int> matrix1 = new GeneralMatrix<int>(new int[3, 4] { { 1, 2, 3, 4 }, { 2, 1, 2, 4 }, { 3, 2, 1, 4 } });
GeneralMatrix<int> matrix2 = new GeneralMatrix<int>(new int[3, 4] { { 1, 2, 3, 4 }, { 2, 1, 2, 4 }, { 3, 2, 1, 4 } });
matrix1.SumWith(matrix2, null);
}
/// <summary>LU Decomposition</summary>
/// <param name="A"> Rectangular matrix
/// </param>
/// <returns> Structure to access L, U and piv.
/// </returns>
public LUDecomposition(GeneralMatrix A)
{
// Use a "left-looking", dot-product, Crout/Doolittle algorithm.
LU = A.ArrayCopy;
m = A.RowDimension;
n = A.ColumnDimension;
piv = new int[m];
for (int i = 0; i < m; i++)
{
piv[i] = i;
}
pivsign = 1;
double[] LUrowi;
double[] LUcolj = new double[m];
// Outer loop.
for (int j = 0; j < n; j++)
{
// Make a copy of the j-th column to localize references.
for (int i = 0; i < m; i++)
{
LUcolj[i] = LU[i][j];
}
// Apply previous transformations.
for (int i = 0; i < m; i++)
{
LUrowi = LU[i];
// Most of the time is spent in the following dot product.
int kmax = System.Math.Min(i, j);
double s = 0.0;
for (int k = 0; k < kmax; k++)
{
s += LUrowi[k] * LUcolj[k];
}
LUrowi[j] = LUcolj[i] -= s;
}
// Find pivot and exchange if necessary.
int p = j;
for (int i = j + 1; i < m; i++)
{
if (System.Math.Abs(LUcolj[i]) > System.Math.Abs(LUcolj[p]))
{
p = i;
}
}
if (p != j)
{
for (int k = 0; k < n; k++)
{
double t = LU[p][k]; LU[p][k] = LU[j][k]; LU[j][k] = t;
}
int k2 = piv[p]; piv[p] = piv[j]; piv[j] = k2;
pivsign = - pivsign;
}
// Compute multipliers.
if (j < m & LU[j][j] != 0.0)
{
for (int i = j + 1; i < m; i++)
{
LU[i][j] /= LU[j][j];
}
}
}
}
public void GeneralMatrixAdditionTest()
{
GeneralMatrix<int> matrix1 = new GeneralMatrix<int>(new int[3, 4] { { 1, 2, 3, 4 }, { 2, 1, 2, 4 }, { 3, 2, 1, 4 } });
GeneralMatrix<int> matrix2 = new GeneralMatrix<int>(new int[3, 4] { { 1, 2, 3, 4 }, { 2, 1, 2, 4 }, { 3, 2, 1, 4 } });
matrix1.SumWith(matrix2, AdditionMethod);
Assert.AreEqual<int>(2, matrix1[0, 0]);
Assert.AreEqual<int>(4, matrix1[0, 1]);
Assert.AreEqual<int>(6, matrix1[0, 2]);
Assert.AreEqual<int>(8, matrix1[0, 3]);
Assert.AreEqual<int>(4, matrix1[1, 0]);
Assert.AreEqual<int>(2, matrix1[1, 1]);
Assert.AreEqual<int>(4, matrix1[1, 2]);
Assert.AreEqual<int>(8, matrix1[1, 3]);
Assert.AreEqual<int>(6, matrix1[2, 0]);
Assert.AreEqual<int>(4, matrix1[2, 1]);
Assert.AreEqual<int>(2, matrix1[2, 2]);
Assert.AreEqual<int>(8, matrix1[2, 3]);
}
public double[][] GetHessian(double[] x)
{
GeneralMatrix mat = CalculateHessian(x);
return(mat.ArrayCopy);
}
/// <summary>
/// Using linear least squares algorithm described at http://en.wikipedia.org/wiki/Linear_least_squares
/// </summary>
/// <returns></returns>
public Transformation CalculateAverageTransformation()
{
var averageProjectionOrigin = new LongLat();
foreach (var session in this)
{
averageProjectionOrigin += session.ProjectionOrigin / Count;
}
if (Count == 0)
{
return(null);
}
var n = 4;
var XtX = new GeneralMatrix(n, n);
var Xty = new GeneralMatrix(n, 1);
var numberOfUnknowns = 0;
foreach (var session in this)
{
var m = session.Handles.Length;
if (m < 2)
{
continue;
}
numberOfUnknowns += m;
var startDistance = session.Route.GetAttributeFromParameterizedLocation(WaypointAttribute.Distance, session.Route.FirstPL).Value;
for (var i = 0; i < m; i++)
{
var longLat = session.Route.GetLocationFromParameterizedLocation(session.Handles[i].ParameterizedLocation);
var p = longLat.Project(averageProjectionOrigin); // projected point on earth (metres)
var q = session.Handles[i].Location; // point on map image (pixels)
var endDistance = (i != m - 1)
? (session.Route.GetAttributeFromParameterizedLocation(WaypointAttribute.Distance, session.Handles[i].ParameterizedLocation).Value +
session.Route.GetAttributeFromParameterizedLocation(WaypointAttribute.Distance, session.Handles[i + 1].ParameterizedLocation).Value) / 2
: session.Route.GetAttributeFromParameterizedLocation(WaypointAttribute.Distance, session.Route.LastPL).Value;
var w = endDistance - startDistance; // weight
startDistance = endDistance;
XtX.SetElement(0, 0, XtX.GetElement(0, 0) + w * (p.X * p.X + p.Y * p.Y));
XtX.SetElement(0, 2, XtX.GetElement(0, 2) + w * p.X);
XtX.SetElement(0, 3, XtX.GetElement(0, 3) - w * p.Y);
XtX.SetElement(1, 1, XtX.GetElement(1, 1) + w * (p.X * p.X + p.Y * p.Y));
XtX.SetElement(1, 2, XtX.GetElement(1, 2) + w * p.Y);
XtX.SetElement(1, 3, XtX.GetElement(1, 3) + w * p.X);
XtX.SetElement(2, 0, XtX.GetElement(2, 0) + w * p.X);
XtX.SetElement(2, 1, XtX.GetElement(2, 1) + w * p.Y);
XtX.SetElement(2, 2, XtX.GetElement(2, 2) + w);
XtX.SetElement(3, 0, XtX.GetElement(3, 0) - w * p.Y);
XtX.SetElement(3, 1, XtX.GetElement(3, 1) + w * p.X);
XtX.SetElement(3, 3, XtX.GetElement(3, 3) + w);
Xty.SetElement(0, 0, Xty.GetElement(0, 0) + w * (q.X * p.X - q.Y * p.Y));
Xty.SetElement(1, 0, Xty.GetElement(1, 0) + w * (q.X * p.Y + q.Y * p.X));
Xty.SetElement(2, 0, Xty.GetElement(2, 0) + w * q.X);
Xty.SetElement(3, 0, Xty.GetElement(3, 0) + w * q.Y);
}
}
var T = new GeneralMatrix(3, 3);
if (numberOfUnknowns == 0)
{
T = this[0].InitialTransformationMatrix;
}
else if (numberOfUnknowns == 1)
{
T = this[0].Handles[0].TransformationMatrix;
}
else
{
var B = XtX.QRD().Solve(Xty);
T.SetElement(0, 0, B.GetElement(0, 0));
T.SetElement(0, 1, B.GetElement(1, 0));
T.SetElement(0, 2, B.GetElement(2, 0));
T.SetElement(1, 0, B.GetElement(1, 0));
T.SetElement(1, 1, -B.GetElement(0, 0));
T.SetElement(1, 2, B.GetElement(3, 0));
T.SetElement(2, 0, 0);
T.SetElement(2, 1, 0);
T.SetElement(2, 2, 1);
}
return(new Transformation(T, averageProjectionOrigin));
}
/// <summary>
/// ֱ���������
/// </summary>
/// <param name="st7"></param>
public void CalculateTrans7Param2(List<Coords7ST> st7)
{
double[][] A = new double[0][];
double[][] B = new double[0][];
InitMatrixAB(ref A, ref B, st7);
GeneralMatrix matrixA = new GeneralMatrix(A);
GeneralMatrix matrixB = new GeneralMatrix(B);
GeneralMatrix matrixParam = matrixA.Inverse() * matrixB;
this.Set4Param(matrixParam.GetElement(0, 0), matrixParam.GetElement(1, 0), matrixParam.GetElement(2, 0), matrixParam.GetElement(6, 0));
this.SetRotationParam(matrixParam.GetElement(3, 0), matrixParam.GetElement(4, 0), matrixParam.GetElement(5, 0));
}
