public void SolveWideMatrixThrowsArgumentException() { var matrix = new SparseMatrix(2, 3); var input = new DenseVector(2); var solver = new GpBiCg(); 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 TFQMR(); 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 BiCgStab(); Assert.Throws<ArgumentException>(() => matrix.SolveIterative(input, solver)); }
/// <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<Complex32> CreateVector(IList<Complex32> data) { var vector = new DenseVector(data.Count); for (var index = 0; index < data.Count; index++) { vector[index] = data[index]; } return vector; }
public void CanAddTwoDenseVectorsUsingOperator() { var vector = new DenseVector(Data); var other = new DenseVector(Data); var result = vector + other; CollectionAssert.AreEqual(Data, vector, "Making sure the original vector wasn't modified."); CollectionAssert.AreEqual(Data, other, "Making sure the original vector wasn't modified."); for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(Data[i]*2.0f, result[i]); } }
/// <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<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> 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(vector[i].Real.AlmostEqualNumbersBetween(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); Assert.IsTrue(vector[i].Imaginary.AlmostEqualNumbersBetween(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + 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 CanCreateDenseVectorFromArray() { var data = new Complex32[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] = new Complex32(10.0f, 1); Assert.AreEqual(new Complex32(10.0f, 1), data[0]); }
public void CanMultiplyWithVector() { var matrix = TestMatrices["Singular3x3"]; var x = new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1) }); 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> /// Converts the string representation of a complex dense vector to double-precision dense vector equivalent. /// A return value indicates whether the conversion succeeded or failed. /// </summary> /// <param name="value"> /// A string containing a complex 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; }
/// <summary> /// Converts the string representation of a complex dense vector to double-precision dense vector equivalent. /// A return value indicates whether the conversion succeeded or failed. /// </summary> /// <param name="value"> /// A string containing a complex 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> /// 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<Complex32> OuterProduct(DenseVector v) { return OuterProduct(this, v); }
/// <summary> /// Converts the string representation of a complex dense vector to double-precision dense vector equivalent. /// A return value indicates whether the conversion succeeded or failed. /// </summary> /// <param name="value"> /// A string containing a complex 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 void CanDivideDenseVectorByComplexUsingOperators() { var vector = new DenseVector(Data); vector = vector/new Complex32(2.0f, 1); for (var i = 0; i < Data.Length; i++) { AssertHelpers.AlmostEqualRelative(Data[i]/new Complex32(2.0f, 1), vector[i], 6); } vector = vector/1.0f; for (var i = 0; i < Data.Length; i++) { AssertHelpers.AlmostEqualRelative(Data[i]/new Complex32(2.0f, 1), vector[i], 6); } }
public void CanCreateDenseMatrix() { var vector = new DenseVector(3); var matrix = Matrix<Complex32>.Build.SameAs(vector, 2, 3); Assert.IsInstanceOf<DenseMatrix>(matrix); Assert.AreEqual(2, matrix.RowCount); Assert.AreEqual(3, matrix.ColumnCount); }
/// <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<Complex32> other, Matrix<Complex32> 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 = Complex32.Zero; for (var index = startIndex; index < endIndex; index++) { sum += values[index] * columnVector[columnIndices[index]]; } result.At(row, column, sum); } } }
public void DetermineStatus() { var criterium = new FailureStopCriterium<Complex32>(); Assert.IsNotNull(criterium, "There should be a criterium"); var solution = new DenseVector(new[] {new Complex32(3.0f, 0), new Complex32(2.0f, 0), new Complex32(1, 0)}); var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)}); var residual = new DenseVector(new[] {new Complex32(1.0f, 0), new Complex32(2.0f, 0), new Complex32(3, 0)}); var status = criterium.DetermineStatus(5, solution, source, residual); Assert.AreEqual(IterationStatus.Continue, status, "Should be running"); }
public void CanSolveForRandomVectorWhenResultVectorGiven(int order) { var matrixA = Matrix<Complex32>.Build.Random(order, order, 1); var matrixACopy = matrixA.Clone(); var factorLU = matrixA.LU(); var vectorb = Vector<Complex32>.Build.Random(order, 1); var vectorbCopy = vectorb.Clone(); var resultx = new DenseVector(order); factorLU.Solve(vectorb, resultx); Assert.AreEqual(vectorb.Count, resultx.Count); var matrixBReconstruct = matrixA * resultx; // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, 1e-3f); Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, 1e-3f); } // 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 criterium = new FailureStopCriterium<Complex32>(); Assert.IsNotNull(criterium, "There should be a criterium"); var solution = new DenseVector(new[] {new Complex32(1.0f, 0), new Complex32(1.0f, 0), new Complex32(float.NaN, 0)}); var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)}); var residual = new DenseVector(new[] {new Complex32(1000, 0), new Complex32(1000, 0), new Complex32(2001, 0)}); var status = criterium.DetermineStatus(5, solution, source, residual); Assert.AreEqual(IterationStatus.Failure, status, "Should be failed"); }
public void CanMultiplyWithVectorIntoResultWhenUpdatingInputArgument() { var matrix = TestMatrices["Singular3x3"]; var x = new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1) }); var y = x; matrix.Multiply(x, x); Assert.AreSame(y, x); y = new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1) }); for (var i = 0; i < matrix.RowCount; i++) { var ar = matrix.Row(i); var dot = ar * y; Assert.AreEqual(dot, x[i]); } }
public void SolveLongMatrixThrowsArgumentException() { var matrix = new SparseMatrix(3, 2); var input = new DenseVector(3); var solver = new TFQMR(); Assert.Throws<ArgumentException>(() => solver.Solve(matrix, input)); }
public void CanTransposeThisAndMultiplyWithVectorIntoResult() { var matrix = TestMatrices["Singular3x3"]; var x = new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1) }); var y = new DenseVector(3); matrix.TransposeThisAndMultiply(x, y); for (var j = 0; j < matrix.ColumnCount; j++) { var ar = matrix.Column(j); var dot = ar * x; AssertHelpers.AlmostEqual(dot, y[j], 6); } }
public void CanConvertDenseVectorToArray() { var vector = new DenseVector(Data); var array = (Complex32[]) vector; Assert.IsInstanceOf(typeof (Complex32[]), array); CollectionAssert.AreEqual(vector, array); }
public void CanTransposeThisAndMultiplyWithVectorIntoResultWhenUpdatingInputArgument() { var matrix = TestMatrices["Singular3x3"]; var x = new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1) }); var y = x; matrix.TransposeThisAndMultiply(x, x); Assert.AreSame(y, x); y = new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1) }); for (var j = 0; j < matrix.ColumnCount; j++) { var ar = matrix.Column(j); var dot = ar * y; AssertHelpers.AlmostEqual(dot, x[j], 6); } }
public void CanCreateDenseVectorFromAnotherDenseVector() { var vector = new DenseVector(Data); var other = DenseVector.OfVector(vector); Assert.AreNotSame(vector, other); for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(vector[i], other[i]); } }
public void MultiplyWithVectorIntoLargerResultThrowsArgumentException() { var matrix = TestMatrices["Singular3x3"]; var x = new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1) }); Vector<Complex32> y = new DenseVector(4); Assert.Throws<ArgumentException>(() => matrix.Multiply(x, y)); }
public void CanMultiplyDenseVectorByComplexUsingOperators() { var vector = new DenseVector(Data); vector = vector*new Complex32(2.0f, 1); for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]); } vector = vector*1.0f; for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]); } vector = new DenseVector(Data); vector = new Complex32(2.0f, 1)*vector; for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]); } vector = 1.0f*vector; for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[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; }
public void CanCallUnaryNegationOperatorOnDenseVector() { var vector = new DenseVector(Data); var other = -vector; for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(-Data[i], other[i]); } }
/// <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 <Complex32> OuterProduct(DenseVector v) { return(OuterProduct(this, v)); }