HODLROptions.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 HODLR_OPTIONS_HPP
#define HODLR_OPTIONS_HPP
 
#include "clustering/Clustering.hpp"
#include "structured/StructuredOptions.hpp"
 
namespace strumpack {
 
  namespace HODLR {
 
    template<typename real_t> inline real_t default_HODLR_rel_tol() {
      return real_t(1e-4);
    }
    template<typename real_t> inline real_t default_HODLR_abs_tol() {
      return real_t(1e-10);
    }
 
    template<> inline float default_HODLR_rel_tol() {
      return 1e-2;
    }
    template<> inline float default_HODLR_abs_tol() {
      return 1e-5;
    }
 
    enum class CompressionAlgorithm {
      RANDOM_SAMPLING,     
      ELEMENT_EXTRACTION   
    };
 
    std::string get_name(CompressionAlgorithm a);
 
    CompressionAlgorithm get_compression_algorithm(const std::string& c);
 
 
 
    template<typename scalar_t> class HODLROptions
      : public structured::StructuredOptions<scalar_t> {
 
    public:
      using real_t = typename RealType<scalar_t>::value_type;
 
      HODLROptions() :
        structured::StructuredOptions<scalar_t>(structured::Type::HODLR) {
        set_defaults();
      }
 
      HODLROptions(const structured::StructuredOptions<scalar_t>& sopts)
        : structured::StructuredOptions<scalar_t>(sopts) {
        this->type_ = structured::Type::HODLR;
      }
 
      void set_rank_guess(int rank_guess) {
        assert(rank_guess > 0);
        rank_guess_ = rank_guess;
      }
 
      void set_rank_rate(double rank_rate) {
        assert(rank_rate > 0);
        rank_rate_ = rank_rate;
      }
 
      void set_clustering_algorithm(ClusteringAlgorithm a) {
        clustering_algo_ = a;
      }
 
      void set_compression_algorithm(CompressionAlgorithm a) {
        compression_algo_ = a;
      }
 
      void set_butterfly_levels(int bfl) {
        assert(bfl >= 0);
        butterfly_levels_ = bfl;
      }
 
      void set_BACA_block_size(int BACA) {
        assert(BACA > 0);
        BACA_block_size_ = BACA;
      }
 
      void set_BF_sampling_parameter(double param) {
        assert(param > 0);
        BF_sampling_parameter_ = param;
      }
 
      void set_geo(int geo) {
        assert(geo == 0 || geo == 1 || geo == 2 || geo == 3);
        geo_ = geo;
      }
 
      void set_lr_leaf(int lr_leaf) {
        assert(lr_leaf == 1 || lr_leaf == 2 || lr_leaf == 3 ||
               lr_leaf == 4 || lr_leaf == 5);
        lr_leaf_ = lr_leaf;
      }
 
      void set_knn_hodlrbf(int k) {
        assert(k >= 0);
        knn_hodlrbf_ = k;
      }
 
      void set_knn_lrbf(int k) {
        assert(k >= 0);
        knn_lrbf_ = k;
      }
 
      void set_less_adapt(bool l) { less_adapt_ = l; }
 
      void set_BF_entry_n15(bool l) { BF_entry_n15_ = l; }
 
      int rank_guess() const { return rank_guess_; }
 
      double rank_rate() const { return rank_rate_; }
 
      ClusteringAlgorithm clustering_algorithm() const {
        return clustering_algo_;
      }
 
      CompressionAlgorithm compression_algorithm() const {
        return compression_algo_;
      }
 
      int butterfly_levels() const { return butterfly_levels_; }
 
      int BACA_block_size() const { return BACA_block_size_; }
 
      double BF_sampling_parameter() const { return BF_sampling_parameter_; }
 
      int geo() const { return geo_; }
 
      int lr_leaf() const { return lr_leaf_; }
 
      int knn_hodlrbf() const { return knn_hodlrbf_; }
 
      int knn_lrbf() const { return knn_lrbf_; }
 
      bool less_adapt() const { return less_adapt_; }
 
      bool BF_entry_n15() const { return BF_entry_n15_; }
 
      void set_from_command_line(int argc, const char* const* cargv) override;
 
      void describe_options() const override;
 
    private:
      int rank_guess_ = 128;
      double rank_rate_ = 2.;
      ClusteringAlgorithm clustering_algo_ = ClusteringAlgorithm::COBBLE;
      int butterfly_levels_ = 0;
      CompressionAlgorithm compression_algo_ = CompressionAlgorithm::ELEMENT_EXTRACTION;
      int BACA_block_size_ = 16;
      double BF_sampling_parameter_ = 1.2;
      int geo_ = 2;
      int lr_leaf_ = 5;
      int knn_hodlrbf_ = 64;
      int knn_lrbf_ = 128;
      bool less_adapt_ = true;
      bool BF_entry_n15_ = false;
 
      void set_defaults() {
        this->type_ = structured::Type::HODLR;
        this->rel_tol_ = default_HODLR_rel_tol<real_t>();
        this->abs_tol_ = default_HODLR_abs_tol<real_t>();
        this->leaf_size_ = 256;
        this->max_rank_ = 50000;
      }
 
    };
 
  } // end namespace HODLR
} // end namespace strumpack
 
 
#endif // HODLR_OPTIONS_HPP