/// <summary> /// Divides all of the matrix elements by a double value. /// </summary> /// <param name="value">The double value.</param> /// <returns>The result matrix.</returns> protected virtual Matrix <T, C> divideByValue(Numeric <T, C> value) { Matrix <T, C> temp = this.Clone() as Matrix <T, C>; MatrixNumericHelper <T, C> .divValue(temp, value, temp); return(temp); }
/// <summary> /// Multiplies all of the matrix elements by a double value. /// </summary> /// <param name="value">The double value.</param> /// <returns>The result matrix.</returns> protected virtual Matrix <T, C> multiplyByValue(Numeric <T, C> value) { Matrix <T, C> temp = this.Clone() as Matrix <T, C>; MatrixNumericHelper <T, C> .mulValue(temp, value, temp); return(temp); }
// --------------------- // ------- ctors ------- // --------------------- internal MinorMatrix(Matrix <T, C> parent, int removedRow, int removedColumn) { this.Matrix_Type = MatrixNumericHelper <T, C> .getMatrixType(parent); this.RemovedRow = removedRow; this.RemovedColumn = removedColumn; this.rows = parent.RowCount - 1; this.columns = parent.ColumnCount - 1; this.Parent = parent; }
protected override Matrix <T, C> multiply(Matrix <T, C> another) { if (this.ColumnCount != another.RowCount) { throw new ArgumentException("The column count of the first matrix and the row count of the second matrix must match."); } Matrix <T, C> temp = MatrixNumericHelper <T, C> .getMatrixOfSize(Parent.Matrix_Type, this.rows, another.ColumnCount); MatrixNumericHelper <T, C> .multiplySimple(this, another, temp); return(temp); }
protected override Matrix <T, C> substract(Matrix <T, C> another) { if (this.rows != another.RowCount || this.columns != another.ColumnCount) { throw new ArgumentException("Matrices must be of the same size in order to substract."); } Matrix <T, C> temp = MatrixNumericHelper <T, C> .getMatrixOfSize(Parent.Matrix_Type, rows, columns); MatrixNumericHelper <T, C> .dif(this, another, temp); return(temp); }
protected override Matrix <T, C> negate() { Matrix <T, C> temp = MatrixNumericHelper <T, C> .getMatrixOfSize(Parent.Matrix_Type, rows, columns); for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { temp[i, j] = -this.getItemAt(i, j); } } return(temp); }
/// <summary> /// Returns the matrix that will be equal to the current matrix after the transposition. /// Performs memory allocation for the new matrix, so any changes made to it will not be reflected on the current matrix. /// </summary> /// <returns>Returns the matrix that will be equal to the current matrix after the transposition.</returns> public Matrix <T, C> transposedMatrixCopy() { Matrix <T, C> transposedMatrix = MatrixNumericHelper <T, C> .getMatrixOfSize(this.Matrix_Type, this.columns, this.rows); for (int i = 0; i < this.rows; i++) { for (int j = 0; j < this.columns; j++) { transposedMatrix.setItemAt(j, i, this.getItemAt(i, j)); } } return(transposedMatrix); }
/// <summary> /// Returns the minor matrix copy (independent from the current), /// which is made by removing the row with index <paramref name="rowToRemove"/> /// and the column with index <paramref name="columnToRemove"/>. /// </summary> /// <param name="rowToRemove">The index of the row to remove.</param> /// <param name="columnToRemove">The index of the column to remove.</param> /// <returns>The minor matrix copy (independent from the current).</returns> public Matrix <T, C> getMinorMatrixCopy(int rowToRemove, int columnToRemove) { checkPositive(rowToRemove, columnToRemove); checkBounds(rowToRemove + 1, columnToRemove + 1); Matrix <T, C> tmp = MatrixNumericHelper <T, C> .getMatrixOfSize(this.Matrix_Type, this.rows - 1, this.columns - 1); for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { int positionIndexRow = (i < rowToRemove ? i : (i > rowToRemove ? i - 1 : -1)); int positionIndexColumn = (j < columnToRemove ? j : (j > columnToRemove ? j - 1 : -1)); if (positionIndexColumn >= 0 && positionIndexRow >= 0) { tmp.setItemAt(positionIndexRow, positionIndexColumn, this.getItemAt(i, j)); } } } return(tmp); }