public static MathNet.Numerics.LinearAlgebra.Vector <float> AddSubVector(
this MathNet.Numerics.LinearAlgebra.Vector <float> vec,
MathNet.Numerics.LinearAlgebra.Vector <float> sub)
{
for (int i = 0; i < sub.Count; i++) // TODO: test performance
{
vec.At(i, vec.At(i) + sub.At(i));
}
return(vec);
}
public void Rescale()
{
Center();
Matrix <double> A = PositionMatrix();
Matrix <double> cov = 1.0f / ((float)A.RowCount) * A.Transpose() * A;
Evd <double> eigen = cov.Evd();
MathNet.Numerics.LinearAlgebra.Vector <System.Numerics.Complex> eigenvals = eigen.EigenValues;
double l1 = eigenvals[0].Real; //1 / Math.Sqrt(eigenvals[0].Real);
double l2 = eigenvals[1].Real; //1 / Math.Sqrt(eigenvals[1].Real);
double l3 = eigenvals[2].Real; // / Math.Sqrt(eigenvals[2].Real);
Debug.Log("l1: " + l1 + ", l2: " + l2 + ", l3: " + l3);
double vol = l1 * l2 * l3;
double max = eigenvals.AbsoluteMaximum().Real;
Debug.Log("max=" + max);
//double det = cov.Determinant();
A = A / Math.Sqrt(max) * 0.2;
Debug.Log(A);
//Debug.Log("determinant:");
for (int i = 0; i < A.RowCount; i++)
{
poses_[i].Translation = new Vector3((float)A[i, 0], (float)A[i, 1], (float)A[i, 2]);
}
/* Matrix<double> A = PositionMatrix();
* Matrix<double> cov = 1.0f / ((float)A.RowCount ) *A.Transpose() * A;
*
*
* Debug.Log(cov.ToString());
* Evd<double> eigen = cov.Evd();
* Matrix<double> m = eigen.EigenVectors;
* Matrix<double> points = m * A * m.Inverse();
*
* points = points * cov.Determinant() / 10;
* points = m * points * m.Inverse();
* for (int i = 0; i < points.RowCount; i++)
* {
* poses_[i].Translation =new Vector3((float)points[i, 0], (float)points[i, 1], (float)points[i, 2]);
* }*/
/*double det = cov.Determinant();
* cov_rotated = cov_rotated / det;
* Matrix<double> cov_recovered = m * cov_rotated * m.Inverse();*/
//Debug.Log(cov_recovered.ToString());
}
/// <summary>
/// Outer product of this and another vector.
/// </summary>
/// <param name="v">The vector to operate on.</param>
/// <returns>
/// Matrix M[i,j] = this[i] * v[j].
/// </returns>
/// <seealso cref="OuterProduct(Vector{T}, Vector{T})"/>
public Matrix <T> OuterProduct(Vector <T> v)
{
return(OuterProduct(this, v));
}
/// <summary> /// Adds another vector to this vector and stores the result into the result vector. /// </summary> /// <param name="other">The vector to add to this one.</param> /// <param name="result">The vector to store the result of the addition.</param> protected abstract void DoAdd(Vector <T> other, Vector <T> result);
/// <summary> /// Adds a scalar to each element of the vector and stores the result in the result vector. /// </summary> /// <param name="scalar">The scalar to add.</param> /// <param name="result">The vector to store the result of the addition.</param> protected abstract void DoAdd(T scalar, Vector <T> result);
/// <summary> /// Complex conjugates vector and save result to <paramref name="result"/> /// </summary> /// <param name="result">Target vector</param> protected abstract void DoConjugate(Vector <T> result);
/// <summary> /// Negates vector and save result to <paramref name="result"/> /// </summary> /// <param name="result">Target vector</param> protected abstract void DoNegate(Vector <T> result);
/// <summary> /// Computes the dot product between this vector and another vector. /// </summary> /// <param name="other">The other vector.</param> /// <returns>The sum of a[i]*b[i] for all i.</returns> protected abstract T DoDotProduct(Vector <T> other);
/// <summary> /// Pointwise multiplies this vector with another vector and stores the result into the result vector. /// </summary> /// <param name="other">The vector to pointwise multiply with this one.</param> /// <param name="result">The vector to store the result of the pointwise multiplication.</param> protected abstract void DoPointwiseMultiply(Vector <T> other, Vector <T> result);
/// <summary> /// Computes the modulus for the given dividend for each element of the vector. /// </summary> /// <param name="dividend">The scalar numerator to use.</param> /// <param name="result">A vector to store the results in.</param> protected abstract void DoModulusByThis(T dividend, Vector <T> result);
/// <summary> /// Computes the modulus for each element of the vector for the given divisor. /// </summary> /// <param name="divisor">The scalar denominator to use.</param> /// <param name="result">A vector to store the results in.</param> protected abstract void DoModulus(T divisor, Vector <T> result);
/// <summary> /// Divides a scalar by each element of the vector and stores the result in the result vector. /// </summary> /// <param name="dividend">The scalar numerator to use.</param> /// <param name="result">The vector to store the result of the division.</param> protected abstract void DoDivideByThis(T dividend, Vector <T> result);
/// <summary> /// Divides each element of the vector by a scalar and stores the result in the result vector. /// </summary> /// <param name="divisor">The scalar denominator to use.</param> /// <param name="result">The vector to store the result of the division.</param> protected abstract void DoDivide(T divisor, Vector <T> result);
/// <summary> /// Computes the dot product between the conjugate of this vector and another vector. /// </summary> /// <param name="other">The other vector.</param> /// <returns>The sum of conj(a[i])*b[i] for all i.</returns> protected abstract T DoConjugateDotProduct(Vector <T> other);
/// <summary> /// Subtracts a scalar from each element of the vector and stores the result in the result vector. /// </summary> /// <param name="scalar">The scalar to subtract.</param> /// <param name="result">The vector to store the result of the subtraction.</param> protected abstract void DoSubtract(T scalar, Vector <T> result);
/// <summary> /// Pointwise divide this vector with another vector and stores the result into the result vector. /// </summary> /// <param name="divisor">The pointwise denominator vector to use.</param> /// <param name="result">The result of the division.</param> protected abstract void DoPointwiseDivide(Vector <T> divisor, Vector <T> result);
/// <summary> /// Pointwise modulus this vector with another vector and stores the result into the result vector. /// </summary> /// <param name="divisor">The pointwise denominator vector to use.</param> /// <param name="result">The result of the modulus.</param> protected abstract void DoPointwiseModulus(Vector <T> divisor, Vector <T> result);
public double DistanceTo(MathNet.Numerics.LinearAlgebra.Vector x)
{
return(Math.Abs(_plane.SignedDistanceTo(x)));
}
/// <summary> /// Multiplies a scalar to each element of the vector and stores the result in the result vector. /// </summary> /// <param name="scalar">The scalar to multiply.</param> /// <param name="result">The vector to store the result of the multiplication.</param> protected abstract void DoMultiply(T scalar, Vector <T> result);