/// <summary> /// Initializes a new instance of the <see cref="TestableComplexMatrixComplexMatrixMultiplication{TExpected}"/> class. /// </summary> /// <param name="expected">The expected result or exception.</param> /// <param name="left">The left operand.</param> /// <param name="right">The right operand.</param> public TestableComplexMatrixComplexMatrixMultiplication( TExpected expected, TestableComplexMatrix left, TestableComplexMatrix right) : base( expected, left, right, leftWritableRightWritableOps: new Func <ComplexMatrix, ComplexMatrix, ComplexMatrix>[2] { (l, r) => l * r, (l, r) => ComplexMatrix.Multiply(l, r) }, leftReadOnlyRightWritableOps: new Func <ReadOnlyComplexMatrix, ComplexMatrix, ComplexMatrix>[2] { (l, r) => l * r, (l, r) => ReadOnlyComplexMatrix.Multiply(l, r) }, leftWritableRightReadOnlyOps: new Func <ComplexMatrix, ReadOnlyComplexMatrix, ComplexMatrix>[2] { (l, r) => l * r, (l, r) => ReadOnlyComplexMatrix.Multiply(l, r) }, leftReadOnlyRightReadOnlyOps: new Func <ReadOnlyComplexMatrix, ReadOnlyComplexMatrix, ComplexMatrix>[2] { (l, r) => l * r, (l, r) => ReadOnlyComplexMatrix.Multiply(l, r) } ) { }
public void Main() { // Create a matrix. var data = new Complex[6] { new Complex(0, 0), new Complex(5, -5), new Complex(2, -2), new Complex(0, 0), new Complex(0, 0), new Complex(2, -2) }; var matrix = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor); Console.WriteLine("The data matrix:"); Console.WriteLine(matrix); // Find the linear indexes of nonzero entries in data. var indexes = matrix.FindNonzero(); Console.WriteLine(); Console.WriteLine("Linear indexes of nonzero entries in data:"); Console.WriteLine(indexes); // FindNonzero is available for read-only matrices: // find nonzero entries using a read-only wrapper of the data matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); indexes = readOnlyMatrix.FindNonzero(); Console.WriteLine(); Console.WriteLine("Using read-only data. Linear indexes of nonzero entries:"); Console.WriteLine(indexes); }
public void Main() { // Create a matrix. var data = new Complex[8] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7), new Complex(4, -4), new Complex(8, -8) }; var matrix = ComplexMatrix.Dense(4, 2, data, StorageOrder.RowMajor); Console.WriteLine("Initial data matrix:"); Console.WriteLine(matrix); // Get the vectorization of the data matrix. var vectorized = matrix.Vec(); Console.WriteLine(); Console.WriteLine("Vectorized data matrix:"); Console.WriteLine(vectorized); // Entries can also be vectorized using a read-only wrapper of the matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); Console.WriteLine(); Console.WriteLine("Vectorized read-only data matrix :"); Console.WriteLine(readOnlyMatrix.Vec()); }
public void Main() { // Create a matrix. var data = new Complex[6] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7) }; var matrix = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor); Console.WriteLine("The data matrix:"); Console.WriteLine(matrix); // Return its conjugate transpose. var transposedMatrix = matrix.ConjugateTranspose(); Console.WriteLine(); Console.WriteLine("Matrix conjugate transpose:"); Console.WriteLine(transposedMatrix); // Compute the conjugate transpose using a read-only wrapper // of the data matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); var transposedReadOnlyMatrix = readOnlyMatrix.ConjugateTranspose(); Console.WriteLine(); Console.WriteLine("Read only matrix transpose:"); Console.WriteLine(transposedReadOnlyMatrix); }
/// <summary> /// Initializes a new instance of the <see cref="TestableComplexMatrixDoubleMatrixElementWiseMultiplication{TExpected}"/> class. /// </summary> /// <param name="expected">The expected result or exception.</param> /// <param name="left">The left operand.</param> /// <param name="right">The right operand.</param> public TestableComplexMatrixDoubleMatrixElementWiseMultiplication( TExpected expected, TestableComplexMatrix left, TestableDoubleMatrix right) : base( expected, left, right, leftWritableRightWritableOps: new Func <ComplexMatrix, DoubleMatrix, ComplexMatrix>[1] { (l, r) => ComplexMatrix.ElementWiseMultiply(l, r) }, leftReadOnlyRightWritableOps: new Func <ReadOnlyComplexMatrix, DoubleMatrix, ComplexMatrix>[1] { (l, r) => ReadOnlyComplexMatrix.ElementWiseMultiply(l, r) }, leftWritableRightReadOnlyOps: new Func <ComplexMatrix, ReadOnlyDoubleMatrix, ComplexMatrix>[1] { (l, r) => ComplexMatrix.ElementWiseMultiply(l, r) }, leftReadOnlyRightReadOnlyOps: new Func <ReadOnlyComplexMatrix, ReadOnlyDoubleMatrix, ComplexMatrix>[1] { (l, r) => ReadOnlyComplexMatrix.ElementWiseMultiply(l, r) } ) { }
/// <summary> /// Initializes a new instance of the <see cref="TestableDoubleMatrixComplexMatrixAddition{TExpected}"/> class. /// </summary> /// <param name="expected">The expected result or exception.</param> /// <param name="left">The left operand.</param> /// <param name="right">The right operand.</param> public TestableDoubleMatrixComplexMatrixAddition( TExpected expected, TestableDoubleMatrix left, TestableComplexMatrix right) : base( expected, left, right, leftWritableRightWritableOps: new Func <DoubleMatrix, ComplexMatrix, ComplexMatrix>[2] { (l, r) => l + r, (l, r) => ComplexMatrix.Add(l, r) }, leftReadOnlyRightWritableOps: new Func <ReadOnlyDoubleMatrix, ComplexMatrix, ComplexMatrix>[2] { (l, r) => l + r, (l, r) => ComplexMatrix.Add(l, r) }, leftWritableRightReadOnlyOps: new Func <DoubleMatrix, ReadOnlyComplexMatrix, ComplexMatrix>[2] { (l, r) => l + r, (l, r) => ReadOnlyComplexMatrix.Add(l, r) }, leftReadOnlyRightReadOnlyOps: new Func <ReadOnlyDoubleMatrix, ReadOnlyComplexMatrix, ComplexMatrix>[2] { (l, r) => l + r, (l, r) => ReadOnlyComplexMatrix.Add(l, r) } ) { }
public void Main() { // Create a matrix. var data = new Complex[6] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7) }; var matrix = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor); Console.WriteLine("The data matrix:"); Console.WriteLine(matrix); // Return a matrix obtained by adding 1 to each entry // of the initial matrix. var plusOneMatrix = matrix.Apply((x) => x + 1); Console.WriteLine(); Console.WriteLine("Matrix obtained by adding 1 to each entry:"); Console.WriteLine(plusOneMatrix); // Add one using a read-only wrapper of the data matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); var plusOneReadOnlyMatrix = readOnlyMatrix.Apply((x) => x + 1); Console.WriteLine(); Console.WriteLine("Adding 1 to each entry of a read only matrix:"); Console.WriteLine(plusOneReadOnlyMatrix); }
/// <summary> /// Initializes a new instance of the <see cref="TestableComplexMatrixComplexMatrixDivision{TExpected}"/> class. /// </summary> /// <param name="expected">The expected result or exception.</param> /// <param name="left">The left operand.</param> /// <param name="right">The right operand.</param> public TestableComplexMatrixComplexMatrixDivision( TExpected expected, TestableComplexMatrix left, TestableComplexMatrix right) : base( expected, left, right, leftWritableRightWritableOps: new Func <ComplexMatrix, ComplexMatrix, ComplexMatrix>[2] { (l, r) => l / r, (l, r) => ComplexMatrix.Divide(l, r) }, leftReadOnlyRightWritableOps: new Func <ReadOnlyComplexMatrix, ComplexMatrix, ComplexMatrix>[2] { (l, r) => l / r, (l, r) => ReadOnlyComplexMatrix.Divide(l, r) }, leftWritableRightReadOnlyOps: new Func <ComplexMatrix, ReadOnlyComplexMatrix, ComplexMatrix>[2] { (l, r) => l / r, (l, r) => ReadOnlyComplexMatrix.Divide(l, r) }, leftReadOnlyRightReadOnlyOps: new Func <ReadOnlyComplexMatrix, ReadOnlyComplexMatrix, ComplexMatrix>[2] { (l, r) => l / r, (l, r) => ReadOnlyComplexMatrix.Divide(l, r) } ) { }
public void Main() { // Create a matrix. var data = new Complex[4] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6) }; var matrix = ComplexMatrix.Dense(2, 2, data, StorageOrder.RowMajor); Console.WriteLine("Initial data matrix:"); Console.WriteLine(matrix); // Get the linear indexes of elements on // the main diagonal. var mainDiagonalIndexes = IndexCollection.Sequence(0, 3, 3); // Get the vectorization of the matrix main diagonal. var mainDiagonal = matrix.Vec(mainDiagonalIndexes); Console.WriteLine(); Console.WriteLine("Vectorized main diagonal:"); Console.WriteLine(mainDiagonal); // Entries can also be vectorized using a read-only wrapper of the matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); Console.WriteLine(); Console.WriteLine("Vectorized main diagonal of a read-only data matrix:"); Console.WriteLine(readOnlyMatrix.Vec(mainDiagonalIndexes)); }
public void Main() { // Create a matrix. var data = new Complex[6] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(2, -2) }; var matrix = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor); Console.WriteLine("The data matrix:"); Console.WriteLine(matrix); // Set the value to search for. Complex value = new(2, -2); // Find entries equal to value (2, -2). var indexes = matrix.Find(value); Console.WriteLine(); Console.WriteLine("Linear indexes of entries equal to (2, -2) in data:"); Console.WriteLine(indexes); // Find is available for read-only matrices: // find entries equal to (2, -2) using a read-only wrapper of the data matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); indexes = readOnlyMatrix.Find(value); Console.WriteLine(); Console.WriteLine("Using read-only data. Linear indexes of entries equal to (2, -2):"); Console.WriteLine(indexes); }
public void Main() { // Create a matrix. var data = new Complex[8] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7), new Complex(4, -4), new Complex(8, -8) }; var matrix = ComplexMatrix.Dense(4, 2, data, StorageOrder.RowMajor); Console.WriteLine("Initial data matrix:"); Console.WriteLine(matrix); // Specify a linear index. int linearIndex = 3; Console.WriteLine(); Console.WriteLine("Linear index: {0}", linearIndex); // Set the corresponding entry. matrix[linearIndex] = new Complex(40, -40); Console.WriteLine(); Console.WriteLine("Updated data matrix:"); Console.WriteLine(matrix); // Entries can also be accessed using a read-only wrapper of the matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); Console.WriteLine(); Console.WriteLine("Updated matrix entry:"); Console.WriteLine(readOnlyMatrix[linearIndex]); }
/// <summary> /// Initializes a new instance of the <see cref="TestableComplexMatrixDoubleMatrixSubtraction{TExpected}"/> class. /// </summary> /// <param name="expected">The expected result or exception.</param> /// <param name="left">The left operand.</param> /// <param name="right">The right operand.</param> public TestableComplexMatrixDoubleMatrixSubtraction( TExpected expected, TestableComplexMatrix left, TestableDoubleMatrix right) : base( expected, left, right, leftWritableRightWritableOps: new Func <ComplexMatrix, DoubleMatrix, ComplexMatrix>[2] { (l, r) => l - r, (l, r) => ComplexMatrix.Subtract(l, r) }, leftReadOnlyRightWritableOps: new Func <ReadOnlyComplexMatrix, DoubleMatrix, ComplexMatrix>[2] { (l, r) => l - r, (l, r) => ReadOnlyComplexMatrix.Subtract(l, r) }, leftWritableRightReadOnlyOps: new Func <ComplexMatrix, ReadOnlyDoubleMatrix, ComplexMatrix>[2] { (l, r) => l - r, (l, r) => ComplexMatrix.Subtract(l, r) }, leftReadOnlyRightReadOnlyOps: new Func <ReadOnlyComplexMatrix, ReadOnlyDoubleMatrix, ComplexMatrix>[2] { (l, r) => l - r, (l, r) => ReadOnlyComplexMatrix.Subtract(l, r) } ) { }
/// <summary> /// Checks that the specified <see cref="ComplexMatrix"/> /// and <see cref="ReadOnlyComplexMatrix"/> instances are equal. /// </summary> /// <param name="expected">The expected matrix.</param> /// <param name="actual">The actual matrix.</param> /// <param name="delta">The required accuracy.</param> public static void AreEqual( ComplexMatrix expected, ReadOnlyComplexMatrix actual, double delta) { AreEqual(expected, (ComplexMatrix)actual, delta); }
public void Main() { // Create a matrix. var data = new Complex[8] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7), new Complex(4, -4), new Complex(8, -8) }; var matrix = ComplexMatrix.Dense(4, 2, data, StorageOrder.RowMajor); Console.WriteLine("Initial data matrix:"); Console.WriteLine(matrix); // Specify all row indexes. var rowIndexes = ":"; Console.WriteLine(); Console.WriteLine("Row indexes: from 0 to {0}", matrix.NumberOfRows - 1); // Specify all column indexes. var columnIndexes = ":"; Console.WriteLine(); Console.WriteLine("Column indexes: from 0 to {0}", matrix.NumberOfColumns - 1); // Specify the value matrix. var valueData = new Complex[8] { new Complex(10, -10), new Complex(50, -50), new Complex(20, -20), new Complex(60, -60), new Complex(30, -30), new Complex(70, -70), new Complex(40, -40), new Complex(80, -80) }; var value = ComplexMatrix.Dense(4, 2, valueData, StorageOrder.RowMajor); Console.WriteLine(); Console.WriteLine("Value matrix:"); Console.WriteLine(value); // Set the entries having the specified indexes to the value matrix. matrix[rowIndexes, columnIndexes] = value; Console.WriteLine(); Console.WriteLine("Updated data matrix:"); Console.WriteLine(matrix); // Entries can also be accessed using a read-only wrapper // of the matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); Console.WriteLine(); Console.WriteLine("Updated matrix entries:"); Console.WriteLine(readOnlyMatrix[rowIndexes, columnIndexes]); }
public void Main() { // Create the left operand. var data = new Complex[8] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7), new Complex(4, -4), new Complex(8, -8) }; var left = ComplexMatrix.Dense(4, 2, data, StorageOrder.RowMajor); Console.WriteLine("left ="); Console.WriteLine(left); // Create the right operand. data = new Complex[8] { new Complex(10, -1), new Complex(50, -5), new Complex(20, -2), new Complex(60, -6), new Complex(30, -3), new Complex(70, -7), new Complex(40, -4), new Complex(80, -8) }; var right = ComplexMatrix.Dense(4, 2, data, StorageOrder.RowMajor); Console.WriteLine("right ="); Console.WriteLine(right); // Subtract right from left. var result = left - right; Console.WriteLine(); Console.WriteLine("left - right ="); Console.WriteLine(result); // In .NET languages that do not support overloaded operators, // you can use the alternative methods named Subtract. result = ComplexMatrix.Subtract(left, right); Console.WriteLine(); Console.WriteLine("ComplexMatrix.Subtract(left, right) returns"); Console.WriteLine(); Console.WriteLine(result); // Both operators and alternative methods are overloaded to // support read-only matrix arguments. // Compute the subtraction using a read-only wrapper of left. ReadOnlyComplexMatrix readOnlyLeft = left.AsReadOnly(); result = readOnlyLeft - right; Console.WriteLine(); Console.WriteLine("readOnlyLeft - right ="); Console.WriteLine(result); }
public void Main() { // Create a matrix. var data = new Complex[8] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7), new Complex(4, -4), new Complex(8, -8) }; var matrix = ComplexMatrix.Dense(4, 2, data, StorageOrder.RowMajor); Console.WriteLine("Initial data matrix:"); Console.WriteLine(matrix); // Specify some row indexes. var rowIndexes = IndexCollection.Range(1, 3); Console.WriteLine(); Console.WriteLine("Row indexes: {0}", rowIndexes); // Specify a column index. int columnIndex = 0; Console.WriteLine(); Console.WriteLine("Column index: {0}", columnIndex); // Specify the value matrix. var valueData = new Complex[3] { new Complex(20, -20), new Complex(30, -30), new Complex(40, -40) }; var value = ComplexMatrix.Dense(3, 1, valueData, StorageOrder.RowMajor); Console.WriteLine(); Console.WriteLine("Value matrix:"); Console.WriteLine(value); // Set the entries having the specified indexes to the value matrix. matrix[rowIndexes, columnIndex] = value; Console.WriteLine(); Console.WriteLine("Updated data matrix:"); Console.WriteLine(matrix); // Entries can also be accessed using a read-only wrapper // of the matrix. ReadOnlyComplexMatrix readOnlyMatrix = matrix.AsReadOnly(); Console.WriteLine(); Console.WriteLine("Updated matrix entries:"); Console.WriteLine(readOnlyMatrix[rowIndexes, columnIndex]); }
public void Main() { // Create the left operand. var data = new Complex[6] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7) }; var left = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor); Console.WriteLine("left ="); Console.WriteLine(left); // Create the right operand. data = new Complex[4] { new Complex(10, -10), new Complex(50, -50), new Complex(20, -20), new Complex(60, -60) }; var right = ComplexMatrix.Dense(2, 2, data, StorageOrder.RowMajor); Console.WriteLine("right ="); Console.WriteLine(right); // Multiply left by right. var result = left * right; Console.WriteLine(); Console.WriteLine("left * right ="); Console.WriteLine(result); // In .NET languages that do not support overloaded operators, // you can use the alternative methods named Multiply. result = ComplexMatrix.Multiply(left, right); Console.WriteLine(); Console.WriteLine("ComplexMatrix.Multiply(left, right) returns"); Console.WriteLine(); Console.WriteLine(result); // Both operators and alternative methods are overloaded to // support read-only matrix arguments. // Compute the product using a read-only wrapper of left. ReadOnlyComplexMatrix readOnlyLeft = left.AsReadOnly(); result = readOnlyLeft * right; Console.WriteLine(); Console.WriteLine("readOnlyLeft * right ="); Console.WriteLine(result); }
///<inheritdoc cref="SingularValueDecomposition ///.GetSingularValues(DoubleMatrix)"/> public static DoubleMatrix GetSingularValues( ReadOnlyComplexMatrix matrix) { #region Input validation if (matrix is null) { throw new ArgumentNullException(nameof(matrix)); } #endregion return(GetSingularValues(matrix.matrix)); }
public void Main() { // Create the left operand. Complex left = new(7, -7); Console.WriteLine("left ="); Console.WriteLine(left); Console.WriteLine(); // Create the right operand. var data = new Complex[6] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7) }; var right = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor); Console.WriteLine("right ="); Console.WriteLine(right); // Compute the sum of left and right. var result = left + right; Console.WriteLine(); Console.WriteLine("left + right ="); Console.WriteLine(result); // In .NET languages that do not support overloaded operators, // you can use the alternative methods named Add. result = ComplexMatrix.Add(left, right); Console.WriteLine(); Console.WriteLine("ComplexMatrix.Add(left, right) returns"); Console.WriteLine(); Console.WriteLine(result); // Both operators and alternative methods are overloaded to // support read-only matrix arguments. // Compute the sum using a read-only wrapper of right. ReadOnlyComplexMatrix readOnlyRight = right.AsReadOnly(); result = left + readOnlyRight; Console.WriteLine(); Console.WriteLine("left + readOnlyRight ="); Console.WriteLine(result); }
/// <inheritdoc cref="SpectralDecomposition.GetEigenvalues(ComplexMatrix, bool)"/> public static DoubleMatrix GetEigenvalues( ReadOnlyComplexMatrix matrix, bool lowerTriangularPart) { #region Input validation if (matrix is null) { throw new ArgumentNullException(nameof(matrix)); } #endregion return(GetEigenvalues( matrix.matrix, lowerTriangularPart)); }
///<inheritdoc cref="SingularValueDecomposition.Decompose( ///ComplexMatrix, out ComplexMatrix, out ComplexMatrix)"/> public static DoubleMatrix Decompose( ReadOnlyComplexMatrix matrix, out ComplexMatrix leftSingularVectors, out ComplexMatrix conjugateTransposedRightSingularVectors) { #region Input validation if (matrix is null) { throw new ArgumentNullException(nameof(matrix)); } #endregion return(Decompose( matrix.matrix, out leftSingularVectors, out conjugateTransposedRightSingularVectors)); }
/// <summary> /// Initializes a new instance of the <see cref="TestableComplexMatrixNegation{TExpected}"/> class. /// </summary> /// <param name="expected">The expected result or exception.</param> /// <param name="operand">The operand.</param> public TestableComplexMatrixNegation( TExpected expected, TestableComplexMatrix operand) : base( expected, operand, operandWritableOps: new Func <ComplexMatrix, ComplexMatrix>[2] { (o) => - o, (o) => ComplexMatrix.Negate(o) }, operandReadOnlyOps: new Func <ReadOnlyComplexMatrix, ComplexMatrix>[2] { (o) => - o, (o) => ReadOnlyComplexMatrix.Negate(o) } ) { }
/// <inheritdoc cref="SpectralDecomposition.Decompose(ComplexMatrix, bool, out ComplexMatrix)"/> public static DoubleMatrix Decompose( ReadOnlyComplexMatrix matrix, bool lowerTriangularPart, out ComplexMatrix eigenvectors) { #region Input validation if (matrix is null) { throw new ArgumentNullException(nameof(matrix)); } #endregion return(Decompose( matrix.matrix, lowerTriangularPart, out eigenvectors)); }
public void Main() { // Create the left operand. var data = new Complex[6] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7) }; var left = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor); Console.WriteLine("left ="); Console.WriteLine(left); // Create the right operand. data = new Complex[6] { new Complex(-1, 1), new Complex(-5, 5), new Complex(-2, 2), new Complex(-6, 6), new Complex(-3, 3), new Complex(-7, 7) }; var right = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor); Console.WriteLine("right ="); Console.WriteLine(right); // Element wise multiply left by right. var result = ComplexMatrix.ElementWiseMultiply(left, right); Console.WriteLine(); Console.WriteLine("Element wise multiplication: left * right ="); Console.WriteLine(result); // Class ReadOnlyComplexMatrix supports element wise multiplications // where some arguments are read-only matrices. // Compute the product using a read-only wrapper of left. ReadOnlyComplexMatrix readOnlyLeft = left.AsReadOnly(); result = ReadOnlyComplexMatrix.ElementWiseMultiply(readOnlyLeft, right); Console.WriteLine(); Console.WriteLine("Element wise multiplication: readOnlyLeft * right ="); Console.WriteLine(result); }
public void Main() { // Create the operand. var data = new Complex[8] { new Complex(1, -1), new Complex(5, -5), new Complex(2, -2), new Complex(6, -6), new Complex(3, -3), new Complex(7, -7), new Complex(4, -4), new Complex(8, -8) }; var operand = ComplexMatrix.Dense(4, 2, data, StorageOrder.RowMajor); Console.WriteLine("operand ="); Console.WriteLine(operand); // Compute the negation of operand. var result = -operand; Console.WriteLine(); Console.WriteLine("- operand ="); Console.WriteLine(result); // In .NET languages that do not support overloaded operators, // you can use the alternative methods named Negate. result = ComplexMatrix.Negate(operand); Console.WriteLine(); Console.WriteLine("DoubleMatrix.Negate(operand) returns"); Console.WriteLine(); Console.WriteLine(result); // Both operators and alternative methods are overloaded to // support read-only matrix arguments. // Compute the negation using a read-only wrapper of operand. ReadOnlyComplexMatrix readOnlyOperand = operand.AsReadOnly(); result = -readOnlyOperand; Console.WriteLine(); Console.WriteLine("- readOnlyOperand ="); Console.WriteLine(result); }
public TestableComplexMatrixComplexScalarSubtraction( TExpected expected, TestableComplexMatrix left, Complex right) : base( expected, left, right, leftWritableRightScalarOps: new Func <ComplexMatrix, Complex, ComplexMatrix>[2] { (l, r) => l - r, (l, r) => ComplexMatrix.Subtract(l, r) }, leftReadOnlyRightScalarOps: new Func <ReadOnlyComplexMatrix, Complex, ComplexMatrix>[2] { (l, r) => l - r, (l, r) => ReadOnlyComplexMatrix.Subtract(l, r) } ) { }
public TestableDoubleScalarComplexMatrixMultiplication( TExpected expected, double left, TestableComplexMatrix right) : base( expected, left, right, leftScalarRightWritableOps: new Func <double, ComplexMatrix, ComplexMatrix>[2] { (l, r) => l * r, (l, r) => ComplexMatrix.Multiply(l, r) }, leftScalarRightReadOnlyOps: new Func <double, ReadOnlyComplexMatrix, ComplexMatrix>[2] { (l, r) => l * r, (l, r) => ReadOnlyComplexMatrix.Multiply(l, r) } ) { }
public TestableComplexMatrixDoubleScalarAddition( TExpected expected, TestableComplexMatrix left, double right) : base( expected, left, right, leftWritableRightScalarOps: new Func <ComplexMatrix, double, ComplexMatrix>[2] { (l, r) => l + r, (l, r) => ComplexMatrix.Add(l, r) }, leftReadOnlyRightScalarOps: new Func <ReadOnlyComplexMatrix, double, ComplexMatrix>[2] { (l, r) => l + r, (l, r) => ReadOnlyComplexMatrix.Add(l, r) } ) { }
public TestableComplexScalarComplexMatrixAddition( TExpected expected, Complex left, TestableComplexMatrix right) : base( expected, left, right, leftScalarRightWritableOps: new Func <Complex, ComplexMatrix, ComplexMatrix>[2] { (l, r) => l + r, (l, r) => ComplexMatrix.Add(l, r) }, leftScalarRightReadOnlyOps: new Func <Complex, ReadOnlyComplexMatrix, ComplexMatrix>[2] { (l, r) => l + r, (l, r) => ReadOnlyComplexMatrix.Add(l, r) } ) { }