solver_option.h

Go to the documentation of this file.

#ifndef _RHEOLEF_SOLVER_OPTION_H
#define _RHEOLEF_SOLVER_OPTION_H
//
// This file is part of Rheolef.
//
// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
//
// Rheolef is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Rheolef is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rheolef; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// =========================================================================
// AUTHOR: Pierre.Saramito@imag.fr
// DATE:   4 march 2011
 
namespace rheolef {
} // namespace rheolef
 
#include "rheolef/diststream.h"
#include "rheolef/csr.h"
 
namespace rheolef {
 
// [verbatim_solver_option]
class solver_option {
public:
  typedef std::size_t size_type;
  static const long int  decide = -1;
  mutable long int   iterative; 
  Float              tol;
  size_type          max_iter;
  bool               absolute_stopping;
  mutable Float      residue;
  mutable size_type  n_iter;
  odiststream*       p_err;
  mutable std::string label;   
  size_type          krylov_dimension;
  size_type          n_refinement;
  bool               compute_determinant; 
  std::string        preferred_library;   
  size_type          verbose_level;     
  bool               do_check;
  bool               force_seq; 
  size_type          level_of_fill;
  size_type          amalgamation; 
  size_type          ooc;         
 
// allocator and default values:
 
  solver_option()
   : iterative     (decide),
#if defined(_RHEOLEF_HAVE_FLOAT128)
     tol           (1e6*std::numeric_limits<Float>::epsilon()),
#else
     tol           (1e3*std::numeric_limits<Float>::epsilon()),
#endif
     max_iter      (100000),
     absolute_stopping (true),
     residue       (0),
     n_iter        (0),
     p_err         (&derr),
     label         (),
     krylov_dimension (6),
     n_refinement  (2),
     compute_determinant(false),
     preferred_library(),
     verbose_level (0),
     do_check      (false),
     force_seq     (false),
     level_of_fill (1),
     amalgamation  (10),
     ooc           (20000)
  {
  }
  solver_option (const solver_option&);
  solver_option& operator= (const solver_option&);
  template <class T, class M>
  static std::string default_preferred_library (const csr<T,M>& a);
  template <class T, class M>
  static std::string used_library (const csr<T,M>& a, const solver_option& sopt = solver_option());
// [verbatim_solver_option]
protected:
  static std::string _default_preferred_library (size_t dis_ext_nnz, bool is_sym, bool is_dp);
  static std::string _used_library (std::string init_preferred_library, size_t dis_ext_nnz, bool is_sym, bool is_dp);
// [verbatim_solver_option_cont]
};
// [verbatim_solver_option_cont]
 
// for backward compatibility:
using solver_option_type = solver_option;
 
// ---------------------------------------------------------------
// inlined
// ---------------------------------------------------------------
inline
solver_option::solver_option (const solver_option& x)
   : iterative     (x.iterative),
     tol           (x.tol),
     max_iter      (x.max_iter),
     absolute_stopping (x.absolute_stopping),
     residue       (x.residue),
     n_iter        (x.n_iter),
     p_err         (x.p_err),
     label         (x.label),
     krylov_dimension (x.krylov_dimension),
     n_refinement  (x.n_refinement),
     compute_determinant(x.compute_determinant),
     preferred_library(x.preferred_library),
     verbose_level (x.verbose_level),
     do_check      (x.do_check),
     force_seq     (x.force_seq),
     level_of_fill (x.level_of_fill),
     amalgamation  (x.amalgamation),
     ooc           (x.ooc)
{
}
inline
solver_option&
solver_option::operator= (const solver_option& x)
{
     iterative     = x.iterative;
     tol           = x.tol;
     max_iter      = x.max_iter;
     absolute_stopping = x.absolute_stopping;
     residue       = x.residue;
     n_iter        = x.n_iter;
     p_err         = x.p_err;
     label         = x.label;
     krylov_dimension = x.krylov_dimension;
     n_refinement  = x.n_refinement;
     compute_determinant= x.compute_determinant;
     preferred_library= x.preferred_library;
     verbose_level = x.verbose_level;
     do_check      = x.do_check;
     force_seq     = x.force_seq;
     level_of_fill = x.level_of_fill;
     amalgamation  = x.amalgamation;
     ooc           = x.ooc;
     return *this;
}
template <class T, class M>
inline
std::string
solver_option::default_preferred_library (const csr<T,M>& a)
{
  return _default_preferred_library (a.dis_ext_nnz(), a.is_symmetric(), a.is_definite_positive());
}
template <class T, class M>
inline
std::string
solver_option::used_library (const csr<T,M>& a, const solver_option& sopt)
{
  return _used_library (sopt.preferred_library,  a.dis_ext_nnz(), a.is_symmetric(), a.is_definite_positive());
}
 
} // namespace rheolef
#endif // _RHEOLEF_SOLVER_OPTION_H