public static Tuple <double, double> LeastSquareLinearRegression(double[] xdata, double[] ydata)
{
// build matrices
var X = DenseMatrix.OfColumnVectors(
new[] { DenseVector.Create(xdata.Length, 1), new DenseVector(xdata) });
var y = new DenseVector(ydata);
// solve using QR
var p = X.QR().Solve(y);
return(new Tuple <double, double>(p[0], p[1]));
}
public void DetermineStatusWithNonMatchingSourceVectorThrowsArgumentException()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws <ArgumentException>(() => criterium.DetermineStatus(
1,
DenseVector.Create(3, i => 4),
DenseVector.Create(4, i => 4),
DenseVector.Create(3, i => 4)));
}
public IVector Rotate(int blockCount)
{
var vectorList = new List <IIndexableVector>();
var blockSize = Count / blockCount;
foreach (var item in Split(blockCount).Reverse())
{
vectorList.Add(item.Reverse().AsIndexable());
}
return(new CpuVector(DenseVector.Create(Count, i => vectorList[i / vectorList.Count][i % blockSize])));
}
public void DetermineStatusWithIllegalIterationNumberThrowsArgumentOutOfRangeException()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws <ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
-1,
DenseVector.Create(3, i => 4),
DenseVector.Create(3, i => 5),
DenseVector.Create(3, i => 6)));
}
public void DetermineStatus()
{
var criterium = new IterationCountStopCriterium <Complex>(10);
Assert.IsNotNull(criterium, "A criterium should have been created");
criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
}
public IVector ConvertToVector()
{
var vectorList = _data.Select(m => m.ConvertInPlaceToVector().AsIndexable()).ToArray();
var size = _rows * _columns;
var ret = DenseVector.Create(Depth * size, i => {
var offset = i / size;
var index = i % size;
return(vectorList[offset][index]);
});
return(new CpuVector(ret));
}
public void ResetCalculationState()
{
var criterium = new IterationCountStopCriterium <Complex>(10);
Assert.IsNotNull(criterium, "A criterium should have been created");
criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
criterium.ResetToPrecalculationState();
Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
}
public void DetermineStatusWithNullSolutionVectorThrowsArgumentNullException()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws <ArgumentNullException>(() => criterium.DetermineStatus(
1,
null,
DenseVector.Create(3, i => 5),
DenseVector.Create(3, i => 6)));
}
/// <param name="srcPoints">need 4 or more points before translate </param>
/// <param name="dstPoints">need 4 or more points after translate</param>
/// <exception cref="ArgumentException">srcPoints and dstPoints must require 4 or more points</exception>
/// <exception cref="ArgumentException">srcPoints and dstPoints must same num</exception>
/// <returns>Homography Matrix</returns>
public static SingleHomographyMatrix Find(IReadOnlyList <Point2 <float> > srcPoints, IReadOnlyList <Point2 <float> > dstPoints)
{
if (srcPoints.Count < 4 || dstPoints.Count < 4)
{
throw new ArgumentException("srcPoints and dstPoints must require 4 or more points");
}
if (srcPoints.Count != dstPoints.Count)
{
throw new ArgumentException("srcPoints and dstPoints must same num");
}
// q(dst vector) = A(nx8 coefficient matrix) * p(homography matrix parameter)
// p = A^-1 * q
int pointNum = srcPoints.Count;
var coefficientMatrix = DenseMatrix.Create(pointNum * 2, 8, 0);
for (int i = 0; i < pointNum; i++)
{
var src = srcPoints[i];
var dst = dstPoints[i];
SetCoefficientMatrixParametersForDstX(coefficientMatrix, src.X, src.Y, dst.X, 2 * i);
SetCoefficientMatrixParametersForDstY(coefficientMatrix, src.X, src.Y, dst.Y, 2 * i + 1);
}
var dstVec = DenseVector.Create(pointNum * 2, 0);
for (int i = 0; i < pointNum; i++)
{
dstVec[i * 2] = dstPoints[i].X;
dstVec[i * 2 + 1] = dstPoints[i].Y;
}
var inverseCoefficientMatrix = pointNum == 4 ? coefficientMatrix.Inverse() : coefficientMatrix.PseudoInverse();
var parameterVec = inverseCoefficientMatrix * dstVec;
var elements = new float[9];
elements[0] = parameterVec[0];
elements[1] = parameterVec[1];
elements[2] = parameterVec[2];
elements[3] = parameterVec[3];
elements[4] = parameterVec[4];
elements[5] = parameterVec[5];
elements[6] = parameterVec[6];
elements[7] = parameterVec[7];
elements[8] = 1;
return(new SingleHomographyMatrix(elements));
}
/// <summary>
/// Procustes statistics which gives a (di)similiarity measure of two set of points, by removing translation, rotation and dilation(stretching) degrees of freedom.
/// Zero as result means the two sets of points are basically the same after translation, rotation and dilation with the corresponding matrices.
/// Reference: Modern Multidimensional Scaling, Theory and Applications, page 436, Procrustes Analysis
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <returns></returns>
public static Tuple <String, double> ProcrustesStatistics(List <Point> A, List <Point> B)
{
int n = A.Count;
//make A to be unitlength
double minX = A.Min(p => p.X);
double maxX = A.Max(p => p.X);
double minY = A.Min(p => p.Y);
double maxY = A.Max(p => p.Y);
double deltaX = maxX - minX;
double deltaY = maxY - minY;
double scale = Math.Max(deltaX, deltaY);
A = A.Select(p => new Point(p.X / scale, p.Y / scale)).ToList();
var centerA = new Point(A.Average(a => a.X), A.Average(a => a.Y));
var centerB = new Point(B.Average(b => b.X), B.Average(b => b.Y));
Matrix X = DenseMatrix.Create(n, 2, (i, j) => j == 0 ? A[i].X:A[i].Y);
Matrix Y = DenseMatrix.Create(n, 2, (i, j) => j == 0 ? B[i].X:B[i].Y);
Matrix Xc = DenseMatrix.Create(n, 2, (i, j) => j == 0 ? A[i].X - centerA.X : A[i].Y - centerA.Y);
Matrix Yc = DenseMatrix.Create(n, 2, (i, j) => j == 0 ? B[i].X - centerB.X : B[i].Y - centerB.Y);
//Reference: Modern Multidimensional Scaling, Theory and Applications, page 436, Procrustes Analysis
DenseMatrix C = (DenseMatrix)(Xc.Transpose() * Y);
Svd svd = new DenseSvd(C, true);
//rotation
Matrix <double> T = (svd.VT().Transpose()) * (svd.U().Transpose());
//dilation
double s = ((C * T).Trace()) / ((Yc.Transpose() * Y).Trace());
//column Vector with n times 1
Vector <double> vector1 = DenseVector.Create(n, i => 1);
//translation vector
Vector <double> t = (1.0 / n) * (X - s * Y * T).Transpose() * vector1;
Matrix translationMatrix = DenseMatrix.Create(n, 2, (i, j) => t.At(j));
Matrix <double> YPrime = s * Y * T + translationMatrix;
Matrix <double> delta = X - YPrime;
double rSquare = 0;
for (int i = 0; i < n; i++)
{
rSquare += delta.Row(i) * delta.Row(i);
}
return(Tuple.Create("ProcrustesStatistics", Math.Sqrt(rSquare)));
}
/// <summary>
/// Computes mean of every column.
/// </summary>
/// <param name="matrix">Matrix to compute means of columns.</param>
/// <returns>Vector where every element is a mean of corresponding column in the source matrix.</returns>
public static Vector MeanOfEveryColumn(this Matrix <double> matrix)
{
Vector result = DenseVector.Create(matrix.ColumnCount, i => 0.0);
foreach (var row in matrix.RowEnumerator())
{
result.Add(row.Item2, result);
}
result.Divide(matrix.RowCount, result);
return(result);
}
public void ResetCalculationState()
{
var criterium = new IterationCountStopCriterium <double>(10);
Assert.IsNotNull(criterium, "A criterium should have been created");
var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
Assert.AreEqual(IterationStatus.Running, status, "Should be running");
criterium.ResetToPrecalculationState();
Assert.AreEqual(IterationStatus.Indetermined, criterium.Status, "Should not have started");
}
private double CreateC(Matrix <double> leftMatrix)
{
var c = DenseVector.Create(leftMatrix.RowCount, 0);
for (var rowIndex = 0; rowIndex < leftMatrix.RowCount; rowIndex++)
{
var row = leftMatrix.Row(rowIndex).Map(Math.Abs);
var sumWithoutDiagonal = row.Where((it, index) => index != rowIndex).Sum();
c[rowIndex] = sumWithoutDiagonal / row[rowIndex];
}
return(c.Max());
}
private static Vector <double> DistributionToVector(IDictionary <TracerFormula, double> distribution, IDictionary <TracerFormula, int> indexes)
{
var result = DenseVector.Create(indexes.Count, double.NaN);
foreach (var entry in distribution)
{
int index;
if (indexes.TryGetValue(entry.Key, out index))
{
result[indexes[entry.Key]] = entry.Value;
}
}
return(result);
}
public void DetermineStatus()
{
var criterium = new IterationCountStopCriterium <double>(10);
Assert.IsNotNull(criterium, "A criterium should have been created");
var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
Assert.AreEqual(IterationStatus.Running, status, "Should be running");
var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, status2, "Should be finished");
}
static public Vector <double> RowAbsoluteSums(Matrix <double> matrix)
{
Vector <double> vector = DenseVector.Create(matrix.RowCount, 0);
for (int line = 0; line < matrix.RowCount; line++)
{
double sum_value = 0;
for (int col = 0; col < matrix.ColumnCount; col++)
{
sum_value += Math.Abs(matrix[line, col]);
}
vector[line] = sum_value;
}
return(vector);
}
private void ResetState()
{
// Estimate d_-1 using euler time formula. F=ma => a = F/m
var test = ComputeGlobalConsistentMassMatrix();
ApplyConstraints(test);
var startupAcceleration = test.Solve(ComputeForceVector());
nodeDisplacementOld = startupAcceleration * (Time.fixedDeltaTime * Time.fixedDeltaTime * 0.5f);
ApplyConstraints(nodeDisplacementOld);
nodeDisplacement = DenseVector.Create(Nodes.Count * 2, 0.0f);
nodeSpeed = DenseVector.Create(Nodes.Count * 2, 0.0f);
nodeAcceleration = DenseVector.Create(Nodes.Count * 2, 0.0f);
}
private Vector <float> ComputeGlobalVector(Func <TElementType, IList <Node>, Vector <float> > getElementVectorFunc)
{
Vector <float> vector = DenseVector.Create(Nodes.Count * 2, 0.0f);
foreach (var e in Elements)
{
var elementVector = getElementVectorFunc(e, Nodes);
for (int r = 0; r < NodesPerElement * 2; ++r)
{
int globalR = e.LocalComponentIndexToGlobal(r);
vector[globalR] += elementVector[r];
}
}
return(vector);
}
private Vector <float> ComputeForceVector()
{
Vector <float> forceVector = DenseVector.Create(Nodes.Count * 2, 0.0f);
foreach (var f in Forces)
{
forceVector[f.NodeIndex * 2] += f.Vector.x;
forceVector[f.NodeIndex * 2 + 1] += f.Vector.y;
}
var scaledGravity = Physics2D.gravity * GravityScale;
ApplyGravityToForceVector(forceVector, scaledGravity);
return(forceVector);
}
public void TestWeightedClassificationToy()
{
foreach (var name in CLF_TREES)
{
var clf = CreateClassifier <double>(name, random: new Random(0));
clf.Fit(X, y, sampleWeight: DenseVector.Create(X.GetLength(0), i => 1.0).ToArray());
AssertExt.ArrayEqual(clf.Predict(T), trueResult,
"Failed with {0}".Frmt(name));
clf.Fit(X, y, sampleWeight: DenseVector.Create(X.GetLength(0), i => 0.5).ToArray());
AssertExt.ArrayEqual(clf.Predict(T), trueResult,
"Failed with {0}".Frmt(name));
}
}
static void LoadSin(out HashSet <TrainingData> data, int n)
{
data = new HashSet <TrainingData>();
ContinuousUniform rand = new ContinuousUniform(0, Math.PI);
for (var i = 0; i < n; i++)
{
double x = rand.Sample();
TrainingData td = new TrainingData(1, 1);
double scale = Math.PI;
td.Data[0] = x / scale;
td.Response = DenseVector.Create(1, Math.Sin(x));
data.Add(td);
}
}
//Generates the pagerank of the page, returned as a vector, which will be iterated on n times, parsed to the function.
public DenseVector GeneratePageRank(int n)
{
DenseVector resultVector = DenseVector.Create(nrOfPages, 0.0);
resultVector[0] = 1.0;
var pageRank = ((1 - randomProbability) * TransitionProbabilityMatrix) + (randomProbability * TransitionRandomMatrix);
//Console.WriteLine(TransitionProbabilityMatrix.Column(30));
//Console.WriteLine(TransitionRandomMatrix.Column(30));
//Console.WriteLine(pageRank.Column(30));
for (int i = 0; i < n; i++)
{
resultVector = (DenseVector)(resultVector * pageRank);
}
return(resultVector);
}
public Tuple <Matrix <float>, Vector <float> > BuildData(List <TrainingInstance> trainingInstances)
{
IState[] states = trainingInstances.Select(x => x.State).ToArray();
double[] pathCosts = trainingInstances.Select(x => x.Response).ToArray();
Matrix <float> trainingData = DenseMatrix.Create(states.Length, numInputs, 0);
for (int r = 0; r < trainingData.RowCount; r++)
{
IState state = states[r];
byte[] stateArr = state.Arr;
int count = 0;
for (byte i = 0; i < stateArr.Length; i++)
{
int index = Array.IndexOf(stateArr, i);
var coord = SlidingPuzzle.IndexToCoord(index);
trainingData[r, count + coord.Item1 - 1] = 1;
trainingData[r, count + dim + coord.Item2 - 1] = 1;
count += dim + dim;
}
}
Vector <float> response = DenseVector.Create(pathCosts.Length, 0);
for (int i = 0; i < pathCosts.Length; i++)
{
double y = pathCosts[i];
if (responseFunc != null)
{
y = responseFunc(y);
}
response[i] = (float)y;
}
return(new Tuple <Matrix <float>, Vector <float> >(trainingData, response));
}
private void createClocalForElement(Element el)
{
Vector <double> funkcje_ksztaltu = DenseVector.Create(4, 0.0);
Matrix <double> tmp;
double[] matrix = new double[4];
double[] X = new double[4]
{
_mesh.Nodes[el.IDS[0]].X,
_mesh.Nodes[el.IDS[1]].X,
_mesh.Nodes[el.IDS[2]].X,
_mesh.Nodes[el.IDS[3]].X
};
double[] Y = new double[4]
{
_mesh.Nodes[el.IDS[0]].Y,
_mesh.Nodes[el.IDS[1]].Y,
_mesh.Nodes[el.IDS[2]].Y,
_mesh.Nodes[el.IDS[3]].Y
};
Matrix <double> c = DenseMatrix.Create(4, 4, 0);
foreach (PointF p in _points.Points)
{
tmp = DenseVector.OfArray(new double[]
{
0.25 * ((1 - p.X) * (1 - p.Y)), // N1 w punkcie p
0.25 * ((1 + p.X) * (1 - p.Y)), // N2 w punkcie p
0.25 * ((1 + p.X) * (1 + p.Y)), // N3 w punkcie P
0.25 * ((1 - p.X) * (1 + p.Y)) // N4 w punkcie p
}).ToRowMatrix();
// funkcje_ksztaltu.Add(tmp,funkcje_ksztaltu);
// sumujemy poszczególne funkcje kształtu we wszystkich punktach
Matrix <double> m = tmp.Transpose();
c = c.Add(m.Multiply(tmp));
}
//Matrix<double> m = funkcje_ksztaltu.ToRowMatrix();
c = c.Multiply(_jacobianMatrix.Determinant());
//Matrix<double> m1 = m.Transpose().Multiply(m);
el.C = c.Multiply(_simulationData.Density * _simulationData.Specific_Heat).ToArray();
//el.C = c.ToArray(); ;
}
public static DenseVector VectorOfVertexPositions(HalfEdgeMesh mesh)
{
int numVertices = mesh.Vertices.Length;
DenseVector vec = DenseVector.Create(3 * numVertices, 0);
for (int i = 0; i < numVertices; i++)
{
Vector3 pos = mesh.Vertices[i].position;
int vBase = 3 * i;
vec[vBase + 0] = pos.x;
vec[vBase + 1] = pos.y;
vec[vBase + 2] = pos.z;
}
return(vec);
}
public void DetermineStatusWithNullResidualVectorThrowsArgumentNullException()
{
var criteria = new List <IIterationStopCriterium <float> >
{
new FailureStopCriterium(),
new DivergenceStopCriterium(),
new IterationCountStopCriterium <float>(),
new ResidualStopCriterium()
};
var iterator = new Iterator(criteria);
Assert.Throws <ArgumentNullException>(() => iterator.DetermineStatus(
1,
DenseVector.Create(3, i => 4),
DenseVector.Create(3, i => 5),
null));
}
public IVector CosineDistance(IReadOnlyList <IVector> data, ref float[] dataNorm)
{
var norm = DotProduct(this);
if (dataNorm == null)
{
dataNorm = data.Select(d => d.DotProduct(d)).ToArray();
}
var ret = new float[data.Count];
for (var i = 0; i < data.Count; i++)
{
ret[i] = Convert.ToSingle(1d - DotProduct(data[i]) / Math.Sqrt(norm * dataNorm[i]));
}
return(new CpuVector(DenseVector.Create(data.Count, i => ret[i])));
}
public void TestAddDiagonalMatrix(int size)
{
var A = MatrixLoader.A(size);
int rows = A.RowCount;
int cols = A.ColumnCount;
var a = DenseVector.Create(rows, (i) => 1.0 + i);
var D = DiagonalMatrix.OfDiagonal(rows, cols, a);
var B = A.Add(D);
var C = A.Clone() as SparseMatrix;
C.FastAddDiagonalMatrix(Util.GetData(a), C);
Assert.IsTrue(MatrixComparer.Equals(B, C, EPS));
}
public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
{
var criteria = new List <IIterationStopCriterium <Complex32> >
{
new FailureStopCriterium(),
new DivergenceStopCriterium(),
new IterationCountStopCriterium <Complex32>(),
new ResidualStopCriterium()
};
var iterator = new Iterator <Complex32>(criteria);
Assert.Throws <ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
-1,
DenseVector.Create(3, i => 4),
DenseVector.Create(3, i => 5),
DenseVector.Create(3, i => 6)));
}
private void calculateProbDens()
{
if (dvData.Count == 0)
{
return;
}
if (binsCount == 0)
{
return;
}
double dataMaxValue = dvData.Values.Max();
double dataMinValue = dvData.Values.Min();
double binCentersStep = (dataMaxValue - dataMinValue) / (double)binsCount;
double currentBinCenter = dataMinValue + binCentersStep / 2.0d;
dvbinsCenters = DenseVector.Create(binsCount, i =>
{
return((double)i * binCentersStep + binCentersStep * 0.5d + dataMinValue);
});
dvProbDens = DenseVector.Create(binsCount, i =>
{
double binMin = dvbinsCenters[i] - binCentersStep * 0.5d;
double binMax = dvbinsCenters[i] + binCentersStep * 0.5d;
List <double> listCurrData = new List <double>();
if (i == binsCount - 1)
{
listCurrData = DataAnalysis.DataAnalysisStatic.DataListedWithCondition(dvData, (dVal => ((dVal >= binMin) && (dVal <= binMax))));
}
else
{
listCurrData = DataAnalysis.DataAnalysisStatic.DataListedWithCondition(dvData, (dVal => ((dVal >= binMin) && (dVal < binMax))));
}
if (listCurrData == null)
{
return(0.0d);
}
return((double)listCurrData.Count);
});
double sum = dvProbDens.Values.Sum();
dvProbDens = (DenseVector)dvProbDens.Divide(sum);
}
