HSSOptions.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 HSS_OPTIONS_HPP
#define HSS_OPTIONS_HPP
 
#include "clustering/Clustering.hpp"
 
 
namespace strumpack {
 
  namespace HSS {
 
    template<typename real_t> inline real_t default_HSS_rel_tol() {
      return real_t(1e-2);
    }
    template<typename real_t> inline real_t default_HSS_abs_tol() {
      return real_t(1e-8);
    }
 
    template<> inline float default_HSS_rel_tol() {
      return 1e-1;
    }
    template<> inline float default_HSS_abs_tol() {
      return 1e-5;
    }
 
    enum class CompressionAlgorithm {
      ORIGINAL,    
      STABLE,      
      HARD_RESTART 
    };
 
    std::string get_name(CompressionAlgorithm a);
 
 
    template<typename scalar_t> class HSSOptions {
 
    public:
      using real_t = typename RealType<scalar_t>::value_type;
 
      void set_rel_tol(real_t rel_tol) {
        assert(rel_tol <= real_t(1.) && rel_tol >= real_t(0.));
        rel_tol_ = rel_tol;
      }
 
      void set_abs_tol(real_t abs_tol) {
        assert(abs_tol >= real_t(0.));
        abs_tol_ = abs_tol;
      }
 
      void set_leaf_size(int leaf_size) {
        assert(leaf_size > 0);
        leaf_size_ = leaf_size;
      }
 
      void set_d0(int d0) { assert(d0 > 0); d0_ = d0; }
 
      void set_dd(int dd) { assert(dd > 0); dd_ = dd; }
 
      void set_p(int p) { assert(p >= 0); p_ = p; }
 
      void set_max_rank(int max_rank) {
        assert(max_rank > 0);
        max_rank_ = max_rank;
      }
 
      void set_random_engine(random::RandomEngine random_engine) {
        random_engine_ = random_engine;
      }
 
      void set_random_distribution
      (random::RandomDistribution random_distribution) {
        random_distribution_ = random_distribution;
      }
 
      void set_compression_algorithm(CompressionAlgorithm a) {
        compress_algo_ = a;
      }
 
      void set_clustering_algorithm(ClusteringAlgorithm a) {
        clustering_algo_ = a;
      }
 
      void set_approximate_neighbors(int neighbors) {
        approximate_neighbors_ = neighbors;
      }
 
      void set_ann_iterations(int iters) {
        assert(iters > 0);
        ann_iterations_ = iters;
      }
 
      void set_user_defined_random(bool user_defined_random) {
        user_defined_random_ = user_defined_random;
      }
 
      void set_synchronized_compression(bool sync) {
        sync_ = sync;
      }
 
      void set_log_ranks(bool log_ranks) { log_ranks_ = log_ranks; }
 
      void set_verbose(bool verbose) { verbose_ = verbose; }
 
      real_t rel_tol() const { return rel_tol_; }
 
      real_t abs_tol() const { return abs_tol_; }
 
      int leaf_size() const { return leaf_size_; }
 
      int d0() const { return d0_; }
 
      int dd() const { return dd_; }
 
      int p() const { return p_; }
 
      int max_rank() const { return max_rank_; }
 
      random::RandomEngine random_engine() const { return random_engine_; }
 
      random::RandomDistribution random_distribution() const {
        return random_distribution_;
      }
 
      CompressionAlgorithm compression_algorithm() const {
        return compress_algo_;
      }
 
      ClusteringAlgorithm clustering_algorithm() const {
        return clustering_algo_;
      }
 
      int approximate_neighbors() const {
        return approximate_neighbors_;
      }
 
      int ann_iterations() const { return ann_iterations_; }
 
      bool user_defined_random() const { return user_defined_random_; }
 
      bool synchronized_compression() const { return sync_; }
 
      bool log_ranks() const { return log_ranks_; }
 
      bool verbose() const { return verbose_; }
 
      void set_from_command_line(int argc, const char* const* cargv);
 
      void describe_options() const;
 
    private:
      real_t rel_tol_ = default_HSS_rel_tol<real_t>();
      real_t abs_tol_ = default_HSS_abs_tol<real_t>();
      int leaf_size_ = 512;
      int d0_ = 128;
      int dd_ = 64;
      int p_ = 10;
      int max_rank_ = 50000;
      random::RandomEngine random_engine_ =
        random::RandomEngine::LINEAR;
      random::RandomDistribution random_distribution_ =
        random::RandomDistribution::NORMAL;
      bool user_defined_random_ = false;
      bool log_ranks_ = false;
      CompressionAlgorithm compress_algo_ = CompressionAlgorithm::STABLE;
      bool sync_ = false;
      ClusteringAlgorithm clustering_algo_ = ClusteringAlgorithm::TWO_MEANS;
      int approximate_neighbors_ = 64;
      int ann_iterations_ = 5;
      bool verbose_ = true;
    };
 
  } // end namespace HSS
} // end namespace strumpack
 
 
#endif // HSS_OPTIONS_HPP