public static Matrix Add(Matrix lhs, Matrix rhs) { Matrix result = new Matrix(lhs); result.Clear(); for (int row = 0; row < lhs.Rows; row++) { for (int col = 0; col < lhs.Cols; col++) { result[row, col] = CognitiveAdditionLogic(lhs[row, col], rhs[row, col]); } } return result; }
public static Matrix Multiply(Matrix lhs, Matrix rhs) { Matrix result = new Matrix(lhs); result.Clear(); for (int i = 0; i < lhs.Rows; i++) { for (int j = 0; j < rhs.Cols; j++) { double sum = 0; for (int k = 0; k < lhs.Rows; k++) { double product = CognitiveMultiplicationLogic(lhs[i, k], rhs[k, j]); sum = CognitiveAdditionLogic(sum, product); } result[i, j] = sum; } } return result; }
/// <summary> /// Multiplies each element of the matrix by a scalar and places results into the result matrix. /// </summary> /// <param name="scalar">The scalar to multiply the matrix with.</param> /// <param name="result">The matrix to store the result of the multiplication.</param> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> protected override void DoMultiply(Complex scalar, Matrix<Complex> result) { if (scalar == 0.0) { result.Clear(); return; } if (scalar == 1.0) { CopyTo(result); return; } var diagResult = result as DiagonalMatrix; if (diagResult == null) { base.DoMultiply(scalar, result); } else { if (!ReferenceEquals(this, result)) { CopyTo(diagResult); } Control.LinearAlgebraProvider.ScaleArray(scalar, _data, diagResult._data); } }
/// <summary> /// Puts the strictly upper triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void StrictlyUpperTriangle(Matrix<Complex> result) { if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw DimensionsDontMatch<ArgumentException>(this, result, "result"); } result.Clear(); }
/// <summary> /// Subtracts another matrix from this matrix. /// </summary> /// <param name="other">The matrix to subtract to this matrix.</param> /// <param name="result">The matrix to store the result of subtraction.</param> /// <exception cref="ArgumentNullException">If the other matrix is <see langword="null"/>.</exception> /// <exception cref="ArgumentOutOfRangeException">If the two matrices don't have the same dimensions.</exception> protected override void DoSubtract(Matrix<Complex> other, Matrix<Complex> result) { var sparseOther = other as SparseMatrix; var sparseResult = result as SparseMatrix; if (sparseOther == null || sparseResult == null) { base.DoSubtract(other, result); return; } if (ReferenceEquals(this, other)) { result.Clear(); return; } if (ReferenceEquals(this, sparseResult)) { for (var i = 0; i < sparseOther.RowCount; i++) { // Get the begin / end index for the current row var startIndex = sparseOther._rowIndex[i]; var endIndex = i < sparseOther._rowIndex.Length - 1 ? sparseOther._rowIndex[i + 1] : sparseOther.NonZerosCount; for (var j = startIndex; j < endIndex; j++) { var columnIndex = sparseOther._columnIndices[j]; var resVal = sparseResult.At(i, columnIndex) - sparseOther._nonZeroValues[j]; result.At(i, columnIndex, resVal); } } } else { if (!ReferenceEquals(sparseOther, sparseResult)) { sparseOther.CopyTo(sparseResult); } sparseResult.Negate(sparseResult); for (var i = 0; i < RowCount; i++) { // Get the begin / end index for the current row var startIndex = _rowIndex[i]; var endIndex = i < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount; for (var j = startIndex; j < endIndex; j++) { var columnIndex = _columnIndices[j]; var resVal = sparseResult.At(i, columnIndex) + _nonZeroValues[j]; result.At(i, columnIndex, resVal); } } } }
/// <summary> /// Multiplies each element of the matrix by a scalar and places results into the result matrix. /// </summary> /// <param name="scalar">The scalar to multiply the matrix with.</param> /// <param name="result">The matrix to store the result of the multiplication.</param> protected override void DoMultiply(Complex scalar, Matrix<Complex> result) { if (scalar == 1.0) { CopyTo(result); return; } if (scalar == 0.0 || NonZerosCount == 0) { result.Clear(); return; } var sparseResult = result as SparseMatrix; if (sparseResult == null) { result.Clear(); for (var row = 0; row < RowCount; row++) { var start = _rowIndex[row]; var end = _rowIndex[row + 1]; if (start == end) { continue; } for (var index = start; index < end; index++) { var column = _columnIndices[index]; result.At(row, column, _nonZeroValues[index] * scalar); } } } else { if (!ReferenceEquals(this, result)) { CopyTo(sparseResult); } CommonParallel.For(0, NonZerosCount, index => sparseResult._nonZeroValues[index] *= scalar); } }
/// <summary> /// Subtracts another matrix from this matrix. /// </summary> /// <param name="other">The matrix to subtract to this matrix.</param> /// <param name="result">The matrix to store the result of subtraction.</param> /// <exception cref="ArgumentNullException">If the other matrix is <see langword="null"/>.</exception> /// <exception cref="ArgumentOutOfRangeException">If the two matrices don't have the same dimensions.</exception> protected override void DoSubtract(Matrix<float> other, Matrix<float> result) { var sparseOther = other as SparseMatrix; var sparseResult = result as SparseMatrix; if (sparseOther == null || sparseResult == null) { base.DoSubtract(other, result); return; } if (ReferenceEquals(this, other)) { result.Clear(); return; } var otherStorage = sparseOther._storage; if (ReferenceEquals(this, sparseResult)) { for (var i = 0; i < otherStorage.RowCount; i++) { var endIndex = otherStorage.RowPointers[i + 1]; for (var j = otherStorage.RowPointers[i]; j < endIndex; j++) { var columnIndex = otherStorage.ColumnIndices[j]; var resVal = sparseResult.At(i, columnIndex) - otherStorage.Values[j]; result.At(i, columnIndex, resVal); } } } else { if (!ReferenceEquals(sparseOther, sparseResult)) { sparseOther.CopyTo(sparseResult); } sparseResult.Negate(sparseResult); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; for (var i = 0; i < RowCount; i++) { var endIndex = rowPointers[i + 1]; for (var j = rowPointers[i]; j < endIndex; j++) { var columnIndex = columnIndices[j]; var resVal = sparseResult.At(i, columnIndex) + values[j]; result.At(i, columnIndex, resVal); } } } }
/// <summary> /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// </summary> /// <param name="divisor">The matrix to pointwise divide this one by.</param> /// <param name="result">The matrix to store the result of the pointwise division.</param> protected override void DoPointwiseDivide(Matrix<float> divisor, Matrix<float> result) { result.Clear(); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; for (var i = 0; i < RowCount; i++) { var endIndex = rowPointers[i + 1]; for (var j = rowPointers[i]; j < endIndex; j++) { if (values[j] != 0f) { result.At(i, columnIndices[j], values[j]/divisor.At(i, columnIndices[j])); } } } }
/// <summary> /// Pointwise divide this matrix by another matrix and stores the result into the result matrix. /// </summary> /// <param name="other">The matrix to pointwise divide this one by.</param> /// <param name="result">The matrix to store the result of the pointwise division.</param> protected override void DoPointwiseDivide(Matrix<float> other, Matrix<float> result) { result.Clear(); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; var valueCount = _storage.ValueCount; for (var i = 0; i < RowCount; i++) { // Get the begin / end index for the current row var startIndex = rowPointers[i]; var endIndex = i < rowPointers.Length - 1 ? rowPointers[i + 1] : valueCount; for (var j = startIndex; j < endIndex; j++) { if (values[j] != 0f) { result.At(i, columnIndices[j], values[j]/other.At(i, columnIndices[j])); } } } }
/// <summary> /// Multiplies this matrix with another matrix and places the results into the result matrix. /// </summary> /// <param name="other">The matrix to multiply with.</param> /// <param name="result">The result of the multiplication.</param> protected override void DoMultiply(Matrix<Complex32> other, Matrix<Complex32> result) { var sparseOther = other as SparseMatrix; var sparseResult = result as SparseMatrix; if (sparseOther != null && sparseResult != null) { DoMultiplySparse(sparseOther, sparseResult); return; } var diagonalOther = other.Storage as DiagonalMatrixStorage<Complex32>; if (diagonalOther != null && sparseResult != null) { var diagonal = diagonalOther.Data; if (other.ColumnCount == other.RowCount) { Storage.MapIndexedTo(result.Storage, (i, j, x) => x*diagonal[j], Zeros.AllowSkip, ExistingData.Clear); } else { result.Storage.Clear(); Storage.MapSubMatrixIndexedTo(result.Storage, (i, j, x) => x*diagonal[j], 0, 0, RowCount, 0, 0, ColumnCount, Zeros.AllowSkip, ExistingData.AssumeZeros); } return; } result.Clear(); var columnVector = new DenseVector(other.RowCount); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; for (var row = 0; row < RowCount; row++) { var startIndex = rowPointers[row]; var endIndex = rowPointers[row + 1]; if (startIndex == endIndex) { continue; } for (var column = 0; column < other.ColumnCount; column++) { // Multiply row of matrix A on column of matrix B other.Column(column, columnVector); var sum = Complex32.Zero; for (var index = startIndex; index < endIndex; index++) { sum += values[index] * columnVector[columnIndices[index]]; } result.At(row, column, sum); } } }
/// <summary> /// Puts the upper triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void UpperTriangle(Matrix<Complex32> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw new ArgumentException(Resources.ArgumentMatrixDimensions, "result"); } if (ReferenceEquals(this, result)) { var tmp = result.CreateMatrix(result.RowCount, result.ColumnCount); UpperTriangle(tmp); tmp.CopyTo(result); } else { result.Clear(); UpperTriangleImpl(result); } }
/// <summary> /// Multiplies this matrix with another matrix and places the results into the result matrix. /// </summary> /// <param name="other">The matrix to multiply with.</param> /// <param name="result">The result of the multiplication.</param> protected override void DoMultiply(Matrix<Complex32> other, Matrix<Complex32> result) { result.Clear(); var columnVector = new DenseVector(other.RowCount); for (var row = 0; row < RowCount; row++) { // Get the begin / end index for the current row var startIndex = _rowIndex[row]; var endIndex = row < _rowIndex.Length - 1 ? _rowIndex[row + 1] : NonZerosCount; if (startIndex == endIndex) { continue; } for (var column = 0; column < other.ColumnCount; column++) { // Multiply row of matrix A on column of matrix B other.Column(column, columnVector); var sum = Complex32.Zero; for (var index = startIndex; index < endIndex; index++) { sum += _nonZeroValues[index] * columnVector[_columnIndices[index]]; } result.At(row, column, sum); } } }
/// <summary> /// Puts the upper triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void UpperTriangle(Matrix<float> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw new ArgumentException(Resources.ArgumentMatrixDimensions, "result"); } result.Clear(); for (var i = 0; i < Data.Length; i++) { result[i, i] = Data[i]; } }
/// <summary> /// Puts the upper triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void UpperTriangle(Matrix<float> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw DimensionsDontMatch<ArgumentException>(this, result, "result"); } result.Clear(); for (var i = 0; i < _data.Length; i++) { result[i, i] = _data[i]; } }
/// <summary> /// Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. /// </summary> /// <param name="other">The matrix to pointwise multiply with this one.</param> /// <param name="result">The matrix to store the result of the pointwise multiplication.</param> protected override void DoPointwiseMultiply(Matrix<Complex> other, Matrix<Complex> result) { result.Clear(); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; var valueCount = _storage.ValueCount; for (var i = 0; i < RowCount; i++) { // Get the begin / end index for the current row var startIndex = rowPointers[i]; var endIndex = i < rowPointers.Length - 1 ? rowPointers[i + 1] : valueCount; for (var j = startIndex; j < endIndex; j++) { var resVal = values[j]*other.At(i, columnIndices[j]); if (!resVal.IsZero()) { result.At(i, columnIndices[j], resVal); } } } }
/// <summary> /// Multiplies each element of the matrix by a scalar and places results into the result matrix. /// </summary> /// <param name="scalar">The scalar to multiply the matrix with.</param> /// <param name="result">The matrix to store the result of the multiplication.</param> protected override void DoMultiply(float scalar, Matrix<float> result) { if (scalar == 1.0) { CopyTo(result); return; } if (scalar == 0.0 || NonZerosCount == 0) { result.Clear(); return; } var sparseResult = result as SparseMatrix; if (sparseResult == null) { result.Clear(); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; for (var row = 0; row < RowCount; row++) { var start = rowPointers[row]; var end = rowPointers[row + 1]; if (start == end) { continue; } for (var index = start; index < end; index++) { var column = columnIndices[index]; result.At(row, column, values[index] * scalar); } } } else { if (!ReferenceEquals(this, result)) { CopyTo(sparseResult); } Control.LinearAlgebraProvider.ScaleArray(scalar, sparseResult._storage.Values, sparseResult._storage.Values); } }
/// <summary> /// Multiplies this matrix with another matrix and places the results into the result matrix. /// </summary> /// <param name="other">The matrix to multiply with.</param> /// <param name="result">The result of the multiplication.</param> protected override void DoMultiply(Matrix<float> other, Matrix<float> result) { result.Clear(); var columnVector = new DenseVector(other.RowCount); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; for (var row = 0; row < RowCount; row++) { var startIndex = rowPointers[row]; var endIndex = rowPointers[row + 1]; if (startIndex == endIndex) { continue; } for (var column = 0; column < other.ColumnCount; column++) { // Multiply row of matrix A on column of matrix B other.Column(column, columnVector); var sum = 0f; for (var index = startIndex; index < endIndex; index++) { sum += values[index] * columnVector[columnIndices[index]]; } result.At(row, column, sum); } } }
/// <summary> /// Stacks this matrix on top of the given matrix and places the result into the result <see cref="SparseMatrix"/>. /// </summary> /// <param name="lower">The matrix to stack this matrix upon.</param> /// <param name="result">The combined <see cref="SparseMatrix"/>.</param> /// <exception cref="ArgumentNullException">If lower is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If <strong>upper.Columns != lower.Columns</strong>.</exception> public override void Stack(Matrix<Complex32> lower, Matrix<Complex32> result) { if (lower == null) { throw new ArgumentNullException("lower"); } if (lower.ColumnCount != ColumnCount) { throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension, "lower"); } if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != (RowCount + lower.RowCount) || result.ColumnCount != ColumnCount) { throw new ArgumentException(Resources.ArgumentMatrixDimensions, "result"); } // Clear the result matrix result.Clear(); // Copy the diagonal part into the result matrix. for (var i = 0; i < Data.Length; i++) { result[i, i] = Data[i]; } // Copy the lower matrix into the result matrix. for (var i = 0; i < lower.RowCount; i++) { for (var j = 0; j < lower.ColumnCount; j++) { result[i + RowCount, j] = lower[i, j]; } } }
/// <summary> /// Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. /// </summary> /// <param name="other">The matrix to pointwise multiply with this one.</param> /// <param name="result">The matrix to store the result of the pointwise multiplication.</param> protected override void DoPointwiseMultiply(Matrix<float> other, Matrix<float> result) { result.Clear(); var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; for (var i = 0; i < RowCount; i++) { var endIndex = rowPointers[i + 1]; for (var j = rowPointers[i]; j < endIndex; j++) { var resVal = values[j]*other.At(i, columnIndices[j]); if (resVal != 0f) { result.At(i, columnIndices[j], resVal); } } } }
/// <summary> /// Puts the strictly upper triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void StrictlyUpperTriangle(Matrix<Complex32> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw new ArgumentException(Resources.ArgumentMatrixDimensions, "result"); } result.Clear(); }
/// <summary> /// Puts the upper triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void UpperTriangle(Matrix<float> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw DimensionsDontMatch<ArgumentException>(this, result, "result"); } if (ReferenceEquals(this, result)) { var tmp = Build.SameAs(result); UpperTriangle(tmp); tmp.CopyTo(result); } else { result.Clear(); UpperTriangleImpl(result); } }
/// <summary> /// Concatenates this matrix with the given matrix and places the result into the result <see cref="SparseMatrix"/>. /// </summary> /// <param name="right">The matrix to concatenate.</param> /// <param name="result">The combined <see cref="SparseMatrix"/>.</param> public override void Append(Matrix<Complex32> right, Matrix<Complex32> result) { if (right == null) { throw new ArgumentNullException("right"); } if (right.RowCount != RowCount) { throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension); } if (result == null) { throw new ArgumentNullException("result"); } if (result.ColumnCount != (ColumnCount + right.ColumnCount) || result.RowCount != RowCount) { throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); } // Clear the result matrix result.Clear(); // Copy the diagonal part into the result matrix. for (var i = 0; i < Data.Length; i++) { result[i, i] = Data[i]; } // Copy the lower matrix into the result matrix. for (var i = 0; i < right.RowCount; i++) { for (var j = 0; j < right.ColumnCount; j++) { result[i, j + RowCount] = right[i, j]; } } }
/// <summary> /// Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. /// </summary> /// <param name="other">The matrix to pointwise multiply with this one.</param> /// <param name="result">The matrix to store the result of the pointwise multiplication.</param> protected override void DoPointwiseMultiply(Matrix<Complex> other, Matrix<Complex> result) { result.Clear(); for (var i = 0; i < other.RowCount; i++) { // Get the begin / end index for the current row var startIndex = _rowIndex[i]; var endIndex = i < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount; for (var j = startIndex; j < endIndex; j++) { var resVal = _nonZeroValues[j] * other.At(i, _columnIndices[j]); if (resVal != 0.0) { result.At(i, _columnIndices[j], resVal); } } } }
/// <summary> /// Diagonally stacks his matrix on top of the given matrix and places the combined matrix into the result matrix. /// </summary> /// <param name="lower">The lower, right matrix.</param> /// <param name="result">The combined matrix</param> /// <exception cref="ArgumentNullException">If lower is <see langword="null" />.</exception> /// <exception cref="ArgumentNullException">If the result matrix is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not (this.Rows + lower.rows) x (this.Columns + lower.Columns).</exception> public override void DiagonalStack(Matrix<Complex32> lower, Matrix<Complex32> result) { if (lower == null) { throw new ArgumentNullException("lower"); } if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount + lower.RowCount || result.ColumnCount != ColumnCount + lower.ColumnCount) { throw new ArgumentException(Resources.ArgumentMatrixDimensions, "result"); } // Clear the result matrix result.Clear(); // Copy the diagonal part into the result matrix. for (var i = 0; i < Data.Length; i++) { result[i, i] = Data[i]; } // Copy the lower matrix into the result matrix. CommonParallel.For(0, lower.RowCount, i => CommonParallel.For(0, lower.ColumnCount, j => result.At(i + RowCount, j + ColumnCount, lower.At(i, j)))); }
/// <summary> /// Puts the strictly lower triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void StrictlyLowerTriangle(Matrix<Complex> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw DimensionsDontMatch<ArgumentException>(this, result); } if (ReferenceEquals(this, result)) { var tmp = result.CreateMatrix(result.RowCount, result.ColumnCount); StrictlyLowerTriangle(tmp); tmp.CopyTo(result); } else { result.Clear(); StrictlyLowerTriangleImpl(result); } }
/// <summary> /// Puts the lower triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void LowerTriangle(Matrix<Complex32> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw new ArgumentException(Resources.ArgumentMatrixDimensions, "result"); } if (ReferenceEquals(this, result)) { return; } result.Clear(); for (var i = 0; i < Data.Length; i++) { result[i, i] = Data[i]; } }
/// <summary> /// Puts the upper triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void UpperTriangle(Matrix<Complex> result) { if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw DimensionsDontMatch<ArgumentException>(this, result, "result"); } result.Clear(); for (var i = 0; i < _data.Length; i++) { result.At(i, i, _data[i]); } }
/// <summary> /// Puts the lower triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void LowerTriangle(Matrix<float> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw DimensionsDontMatch<ArgumentException>(this, result, "result"); } if (ReferenceEquals(this, result)) { return; } result.Clear(); for (var i = 0; i < _data.Length; i++) { result.At(i, i, _data[i]); } }
/// <summary> /// Negate each element of this matrix and place the results into the result matrix. /// </summary> /// <param name="result">The result of the negation.</param> protected override void DoNegate(Matrix<Complex> result) { var diagResult = result as DiagonalMatrix; if (diagResult != null) { Control.LinearAlgebraProvider.ScaleArray(-1, _data, diagResult._data); return; } result.Clear(); for (var i = 0; i < _data.Length; i++) { result.At(i, i, -_data[i]); } }
/// <summary> /// Puts the strictly upper triangle of this matrix into the result matrix. /// </summary> /// <param name="result">Where to store the lower triangle.</param> /// <exception cref="ArgumentNullException">If <paramref name="result"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception> public override void StrictlyUpperTriangle(Matrix<float> result) { if (result == null) { throw new ArgumentNullException("result"); } if (result.RowCount != RowCount || result.ColumnCount != ColumnCount) { throw DimensionsDontMatch<ArgumentException>(this, result, "result"); } result.Clear(); }