C++ matrix_type::Height方法代码示例

  /**
   * 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)));
  }

  /** 
   * 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);
  }

  /** 
   * 8. 
   * @brief Compute the inverse of a matrix.
   * @param[in] A The (non-singular and square) matrix to be inverted.
   * @param[out] B B is overwritten with A's inverse.
   */
  static void inv(const matrix_type& A,
                  matrix_type& B) {

    /** Assume that the matrix has an inverse */
    const int n = A.Height();

    /** First, copy over an identity as the right hand side */
    B = eye(n);

    /** Solve the linear system using LU */
    elem::lu::SolveAfter(elem::NORMAL, A, B);
  }

  /** 
   * 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);
  }

    /**
     * Apply rowwise the sketching transform that is described by the
     * the transform with output sketch_of_A.
     */
    void apply (const matrix_type& A,
                output_matrix_type& sketch_of_A,
                rowwise_tag dimension) const {

        const value_type *a = A.LockedBuffer();
        El::Int lda = A.LDim();
        value_type *sa = sketch_of_A.Buffer();
        El::Int ldsa = sketch_of_A.LDim();

        for (El::Int j = 0; j < data_type::_S; j++)
            for (El::Int i = 0; i < A.Height(); i++)
                sa[j * ldsa + i] = a[data_type::_samples[j] * lda + i];
    }

    void apply_impl_vdist(const matrix_type& A,
                         output_matrix_type& sketch_of_A,
                         skylark::sketch::rowwise_tag tag) const {


        matrix_type sketch_of_A_STAR_RD(A.Height(),
                             data_type::_S);

        dense_transform_t<matrix_type, matrix_type, ValuesAccessor>
            transform(*this);

        transform.apply(A, sketch_of_A_STAR_RD, tag);

        sketch_of_A = sketch_of_A_STAR_RD;
    }

 /**
  * 1. 
  * @brief A function to return the number of rows in a matrix
  * @param[in] A The matrix for which we need the number of rows.
  * @return number of rows in A
  */
 static int getNumRows (const matrix_type& A) { return A.Height(); }

  /** 
   * 9. 
   * @brief Compute the trace of a matrix.
   * @param[in] A The (square) matrix whose trace is to be computed.
   * @return Trace of A
   */
  static value_type trace(const matrix_type& A) {
    value_type traceVal = 0.0;
    for (int i=0; i<A.Height(); ++i) traceVal += A.Get(i,i);

    return traceVal;
  }