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

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

  /** 
   * 15. 
   * @brief Extract the diagonal elements of a matrix.
   * @param[in] A The (square) matrix whose diagonal is to be extracted.
   * @param[out] B A diagonal matrix containing entries from A.
   */
  static void diag(const matrix_type& A,
                   matrix_type& B) {
    /* create a zeros matrix of the right dimension and assign to B */
    const int n = A.Width();
    B = zeros(n, n);

    /* Set the diagonals of B */
    for (int i=0; i<n; ++i) B.Set(i, i, A.Get(i,i));
  }

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

  /** 
   * 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 columnwise 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,
                columnwise_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 < A.Width(); j++)
            for (El::Int i = 0; i < data_type::_S; i++)
                sa[j * ldsa + i] = a[j * lda + data_type::_samples[i]];
    }

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

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

        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;
    }

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