From ca818de454bc938a6eaf4eb50af70e0b6e41bbe4 Mon Sep 17 00:00:00 2001 From: Christoph Ruegg Date: Sat, 3 Aug 2013 13:55:16 +0200 Subject: [PATCH] LA: Modulus between matrix and scalar; pointwise modulus; improved naming --- .../LinearAlgebra/Complex/DenseMatrix.cs | 16 +- .../LinearAlgebra/Complex/DenseVector.cs | 8 +- src/Numerics/LinearAlgebra/Complex/Matrix.cs | 42 +++-- .../LinearAlgebra/Complex/SparseMatrix.cs | 6 +- .../LinearAlgebra/Complex/SparseVector.cs | 8 +- src/Numerics/LinearAlgebra/Complex/Vector.cs | 28 +-- .../LinearAlgebra/Complex32/DenseMatrix.cs | 16 +- .../LinearAlgebra/Complex32/DenseVector.cs | 8 +- .../LinearAlgebra/Complex32/Matrix.cs | 42 +++-- .../LinearAlgebra/Complex32/SparseMatrix.cs | 6 +- .../LinearAlgebra/Complex32/SparseVector.cs | 8 +- .../LinearAlgebra/Complex32/Vector.cs | 28 +-- .../LinearAlgebra/Double/DenseMatrix.cs | 40 +++- .../LinearAlgebra/Double/DenseVector.cs | 8 +- .../LinearAlgebra/Double/DiagonalMatrix.cs | 66 ++++--- src/Numerics/LinearAlgebra/Double/Matrix.cs | 66 +++++-- .../LinearAlgebra/Double/SparseMatrix.cs | 6 +- .../LinearAlgebra/Double/SparseVector.cs | 8 +- src/Numerics/LinearAlgebra/Double/Vector.cs | 52 +++--- .../Generic/Matrix.Arithmetic.cs | 173 ++++++++++++++---- .../LinearAlgebra/Generic/Matrix.Operators.cs | 91 ++++++--- .../Generic/Vector.Arithmetic.cs | 120 ++++++------ .../LinearAlgebra/Generic/Vector.Operators.cs | 98 +++++----- .../LinearAlgebra/Single/DenseMatrix.cs | 40 +++- .../LinearAlgebra/Single/DenseVector.cs | 8 +- .../LinearAlgebra/Single/DiagonalMatrix.cs | 66 ++++--- src/Numerics/LinearAlgebra/Single/Matrix.cs | 54 ++++-- .../LinearAlgebra/Single/SparseMatrix.cs | 6 +- .../LinearAlgebra/Single/SparseVector.cs | 8 +- src/Numerics/LinearAlgebra/Single/Vector.cs | 32 ++-- 30 files changed, 747 insertions(+), 411 deletions(-) diff --git a/src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs index 721c0124..ecbbd2f3 100644 --- a/src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs @@ -593,18 +593,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar to divide the matrix with. /// The matrix to store the result of the division. - protected override void DoDivide(Complex scalar, Matrix result) + protected override void DoDivide(Complex divisor, Matrix result) { var denseResult = result as DenseMatrix; if (denseResult == null) { - base.DoDivide(scalar, result); + base.DoDivide(divisor, result); } else { - Control.LinearAlgebraProvider.ScaleArray(1.0/scalar, _values, denseResult._values); + Control.LinearAlgebraProvider.ScaleArray(1.0/divisor, _values, denseResult._values); } } @@ -631,16 +631,16 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { - var denseOther = other as DenseMatrix; + var denseOther = divisor as DenseMatrix; var denseResult = result as DenseMatrix; if (denseOther == null || denseResult == null) { - base.DoPointwiseDivide(other, result); + base.DoPointwiseDivide(divisor, result); } else { diff --git a/src/Numerics/LinearAlgebra/Complex/DenseVector.cs b/src/Numerics/LinearAlgebra/Complex/DenseVector.cs index e4f471d6..2bfd369b 100644 --- a/src/Numerics/LinearAlgebra/Complex/DenseVector.cs +++ b/src/Numerics/LinearAlgebra/Complex/DenseVector.cs @@ -628,17 +628,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The vector to pointwise divide this one by. /// The vector to store the result of the pointwise division. /// - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { - var denseOther = other as DenseVector; + var denseOther = divisor as DenseVector; var denseResult = result as DenseVector; if (denseOther == null || denseResult == null) { - base.DoPointwiseDivide(other, result); + base.DoPointwiseDivide(divisor, result); } else { diff --git a/src/Numerics/LinearAlgebra/Complex/Matrix.cs b/src/Numerics/LinearAlgebra/Complex/Matrix.cs index d01ed63c..5841857e 100644 --- a/src/Numerics/LinearAlgebra/Complex/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Complex/Matrix.cs @@ -257,25 +257,25 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar to divide the matrix with. /// The matrix to store the result of the division. - protected override void DoDivide(Complex scalar, Matrix result) + protected override void DoDivide(Complex divisor, Matrix result) { - DoMultiply(1.0 / scalar, result); + DoMultiply(1.0 / divisor, result); } /// /// Divides a scalar by each element of the matrix and stores the result in the result matrix. /// - /// The scalar to add. + /// The scalar to add. /// The matrix to store the result of the division. - protected override void DoDivideByThis(Complex scalar, Matrix result) + protected override void DoDivideByThis(Complex dividend, Matrix result) { for (var i = 0; i < RowCount; i++) { for (var j = 0; j < ColumnCount; j++) { - result.At(i, j, scalar / At(i, j)); + result.At(i, j, dividend / At(i, j)); } } } @@ -392,27 +392,47 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { for (var j = 0; j < ColumnCount; j++) { for (var i = 0; i < RowCount; i++) { - result.At(i, j, At(i, j) / other.At(i, j)); + result.At(i, j, At(i, j) / divisor.At(i, j)); } } } + /// + /// Pointwise modulus this matrix with another matrix and stores the result into the result matrix. + /// + /// The pointwise denominator matrix to use + /// The result of the modulus. + protected override void DoPointwiseModulus(Matrix divisor, Matrix result) + { + throw new NotSupportedException(); + } + /// /// Computes the modulus for each element of the matrix. /// - /// The divisor to use. + /// The scalar denominator to use. /// Matrix to store the results in. protected override void DoModulus(Complex divisor, Matrix result) { - throw new NotImplementedException(); + throw new NotSupportedException(); + } + + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + protected override void DoModulusByThis(Complex dividend, Matrix result) + { + throw new NotSupportedException(); } /// diff --git a/src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs b/src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs index 7d304548..a4b7e22b 100644 --- a/src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs @@ -1052,9 +1052,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { result.Clear(); @@ -1073,7 +1073,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex { if (!values[j].IsZero()) { - result.At(i, columnIndices[j], values[j]/other.At(i, columnIndices[j])); + result.At(i, columnIndices[j], values[j]/divisor.At(i, columnIndices[j])); } } } diff --git a/src/Numerics/LinearAlgebra/Complex/SparseVector.cs b/src/Numerics/LinearAlgebra/Complex/SparseVector.cs index ea687bf4..9f90530e 100644 --- a/src/Numerics/LinearAlgebra/Complex/SparseVector.cs +++ b/src/Numerics/LinearAlgebra/Complex/SparseVector.cs @@ -790,11 +790,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Pointwise multiplies this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise multiply with this one. + /// The vector to pointwise multiply with this one. /// The vector to store the result of the pointwise multiplication. - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { - if (ReferenceEquals(this, other)) + if (ReferenceEquals(this, divisor)) { for (var i = 0; i < _storage.ValueCount; i++) { @@ -806,7 +806,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex for (var i = 0; i < _storage.ValueCount; i++) { var index = _storage.Indices[i]; - result.At(index, _storage.Values[i] / other.At(index)); + result.At(index, _storage.Values[i] / divisor.At(index)); } } } diff --git a/src/Numerics/LinearAlgebra/Complex/Vector.cs b/src/Numerics/LinearAlgebra/Complex/Vector.cs index c26df4a7..40320362 100644 --- a/src/Numerics/LinearAlgebra/Complex/Vector.cs +++ b/src/Numerics/LinearAlgebra/Complex/Vector.cs @@ -140,27 +140,27 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Divides each element of the vector by a scalar and stores the result in the result vector. /// - /// + /// /// The scalar to divide with. /// /// /// The vector to store the result of the division. /// - protected override void DoDivide(Complex scalar, Vector result) + protected override void DoDivide(Complex divisor, Vector result) { - DoMultiply(1 / scalar, result); + DoMultiply(1 / divisor, result); } /// /// Divides a scalar by each element of the vector and stores the result in the result vector. /// - /// The scalar to divide. + /// The scalar to divide. /// The vector to store the result of the division. - protected override void DoDivideByThis(Complex scalar, Vector result) + protected override void DoDivideByThis(Complex dividend, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, scalar / At(index)); + result.At(index, dividend / At(index)); } } @@ -180,22 +180,22 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The vector to pointwise divide this one by. /// The vector to store the result of the pointwise division. - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, At(index) / other.At(index)); + result.At(index, At(index) / divisor.At(index)); } } /// /// Pointwise modulus this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise modulus this one by. + /// The vector to pointwise modulus this one by. /// The result of the modulus. - protected override void DoPointwiseModulus(Vector other, Vector result) + protected override void DoPointwiseModulus(Vector divisor, Vector result) { throw new NotSupportedException(); } @@ -224,7 +224,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Computes the modulus for each element of the vector for the given divisor. /// - /// The divisor to use. + /// The scalar denominator to use. /// A vector to store the results in. protected override void DoModulus(Complex divisor, Vector result) { @@ -234,9 +234,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex /// /// Computes the modulus for the given dividend for each element of the vector. /// - /// The dividend to use. + /// The scalar numerator to use. /// A vector to store the results in. - protected override void DoModulusByThis(Complex scalar, Vector result) + protected override void DoModulusByThis(Complex dividend, Vector result) { throw new NotSupportedException(); } diff --git a/src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs index 0027d783..2e7e8956 100644 --- a/src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs @@ -588,18 +588,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar to divide the matrix with. /// The matrix to store the result of the division. - protected override void DoDivide(Complex32 scalar, Matrix result) + protected override void DoDivide(Complex32 divisor, Matrix result) { var denseResult = result as DenseMatrix; if (denseResult == null) { - base.DoDivide(scalar, result); + base.DoDivide(divisor, result); } else { - Control.LinearAlgebraProvider.ScaleArray(1.0f/scalar, _values, denseResult._values); + Control.LinearAlgebraProvider.ScaleArray(1.0f/divisor, _values, denseResult._values); } } @@ -626,16 +626,16 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { - var denseOther = other as DenseMatrix; + var denseOther = divisor as DenseMatrix; var denseResult = result as DenseMatrix; if (denseOther == null || denseResult == null) { - base.DoPointwiseDivide(other, result); + base.DoPointwiseDivide(divisor, result); } else { diff --git a/src/Numerics/LinearAlgebra/Complex32/DenseVector.cs b/src/Numerics/LinearAlgebra/Complex32/DenseVector.cs index 2a37daf0..bfe21643 100644 --- a/src/Numerics/LinearAlgebra/Complex32/DenseVector.cs +++ b/src/Numerics/LinearAlgebra/Complex32/DenseVector.cs @@ -623,17 +623,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The vector to pointwise divide this one by. /// The vector to store the result of the pointwise division. /// - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { - var denseOther = other as DenseVector; + var denseOther = divisor as DenseVector; var denseResult = result as DenseVector; if (denseOther == null || denseResult == null) { - base.DoPointwiseDivide(other, result); + base.DoPointwiseDivide(divisor, result); } else { diff --git a/src/Numerics/LinearAlgebra/Complex32/Matrix.cs b/src/Numerics/LinearAlgebra/Complex32/Matrix.cs index 80196c32..224eb290 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Matrix.cs @@ -230,25 +230,25 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar to divide the matrix with. /// The matrix to store the result of the division. - protected override void DoDivide(Complex32 scalar, Matrix result) + protected override void DoDivide(Complex32 divisor, Matrix result) { - DoMultiply(1.0f / scalar, result); + DoMultiply(1.0f / divisor, result); } /// /// Divides a scalar by each element of the matrix and stores the result in the result matrix. /// - /// The scalar to add. + /// The scalar to add. /// The matrix to store the result of the division. - protected override void DoDivideByThis(Complex32 scalar, Matrix result) + protected override void DoDivideByThis(Complex32 dividend, Matrix result) { for (var i = 0; i < RowCount; i++) { for (var j = 0; j < ColumnCount; j++) { - result.At(i, j, scalar / At(i, j)); + result.At(i, j, dividend / At(i, j)); } } } @@ -387,27 +387,47 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { for (var j = 0; j < ColumnCount; j++) { for (var i = 0; i < RowCount; i++) { - result.At(i, j, At(i, j) / other.At(i, j)); + result.At(i, j, At(i, j) / divisor.At(i, j)); } } } + /// + /// Pointwise modulus this matrix with another matrix and stores the result into the result matrix. + /// + /// The pointwise denominator matrix to use + /// The result of the modulus. + protected override void DoPointwiseModulus(Matrix divisor, Matrix result) + { + throw new NotSupportedException(); + } + /// /// Computes the modulus for each element of the matrix. /// - /// The divisor to use. + /// The scalar denominator to use. /// Matrix to store the results in. protected override void DoModulus(Complex32 divisor, Matrix result) { - throw new NotImplementedException(); + throw new NotSupportedException(); + } + + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + protected override void DoModulusByThis(Complex32 dividend, Matrix result) + { + throw new NotSupportedException(); } /// diff --git a/src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs b/src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs index f6c63a3f..5e51a516 100644 --- a/src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs @@ -1046,9 +1046,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { result.Clear(); @@ -1067,7 +1067,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 { if (!values[j].IsZero()) { - result.At(i, columnIndices[j], values[j]/other.At(i, columnIndices[j])); + result.At(i, columnIndices[j], values[j]/divisor.At(i, columnIndices[j])); } } } diff --git a/src/Numerics/LinearAlgebra/Complex32/SparseVector.cs b/src/Numerics/LinearAlgebra/Complex32/SparseVector.cs index 7eca9e85..dc84be28 100644 --- a/src/Numerics/LinearAlgebra/Complex32/SparseVector.cs +++ b/src/Numerics/LinearAlgebra/Complex32/SparseVector.cs @@ -785,11 +785,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Pointwise multiplies this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise multiply with this one. + /// The vector to pointwise multiply with this one. /// The vector to store the result of the pointwise multiplication. - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { - if (ReferenceEquals(this, other)) + if (ReferenceEquals(this, divisor)) { for (var i = 0; i < _storage.ValueCount; i++) { @@ -801,7 +801,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 for (var i = 0; i < _storage.ValueCount; i++) { var index = _storage.Indices[i]; - result.At(index, _storage.Values[i] / other.At(index)); + result.At(index, _storage.Values[i] / divisor.At(index)); } } } diff --git a/src/Numerics/LinearAlgebra/Complex32/Vector.cs b/src/Numerics/LinearAlgebra/Complex32/Vector.cs index 19109c2e..b39d6c3c 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Vector.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Vector.cs @@ -135,27 +135,27 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Divides each element of the vector by a scalar and stores the result in the result vector. /// - /// + /// /// The scalar to divide with. /// /// /// The vector to store the result of the division. /// - protected override void DoDivide(Complex32 scalar, Vector result) + protected override void DoDivide(Complex32 divisor, Vector result) { - DoMultiply(1 / scalar, result); + DoMultiply(1 / divisor, result); } /// /// Divides a scalar by each element of the vector and stores the result in the result vector. /// - /// The scalar to divide. + /// The scalar to divide. /// The vector to store the result of the division. - protected override void DoDivideByThis(Complex32 scalar, Vector result) + protected override void DoDivideByThis(Complex32 dividend, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, scalar / At(index)); + result.At(index, dividend / At(index)); } } @@ -175,22 +175,22 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The vector to pointwise divide this one by. /// The vector to store the result of the pointwise division. - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, At(index) / other.At(index)); + result.At(index, At(index) / divisor.At(index)); } } /// /// Pointwise modulus this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise modulus this one by. + /// The vector to pointwise modulus this one by. /// The result of the modulus. - protected override void DoPointwiseModulus(Vector other, Vector result) + protected override void DoPointwiseModulus(Vector divisor, Vector result) { throw new NotSupportedException(); } @@ -219,7 +219,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Computes the modulus for each element of the vector for the given divisor. /// - /// The divisor to use. + /// The scalar denominator to use. /// A vector to store the results in. protected override void DoModulus(Complex32 divisor, Vector result) { @@ -229,9 +229,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 /// /// Computes the modulus for the given dividend for each element of the vector. /// - /// The dividend to use. + /// The scalar numerator to use. /// A vector to store the results in. - protected override void DoModulusByThis(Complex32 scalar, Vector result) + protected override void DoModulusByThis(Complex32 dividend, Vector result) { throw new NotSupportedException(); } diff --git a/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs index ee9dfa3e..1d351972 100644 --- a/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs @@ -674,18 +674,18 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar to divide the matrix with. /// The matrix to store the result of the division. - protected override void DoDivide(double scalar, Matrix result) + protected override void DoDivide(double divisor, Matrix result) { var denseResult = result as DenseMatrix; if (denseResult == null) { - base.DoDivide(scalar, result); + base.DoDivide(divisor, result); } else { - Control.LinearAlgebraProvider.ScaleArray(1.0/scalar, _values, denseResult._values); + Control.LinearAlgebraProvider.ScaleArray(1.0/divisor, _values, denseResult._values); } } @@ -712,16 +712,16 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { - var denseOther = other as DenseMatrix; + var denseOther = divisor as DenseMatrix; var denseResult = result as DenseMatrix; if (denseOther == null || denseResult == null) { - base.DoPointwiseDivide(other, result); + base.DoPointwiseDivide(divisor, result); } else { @@ -758,6 +758,30 @@ namespace MathNet.Numerics.LinearAlgebra.Double }); } + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + protected override void DoModulusByThis(double dividend, Matrix result) + { + var denseResult = result as DenseMatrix; + if (denseResult == null) + { + base.DoModulusByThis(dividend, result); + return; + } + + CommonParallel.For(0, _values.Length, 4096, (a, b) => + { + var v = denseResult._values; + for (int i = a; i < b; i++) + { + v[i] = dividend%_values[i]; + } + }); + } + /// /// Computes the trace of this matrix. /// diff --git a/src/Numerics/LinearAlgebra/Double/DenseVector.cs b/src/Numerics/LinearAlgebra/Double/DenseVector.cs index bd75bf80..283fc212 100644 --- a/src/Numerics/LinearAlgebra/Double/DenseVector.cs +++ b/src/Numerics/LinearAlgebra/Double/DenseVector.cs @@ -715,17 +715,17 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The vector to pointwise divide this one by. /// The vector to store the result of the pointwise division. /// - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { - var denseOther = other as DenseVector; + var denseOther = divisor as DenseVector; var denseResult = result as DenseVector; if (denseOther == null || denseResult == null) { - base.DoPointwiseDivide(other, result); + base.DoPointwiseDivide(divisor, result); } else { diff --git a/src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs b/src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs index 72a8b0ee..9ddd2b07 100644 --- a/src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs +++ b/src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs @@ -28,17 +28,18 @@ // OTHER DEALINGS IN THE SOFTWARE. // +using MathNet.Numerics.Distributions; +using MathNet.Numerics.LinearAlgebra.Generic; +using MathNet.Numerics.LinearAlgebra.Storage; +using MathNet.Numerics.Properties; +using MathNet.Numerics.Threading; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; + namespace MathNet.Numerics.LinearAlgebra.Double { - using Distributions; - using Generic; - using Properties; - using Storage; - using System; - using System.Collections.Generic; - using System.Diagnostics; - using System.Linq; - /// /// A matrix type for diagonal matrices. /// @@ -1044,28 +1045,49 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Computes the modulus for each element of the matrix. /// - /// The divisor to use. + /// The scalar denominator to use. /// Matrix to store the results in. protected override void DoModulus(double divisor, Matrix result) { - var denseResult = result as DiagonalMatrix; - - if (denseResult == null) + var diagonalResult = result as DiagonalMatrix; + if (diagonalResult == null) { base.DoModulus(divisor, result); + return; } - else - { - if (!ReferenceEquals(this, result)) - { - CopyTo(result); - } - for (var index = 0; index < _data.Length; index++) + CommonParallel.For(0, _data.Length, 4096, (a, b) => { - denseResult._data[index] %= divisor; - } + var r = diagonalResult._data; + for (var i = a; i < b; i++) + { + r[i] = _data[i]%divisor; + } + }); + } + + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + protected override void DoModulusByThis(double dividend, Matrix result) + { + var diagonalResult = result as DiagonalMatrix; + if (diagonalResult == null) + { + base.DoModulusByThis(dividend, result); + return; } + + CommonParallel.For(0, _data.Length, 4096, (a, b) => + { + var r = diagonalResult._data; + for (var i = a; i < b; i++) + { + r[i] = dividend%_data[i]; + } + }); } #region Static constructors for special matrices. diff --git a/src/Numerics/LinearAlgebra/Double/Matrix.cs b/src/Numerics/LinearAlgebra/Double/Matrix.cs index 328aaa3e..ca203938 100644 --- a/src/Numerics/LinearAlgebra/Double/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Double/Matrix.cs @@ -220,25 +220,25 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar to divide the matrix with. /// The matrix to store the result of the division. - protected override void DoDivide(double scalar, Matrix result) + protected override void DoDivide(double divisor, Matrix result) { - DoMultiply(1.0 / scalar, result); + DoMultiply(1.0 / divisor, result); } /// /// Divides a scalar by each element of the matrix and stores the result in the result matrix. /// - /// The scalar to add. + /// The scalar to add. /// The matrix to store the result of the division. - protected override void DoDivideByThis(double scalar, Matrix result) + protected override void DoDivideByThis(double dividend, Matrix result) { for (var i = 0; i < RowCount; i++) { for (var j = 0; j < ColumnCount; j++) { - result.At(i, j, scalar / At(i, j)); + result.At(i, j, dividend / At(i, j)); } } } @@ -357,6 +357,38 @@ namespace MathNet.Numerics.LinearAlgebra.Double CopyTo(result); } + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar denominator to use. + /// Matrix to store the results in. + protected override void DoModulus(double divisor, Matrix result) + { + for (var row = 0; row < RowCount; row++) + { + for (var column = 0; column < ColumnCount; column++) + { + result.At(row, column, At(row, column)%divisor); + } + } + } + + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + protected override void DoModulusByThis(double dividend, Matrix result) + { + for (var row = 0; row < RowCount; row++) + { + for (var column = 0; column < ColumnCount; column++) + { + result.At(row, column, dividend%At(row, column)); + } + } + } + /// /// Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. /// @@ -368,7 +400,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double { for (var i = 0; i < RowCount; i++) { - result.At(i, j, At(i, j) * other.At(i, j)); + result.At(i, j, At(i, j)*other.At(i, j)); } } } @@ -376,31 +408,31 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { for (var j = 0; j < ColumnCount; j++) { for (var i = 0; i < RowCount; i++) { - result.At(i, j, At(i, j) / other.At(i, j)); + result.At(i, j, At(i, j)/divisor.At(i, j)); } } } /// - /// Computes the modulus for each element of the matrix. + /// Pointwise modulus this matrix with another matrix and stores the result into the result matrix. /// - /// The divisor to use. - /// Matrix to store the results in. - protected override void DoModulus(double divisor, Matrix result) + /// The pointwise denominator matrix to use + /// The result of the modulus. + protected override void DoPointwiseModulus(Matrix divisor, Matrix result) { - for (var row = 0; row < RowCount; row++) + for (var j = 0; j < ColumnCount; j++) { - for (var column = 0; column < ColumnCount; column++) + for (var i = 0; i < RowCount; i++) { - result.At(row, column, At(row, column) % divisor); + result.At(i, j, At(i, j)%divisor.At(i, j)); } } } diff --git a/src/Numerics/LinearAlgebra/Double/SparseMatrix.cs b/src/Numerics/LinearAlgebra/Double/SparseMatrix.cs index b0165585..35e234f1 100644 --- a/src/Numerics/LinearAlgebra/Double/SparseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Double/SparseMatrix.cs @@ -1045,9 +1045,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { result.Clear(); @@ -1066,7 +1066,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double { if (values[j] != 0d) { - result.At(i, columnIndices[j], values[j]/other.At(i, columnIndices[j])); + result.At(i, columnIndices[j], values[j]/divisor.At(i, columnIndices[j])); } } } diff --git a/src/Numerics/LinearAlgebra/Double/SparseVector.cs b/src/Numerics/LinearAlgebra/Double/SparseVector.cs index 0b75a004..715f2f87 100644 --- a/src/Numerics/LinearAlgebra/Double/SparseVector.cs +++ b/src/Numerics/LinearAlgebra/Double/SparseVector.cs @@ -821,11 +821,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Pointwise multiplies this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise multiply with this one. + /// The vector to pointwise multiply with this one. /// The vector to store the result of the pointwise multiplication. - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { - if (ReferenceEquals(this, other)) + if (ReferenceEquals(this, divisor)) { for (var i = 0; i < _storage.ValueCount; i++) { @@ -837,7 +837,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double for (var i = 0; i < _storage.ValueCount; i++) { var index = _storage.Indices[i]; - result.At(index, _storage.Values[i] / other.At(index)); + result.At(index, _storage.Values[i] / divisor.At(index)); } } } diff --git a/src/Numerics/LinearAlgebra/Double/Vector.cs b/src/Numerics/LinearAlgebra/Double/Vector.cs index 3b8ef23d..4de80d00 100644 --- a/src/Numerics/LinearAlgebra/Double/Vector.cs +++ b/src/Numerics/LinearAlgebra/Double/Vector.cs @@ -134,27 +134,27 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Divides each element of the vector by a scalar and stores the result in the result vector. /// - /// + /// /// The scalar to divide with. /// /// /// The vector to store the result of the division. /// - protected override void DoDivide(double scalar, Vector result) + protected override void DoDivide(double divisor, Vector result) { - DoMultiply(1 / scalar, result); + DoMultiply(1 / divisor, result); } /// /// Divides a scalar by each element of the vector and stores the result in the result vector. /// - /// The scalar to divide. + /// The scalar to divide. /// The vector to store the result of the division. - protected override void DoDivideByThis(double scalar, Vector result) + protected override void DoDivideByThis(double dividend, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, scalar / At(index)); + result.At(index, dividend / At(index)); } } @@ -174,39 +174,26 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The vector to pointwise divide this one by. /// The vector to store the result of the pointwise division. - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, At(index) / other.At(index)); + result.At(index, At(index) / divisor.At(index)); } } /// /// Pointwise modulus this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise modulus this one by. + /// The vector to pointwise modulus this one by. /// The result of the modulus. - protected override void DoPointwiseModulus(Vector other, Vector result) - { - for (var index = 0; index < Count; index++) - { - result.At(index, At(index) % other.At(index)); - } - } - - /// - /// Computes the modulus for the given dividend for each element of the vector. - /// - /// The dividend to use. - /// A vector to store the results in. - protected override void DoModulusByThis(double scalar, Vector result) + protected override void DoPointwiseModulus(Vector divisor, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, scalar % At(index)); + result.At(index, At(index) % divisor.At(index)); } } @@ -234,7 +221,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Computes the modulus for each element of the vector for the given divisor. /// - /// The divisor to use. + /// The scalar denominator to use. /// A vector to store the results in. protected override void DoModulus(double divisor, Vector result) { @@ -244,6 +231,19 @@ namespace MathNet.Numerics.LinearAlgebra.Double } } + /// + /// Computes the modulus for the given dividend for each element of the vector. + /// + /// The scalar numerator to use. + /// A vector to store the results in. + protected override void DoModulusByThis(double dividend, Vector result) + { + for (var index = 0; index < Count; index++) + { + result.At(index, dividend%At(index)); + } + } + /// /// Returns the value of the absolute minimum element. /// diff --git a/src/Numerics/LinearAlgebra/Generic/Matrix.Arithmetic.cs b/src/Numerics/LinearAlgebra/Generic/Matrix.Arithmetic.cs index 1d7a99a2..48734d47 100644 --- a/src/Numerics/LinearAlgebra/Generic/Matrix.Arithmetic.cs +++ b/src/Numerics/LinearAlgebra/Generic/Matrix.Arithmetic.cs @@ -147,24 +147,31 @@ namespace MathNet.Numerics.LinearAlgebra.Generic /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar denominator to use. /// The matrix to store the result of the division. - protected abstract void DoDivide(T scalar, Matrix result); + protected abstract void DoDivide(T divisor, Matrix result); /// /// Divides a scalar by each element of the matrix and stores the result in the result matrix. /// - /// The scalar to divide. + /// The scalar numerator to use. /// The matrix to store the result of the division. - protected abstract void DoDivideByThis(T scalar, Matrix result); + protected abstract void DoDivideByThis(T dividend, Matrix result); /// - /// Computes the modulus for each element of the matrix. + /// Computes the modulus for the given divisor each element of the matrix. /// - /// The divisor to use. + /// The scalar denominator to use. /// Matrix to store the results in. protected abstract void DoModulus(T divisor, Matrix result); + /// + /// Computes the modulus for the given dividend for each element of the matrix. + /// + /// The scalar numerator to use. + /// A vector to store the results in. + protected abstract void DoModulusByThis(T dividend, Matrix result); + /// /// Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. /// @@ -175,9 +182,16 @@ namespace MathNet.Numerics.LinearAlgebra.Generic /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The pointwise denominator matrix to use. /// The matrix to store the result of the pointwise division. - protected abstract void DoPointwiseDivide(Matrix other, Matrix result); + protected abstract void DoPointwiseDivide(Matrix divisor, Matrix result); + + /// + /// Pointwise modulus this matrix with another matrix and stores the result into the result matrix. + /// + /// The pointwise denominator matrix to use + /// The result of the modulus. + protected abstract void DoPointwiseModulus(Matrix divisor, Matrix result); /// /// Adds a scalar to each element of the matrix. @@ -1038,6 +1052,70 @@ namespace MathNet.Numerics.LinearAlgebra.Generic DoConjugate(result); } + /// + /// Computes the modulus (matrix % divisor) for each element of the matrix. + /// + /// The scalar denominator to use. + /// A matrix containing the results. + public Matrix Modulus(T divisor) + { + var result = CreateMatrix(RowCount, ColumnCount); + DoModulus(divisor, result); + return result; + } + + /// + /// Computes the modulus (matrix % divisor) for each element of the matrix. + /// + /// The scalar denominator to use. + /// Matrix to store the results in. + public void Modulus(T divisor, Matrix result) + { + if (result == null) + { + throw new ArgumentNullException("result"); + } + + if (ColumnCount != result.ColumnCount || RowCount != result.RowCount) + { + throw DimensionsDontMatch(this, result); + } + + DoModulus(divisor, result); + } + + /// + /// Computes the modulus (dividend % matrix) for each element of the matrix. + /// + /// The scalar numerator to use. + /// A matrix containing the results. + public Matrix ModulusByThis(T dividend) + { + var result = CreateMatrix(RowCount, ColumnCount); + DoModulusByThis(dividend, result); + return result; + } + + /// + /// Computes the modulus (dividend % matrix) for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + public void ModulusByThis(T dividend, Matrix result) + { + if (result == null) + { + throw new ArgumentNullException("result"); + } + + if (ColumnCount != result.ColumnCount || RowCount != result.RowCount) + { + throw DimensionsDontMatch(this, result); + } + + DoModulusByThis(dividend, result); + } + /// /// Pointwise multiplies this matrix with another matrix. /// @@ -1094,41 +1172,41 @@ namespace MathNet.Numerics.LinearAlgebra.Generic /// /// Pointwise divide this matrix by another matrix. /// - /// The matrix to pointwise subtract this one by. + /// The pointwise denominator matrix to use. /// If the other matrix is . - /// If this matrix and are not the same size. - /// A new matrix that is the pointwise division of this matrix and . - public Matrix PointwiseDivide(Matrix other) + /// If this matrix and are not the same size. + /// A new matrix that is the pointwise division of this matrix and . + public Matrix PointwiseDivide(Matrix divisor) { - if (other == null) + if (divisor == null) { - throw new ArgumentNullException("other"); + throw new ArgumentNullException("divisor"); } - if (ColumnCount != other.ColumnCount || RowCount != other.RowCount) + if (ColumnCount != divisor.ColumnCount || RowCount != divisor.RowCount) { - throw DimensionsDontMatch(this, other); + throw DimensionsDontMatch(this, divisor); } var result = CreateMatrix(RowCount, ColumnCount); - DoPointwiseDivide(other, result); + DoPointwiseDivide(divisor, result); return result; } /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The pointwise denominator matrix to use. /// The matrix to store the result of the pointwise division. /// If the other matrix is . /// If the result matrix is . - /// If this matrix and are not the same size. + /// If this matrix and are not the same size. /// If this matrix and are not the same size. - public void PointwiseDivide(Matrix other, Matrix result) + public void PointwiseDivide(Matrix divisor, Matrix result) { - if (other == null) + if (divisor == null) { - throw new ArgumentNullException("other"); + throw new ArgumentNullException("divisor"); } if (result == null) @@ -1136,44 +1214,65 @@ namespace MathNet.Numerics.LinearAlgebra.Generic throw new ArgumentNullException("result"); } - if (ColumnCount != result.ColumnCount || RowCount != result.RowCount || ColumnCount != other.ColumnCount || RowCount != other.RowCount) + if (ColumnCount != result.ColumnCount || RowCount != result.RowCount || ColumnCount != divisor.ColumnCount || RowCount != divisor.RowCount) { - throw DimensionsDontMatch(this, other, result); + throw DimensionsDontMatch(this, divisor, result); } - DoPointwiseDivide(other, result); + DoPointwiseDivide(divisor, result); } /// - /// Computes the modulus for each element of the matrix. + /// Pointwise modulus this matrix by another matrix. /// - /// The divisor to use. - /// A matrix containing the results. - public Matrix Modulus(T divisor) + /// The pointwise denominator matrix to use. + /// If the other matrix is . + /// If this matrix and are not the same size. + /// A new matrix that is the pointwise modulus of this matrix and . + public Matrix PointwiseModulus(Matrix divisor) { + if (divisor == null) + { + throw new ArgumentNullException("divisor"); + } + + if (ColumnCount != divisor.ColumnCount || RowCount != divisor.RowCount) + { + throw DimensionsDontMatch(this, divisor); + } + var result = CreateMatrix(RowCount, ColumnCount); - DoModulus(divisor, result); + DoPointwiseModulus(divisor, result); return result; } /// - /// Computes the modulus for each element of the matrix. + /// Pointwise modulus this matrix by another matrix and stores the result into the result matrix. /// - /// The divisor to use. - /// Matrix to store the results in. - public void Modulus(T divisor, Matrix result) + /// The pointwise denominator matrix to use. + /// The matrix to store the result of the pointwise modulus. + /// If the other matrix is . + /// If the result matrix is . + /// If this matrix and are not the same size. + /// If this matrix and are not the same size. + public void PointwiseModulus(Matrix divisor, Matrix result) { + if (divisor == null) + { + throw new ArgumentNullException("divisor"); + } + if (result == null) { throw new ArgumentNullException("result"); } - if (ColumnCount != result.ColumnCount || RowCount != result.RowCount) + if (ColumnCount != result.ColumnCount || RowCount != result.RowCount || ColumnCount != divisor.ColumnCount || RowCount != divisor.RowCount) { - throw DimensionsDontMatch(this, result); + throw DimensionsDontMatch(this, divisor, result); } - DoModulus(divisor, result); + DoPointwiseModulus(divisor, result); } /// diff --git a/src/Numerics/LinearAlgebra/Generic/Matrix.Operators.cs b/src/Numerics/LinearAlgebra/Generic/Matrix.Operators.cs index 0c6b7049..73c779b3 100644 --- a/src/Numerics/LinearAlgebra/Generic/Matrix.Operators.cs +++ b/src/Numerics/LinearAlgebra/Generic/Matrix.Operators.cs @@ -282,52 +282,87 @@ namespace MathNet.Numerics.LinearAlgebra.Generic /// /// Divides a scalar with a matrix. /// - /// The scalar to divide. - /// The matrix. + /// The scalar to divide. + /// The matrix. /// The result of the division. - /// If is . - public static Matrix operator /(T leftSide, Matrix rightSide) + /// If is . + public static Matrix operator /(T dividend, Matrix divisor) { - if (rightSide == null) + if (divisor == null) { - throw new ArgumentNullException("rightSide"); + throw new ArgumentNullException("divisor"); } - return rightSide.DivideByThis(leftSide); + return divisor.DivideByThis(dividend); } /// /// Divides a matrix with a scalar. /// - /// The matrix to divide. - /// The scalar value. + /// The matrix to divide. + /// The scalar value. /// The result of the division. - /// If is . - public static Matrix operator /(Matrix leftSide, T rightSide) + /// If is . + public static Matrix operator /(Matrix dividend, T divisor) { - if (leftSide == null) + if (dividend == null) { - throw new ArgumentNullException("leftSide"); + throw new ArgumentNullException("dividend"); } - return leftSide.Divide(rightSide); + return dividend.Divide(divisor); } /// - /// Multiplies a Matrix by a constant and returns the result. + /// Computes the modulus of each element of the matrix of the given divisor. /// - /// The matrix to multiply. - /// The constant to multiply the matrix by. - /// The result of the multiplication. - /// If is . - public static Matrix operator %(Matrix leftSide, T rightSide) + /// The matrix whose elements we want to compute the modulus of. + /// The divisor to use. + /// The result of the calculation + /// If is . + public static Matrix operator %(Matrix dividend, T divisor) { - if (leftSide == null) + if (dividend == null) { - throw new ArgumentNullException("leftSide"); + throw new ArgumentNullException("dividend"); } - return leftSide.Modulus(rightSide); + return dividend.Modulus(divisor); + } + + /// + /// Computes the modulus of the given dividend of each element of the matrix. + /// + /// The dividend we want to compute the modulus of. + /// The matrix whose elements we want to use as divisor. + /// The result of the calculation + /// If is . + public static Matrix operator %(T dividend, Matrix divisor) + { + if (divisor == null) + { + throw new ArgumentNullException("dividend"); + } + + return divisor.ModulusByThis(dividend); + } + + /// + /// Computes the pointwise modulus of each element of two matrices. + /// + /// The matrix whose elements we want to compute the modulus of. + /// The divisor to use. + /// The result of the calculation + /// If and are not the same size. + /// If is . + public static Matrix operator %(Matrix dividend, Matrix divisor) + { + if (dividend == null) + { + throw new ArgumentNullException("dividend"); + } + + return dividend.PointwiseModulus(divisor); } [SpecialName] @@ -337,9 +372,15 @@ namespace MathNet.Numerics.LinearAlgebra.Generic } [SpecialName] - public static Matrix op_DotDivide(Matrix x, Matrix y) + public static Matrix op_DotDivide(Matrix dividend, Matrix divisor) + { + return dividend.PointwiseDivide(divisor); + } + + [SpecialName] + public static Vector op_DotPercent(Vector dividend, Vector divisor) { - return x.PointwiseDivide(y); + return dividend.PointwiseModulus(divisor); } } } diff --git a/src/Numerics/LinearAlgebra/Generic/Vector.Arithmetic.cs b/src/Numerics/LinearAlgebra/Generic/Vector.Arithmetic.cs index 7b145037..d4033f30 100644 --- a/src/Numerics/LinearAlgebra/Generic/Vector.Arithmetic.cs +++ b/src/Numerics/LinearAlgebra/Generic/Vector.Arithmetic.cs @@ -103,30 +103,30 @@ namespace MathNet.Numerics.LinearAlgebra.Generic /// /// Divides each element of the vector by a scalar and stores the result in the result vector. /// - /// The scalar to divide with. + /// The scalar denominator to use. /// The vector to store the result of the division. - protected abstract void DoDivide(T scalar, Vector result); + protected abstract void DoDivide(T divisor, Vector result); /// /// Divides a scalar by each element of the vector and stores the result in the result vector. /// - /// The scalar to divide. + /// The scalar numerator to use. /// The vector to store the result of the division. - protected abstract void DoDivideByThis(T scalar, Vector result); + protected abstract void DoDivideByThis(T dividend, Vector result); /// /// Computes the modulus for each element of the vector for the given divisor. /// - /// The divisor to use. + /// The scalar denominator to use. /// A vector to store the results in. - protected abstract void DoModulus(T scalar, Vector result); + protected abstract void DoModulus(T divisor, Vector result); /// /// Computes the modulus for the given dividend for each element of the vector. /// - /// The dividend to use. + /// The scalar numerator to use. /// A vector to store the results in. - protected abstract void DoModulusByThis(T scalar, Vector result); + protected abstract void DoModulusByThis(T dividend, Vector result); /// /// Pointwise multiplies this vector with another vector and stores the result into the result vector. @@ -138,16 +138,16 @@ namespace MathNet.Numerics.LinearAlgebra.Generic /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The pointwise denominator vector to use. /// The result of the division. - protected abstract void DoPointwiseDivide(Vector other, Vector result); + protected abstract void DoPointwiseDivide(Vector divisor, Vector result); /// /// Pointwise modulus this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise modulus this one by. + /// The pointwise denominator vector to use. /// The result of the modulus. - protected abstract void DoPointwiseModulus(Vector other, Vector result); + protected abstract void DoPointwiseModulus(Vector divisor, Vector result); /// /// Adds a scalar to each element of the vector. @@ -601,23 +601,23 @@ namespace MathNet.Numerics.LinearAlgebra.Generic } /// - /// Computes the modulus for each element of the vector for the given divisor. + /// Computes the modulus (vector % divisor) for each element of the vector for the given divisor. /// - /// The divisor to use. + /// The scalar denominator to use. /// A vector containing the result. - public Vector Modulus(T scalar) + public Vector Modulus(T divisor) { var result = CreateVector(Count); - DoModulus(scalar, result); + DoModulus(divisor, result); return result; } /// - /// Computes the modulus for each element of the vector for the given divisor. + /// Computes the modulus (vector % divisor) for each element of the vector for the given divisor. /// - /// The divisor to use. + /// The scalar denominator to use. /// A vector to store the results in. - public void Modulus(T scalar, Vector result) + public void Modulus(T divisor, Vector result) { if (result == null) { @@ -629,27 +629,27 @@ namespace MathNet.Numerics.LinearAlgebra.Generic throw new ArgumentException(Resources.ArgumentVectorsSameLength, "result"); } - DoModulus(scalar, result); + DoModulus(divisor, result); } /// - /// Computes the modulus for the given dividend for each element of the vector. + /// Computes the modulus (dividend % vector) for the given dividend for each element of the vector. /// - /// The dividend to use. + /// The scalar numerator to use. /// A vector containing the result. - public Vector ModulusByThis(T scalar) + public Vector ModulusByThis(T dividend) { var result = CreateVector(Count); - DoModulusByThis(scalar, result); + DoModulusByThis(dividend, result); return result; } /// - /// Computes the modulus for the given dividend for each element of the vector. + /// Computes the modulus (dividend % vector) for the given dividend for each element of the vector. /// - /// The dividend to use. + /// The scalar numerator to use. /// A vector to store the results in. - public void ModulusByThis(T scalar, Vector result) + public void ModulusByThis(T dividend, Vector result) { if (result == null) { @@ -661,7 +661,7 @@ namespace MathNet.Numerics.LinearAlgebra.Generic throw new ArgumentException(Resources.ArgumentVectorsSameLength, "result"); } - DoModulusByThis(scalar, result); + DoModulusByThis(dividend, result); } /// @@ -725,51 +725,51 @@ namespace MathNet.Numerics.LinearAlgebra.Generic /// /// Pointwise divide this vector with another vector. /// - /// The vector to pointwise divide this one by. + /// The pointwise denominator vector to use. /// A new vector which is the pointwise division of the two vectors. /// If the other vector is . - /// If this vector and are not the same size. - public Vector PointwiseDivide(Vector other) + /// If this vector and are not the same size. + public Vector PointwiseDivide(Vector divisor) { - if (other == null) + if (divisor == null) { - throw new ArgumentNullException("other"); + throw new ArgumentNullException("divisor"); } - if (Count != other.Count) + if (Count != divisor.Count) { - throw new ArgumentException(Resources.ArgumentVectorsSameLength, "other"); + throw new ArgumentException(Resources.ArgumentVectorsSameLength, "divisor"); } var result = CreateVector(Count); - DoPointwiseDivide(other, result); + DoPointwiseDivide(divisor, result); return result; } /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The pointwise denominator vector to use. /// The vector to store the result of the pointwise division. /// If the other vector is . /// If the result vector is . - /// If this vector and are not the same size. + /// If this vector and are not the same size. /// If this vector and are not the same size. - public void PointwiseDivide(Vector other, Vector result) + public void PointwiseDivide(Vector divisor, Vector result) { if (result == null) { throw new ArgumentNullException("result"); } - if (other == null) + if (divisor == null) { - throw new ArgumentNullException("other"); + throw new ArgumentNullException("divisor"); } - if (Count != other.Count) + if (Count != divisor.Count) { - throw new ArgumentException(Resources.ArgumentVectorsSameLength, "other"); + throw new ArgumentException(Resources.ArgumentVectorsSameLength, "divisor"); } if (Count != result.Count) @@ -777,57 +777,57 @@ namespace MathNet.Numerics.LinearAlgebra.Generic throw new ArgumentException(Resources.ArgumentVectorsSameLength, "result"); } - DoPointwiseDivide(other, result); + DoPointwiseDivide(divisor, result); } /// /// Pointwise modulus this vector with another vector. /// - /// The vector to pointwise modulus this one by. + /// The pointwise denominator vector to use. /// A new vector which is the pointwise modulus of the two vectors. /// If the other vector is . - /// If this vector and are not the same size. - public Vector PointwiseModulus(Vector other) + /// If this vector and are not the same size. + public Vector PointwiseModulus(Vector divisor) { - if (other == null) + if (divisor == null) { - throw new ArgumentNullException("other"); + throw new ArgumentNullException("divisor"); } - if (Count != other.Count) + if (Count != divisor.Count) { - throw new ArgumentException(Resources.ArgumentVectorsSameLength, "other"); + throw new ArgumentException(Resources.ArgumentVectorsSameLength, "divisor"); } var result = CreateVector(Count); - DoPointwiseModulus(other, result); + DoPointwiseModulus(divisor, result); return result; } /// /// Pointwise modulus this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise modulus this one by. + /// The pointwise denominator vector to use. /// The vector to store the result of the pointwise modulus. /// If the other vector is . /// If the result vector is . - /// If this vector and are not the same size. + /// If this vector and are not the same size. /// If this vector and are not the same size. - public void PointwiseModulus(Vector other, Vector result) + public void PointwiseModulus(Vector divisor, Vector result) { if (result == null) { throw new ArgumentNullException("result"); } - if (other == null) + if (divisor == null) { - throw new ArgumentNullException("other"); + throw new ArgumentNullException("divisor"); } - if (Count != other.Count) + if (Count != divisor.Count) { - throw new ArgumentException(Resources.ArgumentVectorsSameLength, "other"); + throw new ArgumentException(Resources.ArgumentVectorsSameLength, "divisor"); } if (Count != result.Count) @@ -835,7 +835,7 @@ namespace MathNet.Numerics.LinearAlgebra.Generic throw new ArgumentException(Resources.ArgumentVectorsSameLength, "result"); } - DoPointwiseModulus(other, result); + DoPointwiseModulus(divisor, result); } /// diff --git a/src/Numerics/LinearAlgebra/Generic/Vector.Operators.cs b/src/Numerics/LinearAlgebra/Generic/Vector.Operators.cs index c551a6ea..275d397c 100644 --- a/src/Numerics/LinearAlgebra/Generic/Vector.Operators.cs +++ b/src/Numerics/LinearAlgebra/Generic/Vector.Operators.cs @@ -227,105 +227,105 @@ namespace MathNet.Numerics.LinearAlgebra.Generic /// /// Divides a scalar with a vector. /// - /// The scalar to divide. - /// The vector. + /// The scalar to divide. + /// The vector. /// The result of the division. - /// If is . - public static Vector operator /(T leftSide, Vector rightSide) + /// If is . + public static Vector operator /(T dividend, Vector divisor) { - if (rightSide == null) + if (divisor == null) { - throw new ArgumentNullException("rightSide"); + throw new ArgumentNullException("divisor"); } - return rightSide.DevideByThis(leftSide); + return divisor.DevideByThis(dividend); } /// /// Divides a vector with a scalar. /// - /// The vector to divide. - /// The scalar value. + /// The vector to divide. + /// The scalar value. /// The result of the division. - /// If is . - public static Vector operator /(Vector leftSide, T rightSide) + /// If is . + public static Vector operator /(Vector dividend, T divisor) { - if (leftSide == null) + if (dividend == null) { - throw new ArgumentNullException("leftSide"); + throw new ArgumentNullException("dividend"); } - return leftSide.Divide(rightSide); + return dividend.Divide(divisor); } /// /// Pointwise divides two Vectors. /// - /// The vector to divide. - /// The other vector. + /// The vector to divide. + /// The other vector. /// The result of the division. - /// If and are not the same size. - /// If is . - public static Vector operator /(Vector leftSide, Vector rightSide) + /// If and are not the same size. + /// If is . + public static Vector operator /(Vector dividend, Vector divisor) { - if (leftSide == null) + if (dividend == null) { - throw new ArgumentNullException("leftSide"); + throw new ArgumentNullException("dividend"); } - return leftSide.PointwiseDivide(rightSide); + return dividend.PointwiseDivide(divisor); } /// /// Computes the modulus of each element of the vector of the given divisor. /// - /// The vector whose elements we want to compute the modulus of. - /// The divisor to use. + /// The vector whose elements we want to compute the modulus of. + /// The divisor to use. /// The result of the calculation - /// If is . - public static Vector operator %(Vector leftSide, T rightSide) + /// If is . + public static Vector operator %(Vector dividend, T divisor) { - if (leftSide == null) + if (dividend == null) { - throw new ArgumentNullException("leftSide"); + throw new ArgumentNullException("dividend"); } - return leftSide.Modulus(rightSide); + return dividend.Modulus(divisor); } /// /// Computes the modulus of the given dividend of each element of the vector. /// - /// The dividend we want to compute the modulus of. - /// The vector whose elements we want to use as divisor. + /// The dividend we want to compute the modulus of. + /// The vector whose elements we want to use as divisor. /// The result of the calculation - /// If is . - public static Vector operator %(T leftSide, Vector rightSide) + /// If is . + public static Vector operator %(T dividend, Vector divisor) { - if (rightSide == null) + if (divisor == null) { - throw new ArgumentNullException("rightSide"); + throw new ArgumentNullException("divisor"); } - return rightSide.ModulusByThis(leftSide); + return divisor.ModulusByThis(dividend); } /// - /// Computes the pointwise modulus of each element of two vectors. + /// Computes the pointwise modulus of each element of two vectors. /// - /// The vector whose elements we want to compute the modulus of. - /// The divisor to use. + /// The vector whose elements we want to compute the modulus of. + /// The divisor to use. /// The result of the calculation - /// If and are not the same size. - /// If is . - public static Vector operator %(Vector leftSide, Vector rightSide) + /// If and are not the same size. + /// If is . + public static Vector operator %(Vector dividend, Vector divisor) { - if (leftSide == null) + if (dividend == null) { - throw new ArgumentNullException("leftSide"); + throw new ArgumentNullException("dividend"); } - return leftSide.PointwiseModulus(rightSide); + return dividend.PointwiseModulus(divisor); } [SpecialName] @@ -335,15 +335,15 @@ namespace MathNet.Numerics.LinearAlgebra.Generic } [SpecialName] - public static Vector op_DotDivide(Vector x, Vector y) + public static Vector op_DotDivide(Vector dividend, Vector divisor) { - return x.PointwiseDivide(y); + return dividend.PointwiseDivide(divisor); } [SpecialName] - public static Vector op_DotPercent(Vector x, Vector y) + public static Vector op_DotPercent(Vector dividend, Vector divisor) { - return x.PointwiseModulus(y); + return dividend.PointwiseModulus(divisor); } } } diff --git a/src/Numerics/LinearAlgebra/Single/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Single/DenseMatrix.cs index 41d074a6..9ec1f58b 100644 --- a/src/Numerics/LinearAlgebra/Single/DenseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Single/DenseMatrix.cs @@ -674,18 +674,18 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar to divide the matrix with. /// The matrix to store the result of the division. - protected override void DoDivide(float scalar, Matrix result) + protected override void DoDivide(float divisor, Matrix result) { var denseResult = result as DenseMatrix; if (denseResult == null) { - base.DoDivide(scalar, result); + base.DoDivide(divisor, result); } else { - Control.LinearAlgebraProvider.ScaleArray(1.0f/scalar, _values, denseResult._values); + Control.LinearAlgebraProvider.ScaleArray(1.0f/divisor, _values, denseResult._values); } } @@ -712,16 +712,16 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { - var denseOther = other as DenseMatrix; + var denseOther = divisor as DenseMatrix; var denseResult = result as DenseMatrix; if (denseOther == null || denseResult == null) { - base.DoPointwiseDivide(other, result); + base.DoPointwiseDivide(divisor, result); } else { @@ -758,6 +758,30 @@ namespace MathNet.Numerics.LinearAlgebra.Single }); } + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + protected override void DoModulusByThis(float dividend, Matrix result) + { + var denseResult = result as DenseMatrix; + if (denseResult == null) + { + base.DoModulusByThis(dividend, result); + return; + } + + CommonParallel.For(0, _values.Length, 4096, (a, b) => + { + var v = denseResult._values; + for (int i = a; i < b; i++) + { + v[i] = dividend%_values[i]; + } + }); + } + /// /// Computes the trace of this matrix. /// diff --git a/src/Numerics/LinearAlgebra/Single/DenseVector.cs b/src/Numerics/LinearAlgebra/Single/DenseVector.cs index abcbeabb..7186ace8 100644 --- a/src/Numerics/LinearAlgebra/Single/DenseVector.cs +++ b/src/Numerics/LinearAlgebra/Single/DenseVector.cs @@ -704,17 +704,17 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The vector to pointwise divide this one by. /// The vector to store the result of the pointwise division. /// - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { - var denseOther = other as DenseVector; + var denseOther = divisor as DenseVector; var denseResult = result as DenseVector; if (denseOther == null || denseResult == null) { - base.DoPointwiseDivide(other, result); + base.DoPointwiseDivide(divisor, result); } else { diff --git a/src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs b/src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs index 34886fdd..3be22b29 100644 --- a/src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs +++ b/src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs @@ -28,17 +28,18 @@ // OTHER DEALINGS IN THE SOFTWARE. // +using MathNet.Numerics.Distributions; +using MathNet.Numerics.LinearAlgebra.Generic; +using MathNet.Numerics.LinearAlgebra.Storage; +using MathNet.Numerics.Properties; +using MathNet.Numerics.Threading; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; + namespace MathNet.Numerics.LinearAlgebra.Single { - using Distributions; - using Generic; - using Properties; - using Storage; - using System; - using System.Collections.Generic; - using System.Diagnostics; - using System.Linq; - /// /// A matrix type for diagonal matrices. /// @@ -1044,28 +1045,49 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Computes the modulus for each element of the matrix. /// - /// The divisor to use. + /// The scalar denominator to use. /// Matrix to store the results in. protected override void DoModulus(float divisor, Matrix result) { - var denseResult = result as DiagonalMatrix; - - if (denseResult == null) + var diagonalResult = result as DiagonalMatrix; + if (diagonalResult == null) { base.DoModulus(divisor, result); + return; } - else - { - if (!ReferenceEquals(this, result)) - { - CopyTo(result); - } - for (var index = 0; index < _data.Length; index++) + CommonParallel.For(0, _data.Length, 4096, (a, b) => { - denseResult._data[index] %= divisor; - } + var r = diagonalResult._data; + for (var i = a; i < b; i++) + { + r[i] = _data[i]%divisor; + } + }); + } + + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + protected override void DoModulusByThis(float dividend, Matrix result) + { + var diagonalResult = result as DiagonalMatrix; + if (diagonalResult == null) + { + base.DoModulusByThis(dividend, result); + return; } + + CommonParallel.For(0, _data.Length, 4096, (a, b) => + { + var r = diagonalResult._data; + for (var i = a; i < b; i++) + { + r[i] = dividend%_data[i]; + } + }); } #region Static constructors for special matrices. diff --git a/src/Numerics/LinearAlgebra/Single/Matrix.cs b/src/Numerics/LinearAlgebra/Single/Matrix.cs index d101691c..fb4c4e96 100644 --- a/src/Numerics/LinearAlgebra/Single/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Single/Matrix.cs @@ -242,25 +242,25 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Divides each element of the matrix by a scalar and places results into the result matrix. /// - /// The scalar to divide the matrix with. + /// The scalar to divide the matrix with. /// The matrix to store the result of the division. - protected override void DoDivide(float scalar, Matrix result) + protected override void DoDivide(float divisor, Matrix result) { - DoMultiply(1.0f / scalar, result); + DoMultiply(1.0f / divisor, result); } /// /// Divides a scalar by each element of the matrix and stores the result in the result matrix. /// - /// The scalar to add. + /// The scalar to add. /// The matrix to store the result of the division. - protected override void DoDivideByThis(float scalar, Matrix result) + protected override void DoDivideByThis(float dividend, Matrix result) { for (var i = 0; i < RowCount; i++) { for (var j = 0; j < ColumnCount; j++) { - result.At(i, j, scalar / At(i, j)); + result.At(i, j, dividend / At(i, j)); } } } @@ -331,7 +331,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Computes the modulus for each element of the matrix. /// - /// The divisor to use. + /// The scalar denominator to use. /// Matrix to store the results in. protected override void DoModulus(float divisor, Matrix result) { @@ -344,6 +344,22 @@ namespace MathNet.Numerics.LinearAlgebra.Single } } + /// + /// Computes the modulus for each element of the matrix. + /// + /// The scalar numerator to use. + /// Matrix to store the results in. + protected override void DoModulusByThis(float dividend, Matrix result) + { + for (var row = 0; row < RowCount; row++) + { + for (var column = 0; column < ColumnCount; column++) + { + result.At(row, column, dividend % At(row, column)); + } + } + } + /// /// Negate each element of this matrix and place the results into the result matrix. /// @@ -384,7 +400,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single { for (var i = 0; i < RowCount; i++) { - result.At(i, j, At(i, j) * other.At(i, j)); + result.At(i, j, At(i, j)*other.At(i, j)); } } } @@ -392,15 +408,31 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) + { + for (var j = 0; j < ColumnCount; j++) + { + for (var i = 0; i < RowCount; i++) + { + result.At(i, j, At(i, j)/divisor.At(i, j)); + } + } + } + + /// + /// Pointwise modulus this matrix with another matrix and stores the result into the result matrix. + /// + /// The pointwise denominator matrix to use + /// The result of the modulus. + protected override void DoPointwiseModulus(Matrix divisor, Matrix result) { for (var j = 0; j < ColumnCount; j++) { for (var i = 0; i < RowCount; i++) { - result.At(i, j, At(i, j) / other.At(i, j)); + result.At(i, j, At(i, j)%divisor.At(i, j)); } } } diff --git a/src/Numerics/LinearAlgebra/Single/SparseMatrix.cs b/src/Numerics/LinearAlgebra/Single/SparseMatrix.cs index 28449551..a89cb811 100644 --- a/src/Numerics/LinearAlgebra/Single/SparseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Single/SparseMatrix.cs @@ -1044,9 +1044,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// - /// The matrix to pointwise divide this one by. + /// The matrix to pointwise divide this one by. /// The matrix to store the result of the pointwise division. - protected override void DoPointwiseDivide(Matrix other, Matrix result) + protected override void DoPointwiseDivide(Matrix divisor, Matrix result) { result.Clear(); @@ -1065,7 +1065,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single { if (values[j] != 0f) { - result.At(i, columnIndices[j], values[j]/other.At(i, columnIndices[j])); + result.At(i, columnIndices[j], values[j]/divisor.At(i, columnIndices[j])); } } } diff --git a/src/Numerics/LinearAlgebra/Single/SparseVector.cs b/src/Numerics/LinearAlgebra/Single/SparseVector.cs index 8415b269..33b10c2e 100644 --- a/src/Numerics/LinearAlgebra/Single/SparseVector.cs +++ b/src/Numerics/LinearAlgebra/Single/SparseVector.cs @@ -822,11 +822,11 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Pointwise multiplies this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise multiply with this one. + /// The vector to pointwise multiply with this one. /// The vector to store the result of the pointwise multiplication. - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { - if (ReferenceEquals(this, other)) + if (ReferenceEquals(this, divisor)) { for (var i = 0; i < _storage.ValueCount; i++) { @@ -838,7 +838,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single for (var i = 0; i < _storage.ValueCount; i++) { var index = _storage.Indices[i]; - result.At(index, _storage.Values[i] / other.At(index)); + result.At(index, _storage.Values[i] / divisor.At(index)); } } } diff --git a/src/Numerics/LinearAlgebra/Single/Vector.cs b/src/Numerics/LinearAlgebra/Single/Vector.cs index d7ea08fe..1199d759 100644 --- a/src/Numerics/LinearAlgebra/Single/Vector.cs +++ b/src/Numerics/LinearAlgebra/Single/Vector.cs @@ -134,27 +134,27 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Divides each element of the vector by a scalar and stores the result in the result vector. /// - /// + /// /// The scalar to divide with. /// /// /// The vector to store the result of the division. /// - protected override void DoDivide(float scalar, Vector result) + protected override void DoDivide(float divisor, Vector result) { - DoMultiply(1 / scalar, result); + DoMultiply(1 / divisor, result); } /// /// Divides a scalar by each element of the vector and stores the result in the result vector. /// - /// The scalar to divide. + /// The scalar to divide. /// The vector to store the result of the division. - protected override void DoDivideByThis(float scalar, Vector result) + protected override void DoDivideByThis(float dividend, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, scalar / At(index)); + result.At(index, dividend / At(index)); } } @@ -174,26 +174,26 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Pointwise divide this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise divide this one by. + /// The vector to pointwise divide this one by. /// The vector to store the result of the pointwise division. - protected override void DoPointwiseDivide(Vector other, Vector result) + protected override void DoPointwiseDivide(Vector divisor, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, At(index) / other.At(index)); + result.At(index, At(index) / divisor.At(index)); } } /// /// Pointwise modulus this vector with another vector and stores the result into the result vector. /// - /// The vector to pointwise modulus this one by. + /// The vector to pointwise modulus this one by. /// The result of the modulus. - protected override void DoPointwiseModulus(Vector other, Vector result) + protected override void DoPointwiseModulus(Vector divisor, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, At(index) % other.At(index)); + result.At(index, At(index) % divisor.At(index)); } } @@ -221,7 +221,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Computes the modulus for each element of the vector for the given divisor. /// - /// The divisor to use. + /// The scalar denominator to use. /// A vector to store the results in. protected override void DoModulus(float divisor, Vector result) { @@ -234,13 +234,13 @@ namespace MathNet.Numerics.LinearAlgebra.Single /// /// Computes the modulus for the given dividend for each element of the vector. /// - /// The dividend to use. + /// The scalar numerator to use. /// A vector to store the results in. - protected override void DoModulusByThis(float scalar, Vector result) + protected override void DoModulusByThis(float dividend, Vector result) { for (var index = 0; index < Count; index++) { - result.At(index, scalar % At(index)); + result.At(index, dividend%At(index)); } }