StructuredMatrix.hpp

Go to the documentation of this file.

/*
 * STRUMPACK -- STRUctured Matrices PACKage, Copyright (c) 2014, The
 * Regents of the University of California, through Lawrence Berkeley
 * National Laboratory (subject to receipt of any required approvals
 * from the U.S. Dept. of Energy).  All rights reserved.
 *
 * If you have questions about your rights to use or distribute this
 * software, please contact Berkeley Lab's Technology Transfer
 * Department at TTD@lbl.gov.
 *
 * NOTICE. This software is owned by the U.S. Department of Energy. As
 * such, the U.S. Government has been granted for itself and others
 * acting on its behalf a paid-up, nonexclusive, irrevocable,
 * worldwide license in the Software to reproduce, prepare derivative
 * works, and perform publicly and display publicly.  Beginning five
 * (5) years after the date permission to assert copyright is obtained
 * from the U.S. Department of Energy, and subject to any subsequent
 * five (5) year renewals, the U.S. Government is granted for itself
 * and others acting on its behalf a paid-up, nonexclusive,
 * irrevocable, worldwide license in the Software to reproduce,
 * prepare derivative works, distribute copies to the public, perform
 * publicly and display publicly, and to permit others to do so.
 *
 * Developers: Pieter Ghysels, Francois-Henry Rouet, Xiaoye S. Li.
 *             (Lawrence Berkeley National Lab, Computational Research
 *             Division).
 *
 */
#ifndef STRUCTURED_MATRIX_HPP
#define STRUCTURED_MATRIX_HPP
 
#include <vector>
#include <cassert>
#include <memory>
#include <functional>
#include <algorithm>
 
#include "StructuredOptions.hpp"
#include "ClusterTree.hpp"
#include "dense/DenseMatrix.hpp"
#if defined(STRUMPACK_USE_MPI)
#include "dense/DistributedMatrix.hpp"
#endif
 
namespace strumpack {
 
  namespace structured {
 
 
    template<typename scalar_t>
    using extract_t = std::function
      <scalar_t(std::size_t i, std::size_t j)>;
 
    template<typename scalar_t>
    using extract_block_t = std::function
      <void(const std::vector<std::size_t>& I,
            const std::vector<std::size_t>& J,
            DenseMatrix<scalar_t>& B)>;
 
    template<typename scalar_t>
    using mult_t = std::function
      <void(Trans op,
            const DenseMatrix<scalar_t>& R,
            DenseMatrix<scalar_t>& S)>;
 
#if defined(STRUMPACK_USE_MPI)
    template<typename scalar_t>
    using extract_dist_block_t = std::function
      <void(const std::vector<std::size_t>& I,
            const std::vector<std::size_t>& J,
            DistributedMatrix<scalar_t>& B)>;
 
    template<typename scalar_t>
    using mult_2d_t = std::function
      <void(Trans op,
            const DistributedMatrix<scalar_t>& R,
            DistributedMatrix<scalar_t>& S)>;
 
    template<typename scalar_t>
    using mult_1d_t = std::function
      <void(Trans op,
            const DenseMatrix<scalar_t>& R,
            DenseMatrix<scalar_t>& S,
            const std::vector<int>& rdist,
            const std::vector<int>& cdist)>;
#endif
 
    using admissibility_t = DenseMatrix<bool>;
 
 
 
    template<typename scalar_t> class StructuredMatrix {
      using real_t = typename RealType<scalar_t>::value_type;
 
    public:
 
      virtual ~StructuredMatrix() = default;
 
      virtual std::size_t rows() const = 0;
 
      virtual std::size_t cols() const = 0;
 
      virtual std::size_t memory() const = 0;
 
      virtual std::size_t nonzeros() const = 0;
 
      virtual std::size_t rank() const = 0;
 
      virtual std::size_t local_rows() const {
        throw std::invalid_argument
          ("1d block row distribution not supported for this format.");
      }
 
      virtual std::size_t begin_row() const {
        throw std::invalid_argument
          ("1d block row distribution not supported for this format.");
      }
 
      virtual std::size_t end_row() const {
        throw std::invalid_argument
          ("1d block row distribution not supported for this format.");
      }
 
      virtual const std::vector<int>& dist() const {
        static std::vector<int> d = {0, int(rows())};
        return d;
      };
      virtual const std::vector<int>& rdist() const {
        return dist();
      };
      virtual const std::vector<int>& cdist() const {
        return dist();
      };
 
      virtual void mult(Trans op, const DenseMatrix<scalar_t>& x,
                        DenseMatrix<scalar_t>& y) const;
 
      void mult(Trans op, int m, const scalar_t* x, int ldx,
                scalar_t* y, int ldy) const;
 
#if defined(STRUMPACK_USE_MPI)
      virtual void mult(Trans op, const DistributedMatrix<scalar_t>& x,
                        DistributedMatrix<scalar_t>& y) const;
#endif
 
      virtual void factor();
 
      virtual void solve(DenseMatrix<scalar_t>& b) const;
 
      virtual void solve(int nrhs, scalar_t* b, int ldb) const {
        int lr = rows();
        try { lr = local_rows(); }
        catch(...) {}
        DenseMatrixWrapper<scalar_t> B(lr, nrhs, b, ldb);
        solve(B);
      }
 
#if defined(STRUMPACK_USE_MPI)
      virtual void solve(DistributedMatrix<scalar_t>& b) const;
#endif
 
      virtual void shift(scalar_t s);
 
    };
 
 
    template<typename scalar_t>
    std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_from_dense(const DenseMatrix<scalar_t>& A,
                         const StructuredOptions<scalar_t>& opts,
                         const structured::ClusterTree* row_tree=nullptr,
                         const structured::ClusterTree* col_tree=nullptr,
                         const admissibility_t* adm=nullptr);
 
    template<typename scalar_t>
    std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_from_dense(int rows, int cols, const scalar_t* A, int ldA,
                         const StructuredOptions<scalar_t>& opts,
                         const structured::ClusterTree* row_tree=nullptr,
                         const structured::ClusterTree* col_tree=nullptr,
                         const admissibility_t* adm=nullptr);
 
    template<typename scalar_t,
             typename real_t = typename RealType<scalar_t>::value_type>
    std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_from_elements(int rows, int cols,
                            const extract_t<scalar_t>& A,
                            const StructuredOptions<scalar_t>& opts,
                            const structured::ClusterTree* row_tree=nullptr,
                            const structured::ClusterTree* col_tree=nullptr,
                            const admissibility_t* adm=nullptr,
                            const DenseMatrix<real_t>* p=nullptr);
 
 
    template<typename scalar_t,
             typename real_t = typename RealType<scalar_t>::value_type>
    std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_from_elements(int rows, int cols,
                            const extract_block_t<scalar_t>& A,
                            const StructuredOptions<scalar_t>& opts,
                            const structured::ClusterTree* row_tree=nullptr,
                            const structured::ClusterTree* col_tree=nullptr,
                            const admissibility_t* adm=nullptr,
                            const DenseMatrix<real_t>* p=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_and_factor_from_dense(const DenseMatrix<scalar_t>& A,
                                    const StructuredOptions<scalar_t>& opts,
                                    const structured::ClusterTree* row_tree=nullptr,
                                    const structured::ClusterTree* col_tree=nullptr,
                                    const admissibility_t* adm=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_and_factor_from_elements(int rows, int cols,
                                       const extract_t<scalar_t>& A,
                                       const StructuredOptions<scalar_t>& opts,
                                       const structured::ClusterTree* row_tree=nullptr,
                                       const structured::ClusterTree* col_tree=nullptr,
                                       const admissibility_t* adm=nullptr);
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_and_factor_from_elements(int rows, int cols,
                                       const extract_block_t<scalar_t>& A,
                                       const StructuredOptions<scalar_t>& opts,
                                       const structured::ClusterTree* row_tree=nullptr,
                                       const structured::ClusterTree* col_tree=nullptr,
                                       const admissibility_t* adm=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_matrix_free(int rows, int cols,
                          const mult_t<scalar_t>& Amult,
                          const StructuredOptions<scalar_t>& opts,
                          const structured::ClusterTree* row_tree=nullptr,
                          const structured::ClusterTree* col_tree=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_partially_matrix_free(int rows, int cols,
                                    const mult_t<scalar_t>& Amult,
                                    const extract_block_t<scalar_t>& Aelem,
                                    const StructuredOptions<scalar_t>& opts,
                                    const structured::ClusterTree* row_tree=nullptr,
                                    const structured::ClusterTree* col_tree=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_partially_matrix_free(int rows, int cols,
                                    const mult_t<scalar_t>& Amult,
                                    const extract_t<scalar_t>& Aelem,
                                    const StructuredOptions<scalar_t>& opts,
                                    const structured::ClusterTree* row_tree=nullptr,
                                    const structured::ClusterTree* col_tree=nullptr);
 
 
#if defined(STRUMPACK_USE_MPI)
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_from_dense(const DistributedMatrix<scalar_t>& A,
                         const StructuredOptions<scalar_t>& opts,
                         const structured::ClusterTree* row_tree=nullptr,
                         const structured::ClusterTree* col_tree=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_from_elements(const MPIComm& comm, const BLACSGrid* grid,
                            int rows, int cols,
                            const extract_t<scalar_t>& A,
                            const StructuredOptions<scalar_t>& opts,
                            const structured::ClusterTree* row_tree=nullptr,
                            const structured::ClusterTree* col_tree=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_from_elements(const MPIComm& comm, const BLACSGrid* grid,
                            int rows, int cols,
                            const extract_dist_block_t<scalar_t>& A,
                            const StructuredOptions<scalar_t>& opts,
                            const structured::ClusterTree* row_tree=nullptr,
                            const structured::ClusterTree* col_tree=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_matrix_free(const MPIComm& comm, const BLACSGrid* g,
                          int rows, int cols,
                          const mult_2d_t<scalar_t>& Amult,
                          const StructuredOptions<scalar_t>& opts,
                          const structured::ClusterTree* row_tree=nullptr,
                          const structured::ClusterTree* col_tree=nullptr);
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_matrix_free(const MPIComm& comm, int rows, int cols,
                          const mult_1d_t<scalar_t>& Amult,
                          const StructuredOptions<scalar_t>& opts,
                          const structured::ClusterTree* row_tree=nullptr,
                          const structured::ClusterTree* col_tree=nullptr);
 
 
    template<typename scalar_t> std::unique_ptr<StructuredMatrix<scalar_t>>
    construct_partially_matrix_free(const BLACSGrid* grid, int rows, int cols,
                                    const mult_2d_t<scalar_t>& Amult,
                                    const extract_dist_block_t<scalar_t>& Aelem,
                                    const StructuredOptions<scalar_t>& opts,
                                    const structured::ClusterTree* row_tree=nullptr,
                                    const structured::ClusterTree* col_tree=nullptr);
 
#endif
 
  } // end namespace structured
} // end namespace strumpack
 
#endif // STRUCTURED_MATRIX_HPP