/** * 13. * @brief Copy the contents of a matrix. * @param[out] A A is overwritten with B. * @param[in] B The matrix to be copied. */ static void copy (matrix_type &A, const matrix_type &B) { /** Result matrices should always be of the right size */ A.Resize (B.Height(), B.Width()); /** This one is pretty simple, but the order is different */ elem::Copy (B, A); }
/** * 6. * @brief Compute the matrix transpose. * @param[in] A The matrix to be transposed. * @param[out] B B is overwritten with A^{T} */ static void transpose (const matrix_type& A, matrix_type& B) { /** Result matrices should always have sufficient space */ B.Resize(A.Width(), A.Height()); /** Compute transpose */ elem::Transpose (A, B); }
/** * 5. * @brief Multiply one matrix with another. * @param[in] A The first matrix * @param[in] B The second matrix * @param[out] C C is overwritten with (A*B) */ static void multiply (const matrix_type& A, const matrix_type& B, matrix_type& C) { /** Result matrices should always have sufficient space */ C.Resize(A.Height(), B.Width()); /** We have to do a Gemm */ elem::Gemm (elem::NORMAL, elem::NORMAL, 1.0, A, B, 0.0, C); }
/** * 7. * @brief Compute element-wise negation of a matrix. * @param[in] A The matrix to be negated. * @param[out] B B is overwritten with -1.0*A */ static void negation (const matrix_type& A, matrix_type& B) { /** Result matrices should always have sufficient space */ B.Resize(A.Height(), A.Width()); /** Copy over the matrix */ elem::Copy (A, B); /** Multiply by -1.0 */ elem::Scal(-1.0, B); }
/** * 4. * @brief Subtract one matrix from another. * @param[in] A The first matrix * @param[in] B The second matrix * @param[out] C C is overwritten with (A-B) */ static void minus (const matrix_type& A, const matrix_type& B, matrix_type& C) { /** Result matrices should always have sufficient space */ C.Resize(A.Height(), A.Width()); /** first copy the matrix over */ elem::Copy (A, C); /** now, subtract the other matrix in */ elem::Axpy (-1.0, B, C); }
/** * 17. * @brief Multiply one scalar with matrix. * @param[in] A The matrix. * @param[in] a The scalar. * @param[out] B B is overwritten with (A*B). */ static void multiply(const matrix_type& A, const value_type& a, matrix_type& B) { /** Result matrices should always be of the right size */ B.Resize(A.Height(), A.Width()); /** Get the matrix dimensions. */ const int m = A.Height(); const int n = A.Width(); /** Simple scalar-matrix product. */ for (int i=0; i<m; ++i) for (int j=0; j<n; ++j) B.Set(i, j, (a*A.Get(i, j))); }
/** * 16. * @brief Compute the element-wise product of two matrices. * @param[in] A the first matrix. * @param[in] B the second matrix. * @param[out] C the result, which contains A.*B. */ static void elementwiseProduct(const matrix_type& A, const matrix_type& B, matrix_type& C) { /** Result matrices should always be of the right size */ C.Resize (A.Height(), A.Width()); /* Get the matrix dimensions */ const int m = A.Height(); const int n = A.Width(); /* Simple element-wise product */ for (int i=0; i<m; ++i) for (int j=0; j<n; ++j) C.Set(i, j, (A.Get(i,j)*B.Get(i,j))); }