public virtual void Tan(float[] value, ref float[] returnValue) { Single.Vector input = new Single.DenseVector(value); Single.Vector output = new Single.DenseVector(returnValue); output = (Single.DenseVector)Single.Vector.Tan(input); returnValue = output.ToArray(); }
public virtual void Tan(float value, ref float returnValue) { Single.Vector input = new Single.DenseVector(new float[] { value }); Single.Vector output = new Single.DenseVector(new float[] { returnValue }); output = (Single.DenseVector)Single.Vector.Tan(input); returnValue = output[0]; }
public void HeapSortWithDecreasingDoubleArray() { var sortedIndices = new int[10]; var values = new DenseVector(10); values[0] = 9; values[1] = 8; values[2] = 7; values[3] = 6; values[4] = 5; values[5] = 4; values[6] = 3; values[7] = 2; values[8] = 1; values[9] = 0; for (var i = 0; i < sortedIndices.Length; i++) { sortedIndices[i] = i; } ILUTPElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); for (var i = 0; i < sortedIndices.Length; i++) { Assert.AreEqual(i, sortedIndices[i], "#01-" + i); } }
public void SolveWideMatrixThrowsArgumentException() { var matrix = new SparseMatrix(2, 3); var input = new DenseVector(2); var solver = new MlkBiCgStab(); Assert.That(() => matrix.SolveIterative(input, solver), Throws.ArgumentException); }
public void SolveLongMatrixThrowsArgumentException() { var matrix = new SparseMatrix(3, 2); var input = new DenseVector(3); var solver = new GpBiCg(); Assert.That(() => matrix.SolveIterative(input, solver), Throws.ArgumentException); }
public void SolveWideMatrixThrowsArgumentException() { var matrix = new SparseMatrix(2, 3); var input = new DenseVector(2); var solver = new TFQMR(); Assert.Throws<ArgumentException>(() => matrix.SolveIterative(input, solver)); }
public void SolveLongMatrixThrowsArgumentException() { var matrix = new SparseMatrix(3, 2); var input = new DenseVector(3); var solver = new MlkBiCgStab(); Assert.Throws<ArgumentException>(() => matrix.SolveIterative(input, solver)); }
private float ComputeMecanumDriveMotorSpeed(DenseVector desiredMovement, VectorComponent wheelForceVectorInput) { var wheelForceVector = new DenseVector(new[] { wheelForceVectorInput.X, wheelForceVectorInput.Y }); var wheelForceVectorUnit = wheelForceVector.Normalize(2); var scale = wheelForceVectorUnit.DotProduct(desiredMovement); // Console.WriteLine(wheelForceVector + " " + wheelForceVectorUnit + " " + desiredMovement + " " + scale); return scale; }
public void ApproximateWithNonInitializedPreconditionerThrowsArgumentException() { const int Size = 10; var vector = CreateStandardBcVector(Size); var preconditioner = CreatePreconditioner(); var result = new DenseVector(vector.Count); Assert.Throws<ArgumentException>(() => preconditioner.Approximate(vector, result)); }
/// <summary> /// Create standard vector. /// </summary> /// <param name="size">Size of the vector.</param> /// <returns>New vector.</returns> protected DenseVector CreateStandardBcVector(int size) { var vector = new DenseVector(size); for (var i = 0; i < size; i++) { vector[i] = i + 1; } return vector; }
/// <summary> /// Creates a new instance of the Vector class. /// </summary> /// <param name="data">The array to create this vector from.</param> /// <returns>The new <c>Vector</c>.</returns> protected override Vector<float> CreateVector(IList<float> data) { var vector = new DenseVector(data.Count); for (var index = 0; index < data.Count; index++) { vector[index] = data[index]; } return vector; }
// generating random vector public static Vector <float> GenerateRandomVector(int rows, params int[] parameters) { if (parameters.Length < 1) { throw new Exception("Pass no parameters"); // check if at least 1 parameter has been passed } meanDistr = new float[] { 0 }; // meanValues is zero sigmaDistr = new float[] { (float)Math.Sqrt(1.0 / 1) }; // sum of sigmas CreateDistribution(parameters); // generate distirbiution return(DenseVector.CreateRandom(rows, continuousDistribution)); // create a matrix from continous distribtion; }
public void DetermineStatus() { var criterion = new FailureStopCriterion<float>(); Assert.IsNotNull(criterion, "There should be a criterion"); var solution = new DenseVector(new[] { 3.0f, 2.0f, 1.0f }); var source = new DenseVector(new[] { 1001.0f, 0.0f, 2003.0f }); var residual = new DenseVector(new[] { 1.0f, 2.0f, 3.0f }); var status = criterion.DetermineStatus(5, solution, source, residual); Assert.AreEqual(IterationStatus.Continue, status, "Should be running"); }
public HolonomicDriveValues MecanumDrive(HolonomicDriveTrain driveTrain, float x, float y, bool inputsSquared = false) { x = InputUtilities.TransformWithWarning(x, square: inputsSquared); y = InputUtilities.TransformWithWarning(y, square: inputsSquared); var desiredMovement = new DenseVector(new [] { x, y }); // var desiredMovement = new DenseVector(new [] { 1f, 0f }); HolonomicDriveValues result = new HolonomicDriveValues(); result.FrontLeft = ComputeMecanumDriveMotorSpeed(desiredMovement, driveTrain.FrontLeft.GetComponent<VectorComponent>(DeviceComponentType.DriveWheelForceVector)); result.FrontRight = ComputeMecanumDriveMotorSpeed(desiredMovement, driveTrain.FrontRight.GetComponent<VectorComponent>(DeviceComponentType.DriveWheelForceVector)); result.RearLeft = ComputeMecanumDriveMotorSpeed(desiredMovement, driveTrain.RearLeft.GetComponent<VectorComponent>(DeviceComponentType.DriveWheelForceVector)); result.RearRight = ComputeMecanumDriveMotorSpeed(desiredMovement, driveTrain.RearRight.GetComponent<VectorComponent>(DeviceComponentType.DriveWheelForceVector)); return result; }
public void CanCreateDenseVectorFromArray() { var data = new float[Data.Length]; Array.Copy(Data, data, Data.Length); var vector = new DenseVector(data); for (var i = 0; i < data.Length; i++) { Assert.AreEqual(data[i], vector[i]); } vector[0] = 100.0f; Assert.AreEqual(100.0f, data[0]); }
/// <summary> /// Check the result. /// </summary> /// <param name="preconditioner">Specific preconditioner.</param> /// <param name="matrix">Source matrix.</param> /// <param name="vector">Initial vector.</param> /// <param name="result">Result vector.</param> protected override void CheckResult(IPreconditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result) { Assert.AreEqual(typeof (DiagonalPreconditioner), preconditioner.GetType(), "#01"); // Compute M * result = product // compare vector and product. Should be equal var product = new DenseVector(result.Count); matrix.Multiply(result, product); for (var i = 0; i < product.Count; i++) { Assert.IsTrue(((double) vector[i]).AlmostEqualNumbersBetween(product[i], -Epsilon.Magnitude()), "#02-" + i); } }
public void ApproximateReturningOldVector() { const int Size = 10; var newMatrix = CreateUnitMatrix(Size); var vector = CreateStandardBcVector(Size); var preconditioner = CreatePreconditioner(); preconditioner.Initialize(newMatrix); var result = new DenseVector(vector.Count); preconditioner.Approximate(vector, result); CheckResult(preconditioner, newMatrix, vector, result); }
public void CanMultiplyWithVector() { var matrix = TestMatrices["Singular3x3"]; var x = new DenseVector(new[] { 1.0f, 2.0f, 3.0f }); var y = matrix * x; Assert.AreEqual(matrix.RowCount, y.Count); for (var i = 0; i < matrix.RowCount; i++) { var ar = matrix.Row(i); var dot = ar * x; Assert.AreEqual(dot, y[i]); } }
/// <summary> /// Outer product of two vectors /// </summary> /// <param name="u">First vector</param> /// <param name="v">Second vector</param> /// <returns>Matrix M[i,j] = u[i]*v[j] </returns> /// <exception cref="ArgumentNullException">If the u vector is <see langword="null" />.</exception> /// <exception cref="ArgumentNullException">If the v vector is <see langword="null" />.</exception> public static DenseMatrix OuterProduct(DenseVector u, DenseVector v) { if (u == null) { throw new ArgumentNullException("u"); } if (v == null) { throw new ArgumentNullException("v"); } var matrix = new DenseMatrix(u.Count, v.Count); CommonParallel.For( 0, u.Count, i => { for (var j = 0; j < v.Count; j++) { matrix.At(i, j, u._values[i] * v._values[j]); } }); return matrix; }
/// <summary> /// Creates a vector containing specified elements. /// </summary> /// <param name="index">The first element to begin copying from.</param> /// <param name="length">The number of elements to copy.</param> /// <returns>A vector containing a copy of the specified elements.</returns> /// <exception cref="ArgumentOutOfRangeException"><list><item>If <paramref name="index"/> is not positive or /// greater than or equal to the size of the vector.</item> /// <item>If <paramref name="index"/> + <paramref name="length"/> is greater than or equal to the size of the vector.</item> /// </list></exception> /// <exception cref="ArgumentException">If <paramref name="length"/> is not positive.</exception> public override Vector<float> SubVector(int index, int length) { if (index < 0 || index >= _length) { throw new ArgumentOutOfRangeException("index"); } if (length <= 0) { throw new ArgumentOutOfRangeException("length"); } if (index + length > _length) { throw new ArgumentOutOfRangeException("length"); } var result = new DenseVector(length); CommonParallel.For( index, index + length, i => result._values[i - index] = _values[i]); return result; }
/// <summary> /// Returns a negated vector. /// </summary> /// <returns>The negated vector.</returns> /// <remarks>Added as an alternative to the unary negation operator.</remarks> public override Vector<float> Negate() { var result = new DenseVector(_length); CommonParallel.For( 0, _values.Length, index => result[index] = -_values[index]); return result; }
/// <summary> /// Converts the string representation of a real dense vector to float-precision dense vector equivalent. /// A return value indicates whether the conversion succeeded or failed. /// </summary> /// <param name="value"> /// A string containing a real vector to convert. /// </param> /// <param name="formatProvider"> /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information about value. /// </param> /// <param name="result"> /// The parsed value. /// </param> /// <returns> /// If the conversion succeeds, the result will contain a complex number equivalent to value. /// Otherwise the result will be <c>null</c>. /// </returns> public static bool TryParse(string value, IFormatProvider formatProvider, out DenseVector result) { bool ret; try { result = Parse(value, formatProvider); ret = true; } catch (ArgumentNullException) { result = null; ret = false; } catch (FormatException) { result = null; ret = false; } return ret; }
public HalForce6AxisVector(MathNet.Numerics.LinearAlgebra.Single.DenseVector vec) : base(vec.ToArray()) { }
public void ResetCalculationState() { var criterion = new ResidualStopCriterion<float>(1e-3f, 10); var solution = new DenseVector(new[] { 0.001f, 0.001f, 0.002f }); var source = new DenseVector(new[] { 0.001f, 0.001f, 0.002f }); var residual = new DenseVector(new[] { 1.000f, 1.000f, 2.001f }); var status = criterion.DetermineStatus(5, solution, source, residual); Assert.AreEqual(IterationStatus.Continue, status, "Should be running"); criterion.Reset(); Assert.AreEqual(IterationStatus.Continue, criterion.Status, "Should not have started"); }
public void DetermineStatusWithConvergenceAtFirstIteration() { var criterion = new ResidualStopCriterion<float>(1e-6); var solution = new DenseVector(new[] { 1.0f, 1.0f, 1.0f }); var source = new DenseVector(new[] { 1.0f, 1.0f, 1.0f }); var residual = new DenseVector(new[] { 0.0f, 0.0f, 0.0f }); var status = criterion.DetermineStatus(0, solution, source, residual); Assert.AreEqual(IterationStatus.Converged, status, "Should be done"); }
public void ApproximateWithVectorWithIncorrectLengthThrowsArgumentException() { const int Size = 10; var newMatrix = CreateUnitMatrix(Size); var vector = CreateStandardBcVector(Size); var preconditioner = CreatePreconditioner(); preconditioner.Initialize(newMatrix); var result = new DenseVector(vector.Count + 10); Assert.That(() => preconditioner.Approximate(vector, result), Throws.ArgumentException); }
public void DetermineStatusWithResidualNaN() { var criterium = new ResidualStopCriterium(1e-3f, 10); Assert.IsNotNull(criterium, "There should be a criterium"); var solution = new DenseVector(new[] {1.0f, 1.0f, 2.0f}); var source = new DenseVector(new[] {1.0f, 1.0f, 2.0f}); var residual = new DenseVector(new[] {1000.0f, float.NaN, 2001.0f}); var status = criterium.DetermineStatus(5, solution, source, residual); Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged"); }
public virtual float Dot(float[] a, float[] b) { Single.DenseVector vector_a = new Single.DenseVector(a); return(vector_a.DotProduct(new Single.DenseVector(b))); }
/// <summary> /// Converts the string representation of a real dense vector to float-precision dense vector equivalent. /// A return value indicates whether the conversion succeeded or failed. /// </summary> /// <param name="value"> /// A string containing a real vector to convert. /// </param> /// <param name="result"> /// The parsed value. /// </param> /// <returns> /// If the conversion succeeds, the result will contain a complex number equivalent to value. /// Otherwise the result will be <c>null</c>. /// </returns> public static bool TryParse(string value, out DenseVector result) { return(TryParse(value, null, out result)); }
public virtual double Norm(float[] a, double p) { Single.DenseVector vector_a = new Single.DenseVector(a); return(vector_a.Norm(p)); }
/// <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(DenseVector, DenseVector)"/> public Matrix<float> OuterProduct(DenseVector v) { return OuterProduct(this, v); }
public void DetermineStatus() { var criterion = new ResidualStopCriterion<float>(1e-3f, 10); // the solution vector isn't actually being used so ... var solution = new DenseVector(new[] { float.NaN, float.NaN, float.NaN }); // Set the source values var source = new DenseVector(new[] { 1.000f, 1.000f, 2.001f }); // Set the residual values var residual = new DenseVector(new[] { 0.001f, 0.001f, 0.002f }); var status = criterion.DetermineStatus(5, solution, source, residual); Assert.AreEqual(IterationStatus.Continue, status, "Should still be running"); var status2 = criterion.DetermineStatus(16, solution, source, residual); Assert.AreEqual(IterationStatus.Converged, status2, "Should be done"); }
public static Vector <float> GenerateUnitVector(int rows) // generate unit vector { return(DenseVector.Create(rows, 1)); }
public void DetermineStatusWithSourceNaN() { var criterion = new ResidualStopCriterion<float>(1e-3f, 10); var solution = new DenseVector(new[] { 1.0f, 1.0f, 2.0f }); var source = new DenseVector(new[] { 1.0f, 1.0f, float.NaN }); var residual = new DenseVector(new[] { 1000.0f, 1000.0f, 2001.0f }); var status = criterion.DetermineStatus(5, solution, source, residual); Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged"); }
public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column) { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var matrixACopy = matrixA.Clone(); var factorSvd = matrixA.Svd(true); var vectorb = MatrixLoader.GenerateRandomDenseVector(row); var vectorbCopy = vectorb.Clone(); var resultx = new DenseVector(column); factorSvd.Solve(vectorb, resultx); var matrixBReconstruct = matrixA * resultx; // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { Assert.AreEqual(vectorb[i], matrixBReconstruct[i], 1e-4); } // Make sure A didn't change. for (var i = 0; i < matrixA.RowCount; i++) { for (var j = 0; j < matrixA.ColumnCount; j++) { Assert.AreEqual(matrixACopy[i, j], matrixA[i, j]); } } // Make sure b didn't change. for (var i = 0; i < vectorb.Count; i++) { Assert.AreEqual(vectorbCopy[i], vectorb[i]); } }
public void DetermineStatusWithSolutionNaN() { var criterion = new FailureStopCriterion<float>(); Assert.IsNotNull(criterion, "There should be a criterion"); var solution = new DenseVector(new[] { 1, 1, float.NaN }); var source = new DenseVector(new[] { 1001.0f, 0.0f, 2003.0f }); var residual = new DenseVector(new[] { 1000.0f, 1000.0f, 2001.0f }); var status = criterion.DetermineStatus(5, solution, source, residual); Assert.AreEqual(IterationStatus.Failure, status, "Should be failed"); }
/// <summary> /// Converts the string representation of a real dense vector to float-precision dense vector equivalent. /// A return value indicates whether the conversion succeeded or failed. /// </summary> /// <param name="value"> /// A string containing a real vector to convert. /// </param> /// <param name="result"> /// The parsed value. /// </param> /// <returns> /// If the conversion succeeds, the result will contain a complex number equivalent to value. /// Otherwise the result will be <c>null</c>. /// </returns> public static bool TryParse(string value, out DenseVector result) { return TryParse(value, null, out result); }
/// <summary> /// Multiplies this matrix with another matrix and places the results into the result matrix. /// </summary> /// <param name="other">The matrix to multiply with.</param> /// <param name="result">The result of the multiplication.</param> protected override void DoMultiply(Matrix<float> other, Matrix<float> result) { result.Clear(); var columnVector = new DenseVector(other.RowCount); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; for (var row = 0; row < RowCount; row++) { var startIndex = rowPointers[row]; var endIndex = rowPointers[row + 1]; if (startIndex == endIndex) { continue; } for (var column = 0; column < other.ColumnCount; column++) { // Multiply row of matrix A on column of matrix B other.Column(column, columnVector); var sum = 0f; for (var index = startIndex; index < endIndex; index++) { sum += values[index] * columnVector[columnIndices[index]]; } result.At(row, column, sum); } } }
/// <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(DenseVector, DenseVector)"/> public Matrix <float> OuterProduct(DenseVector v) { return(OuterProduct(this, v)); }