sparse_les.h

#pragma once
 
#include <vector>
#include <string>
#include <cgv/data/ref_ptr.h>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace math {
 
class CGV_API sparse_les;
 
typedef cgv::data::ref_ptr<sparse_les,true> sparse_les_ptr;
 
enum SparseLesCaps
{
    SLC_SYMMETRIC = 1,
    SLC_UNSYMMETRIC = 2,
    SLC_NZE_OPTIONAL = 4,
    SLC_ALL = 7
};
 
class CGV_API sparse_les_factory : public cgv::data::ref_counted
{
public:
    virtual ~sparse_les_factory();
    virtual SparseLesCaps get_caps() const = 0;
    virtual std::string get_solver_name() const = 0;
 
    virtual sparse_les_ptr create(int n, int nr_rhs, int nr_nze = -1) = 0;
};
 
typedef cgv::data::ref_ptr<sparse_les_factory,true> sparse_les_factory_ptr;
 
 
class CGV_API sparse_les : public cgv::data::ref_counted
{
public:
    virtual ~sparse_les() {}
    static void register_solver_factory(sparse_les_factory_ptr sls_fac);
    static const std::vector<sparse_les_factory_ptr>& get_solver_factories();
    static sparse_les_ptr create_by_name(const std::string& solver_name, int n, int nr_rhs, int nr_nze = -1);
    static sparse_les_ptr create_by_cap(SparseLesCaps caps, int n, int nr_rhs, int nr_nze = -1);
 
    virtual void set_mat_entry(int r, int c, double val) = 0;
    virtual void set_b_entry(int i, double val);
    virtual void set_b_entry(int i, int j, double val) = 0;
    virtual double& ref_b_entry(int i);
    virtual double& ref_b_entry(int i, int j) = 0;
 
    virtual bool solve(bool analyze_residual = false) = 0;
    virtual double get_x_entry(int i) const;
    virtual double get_x_entry(int i, int j) const = 0;
};
 
template <class T>
class sparse_les_factory_impl : public sparse_les_factory
{
protected:
    std::string solver_name;
    SparseLesCaps caps;
public:
    sparse_les_factory_impl(const std::string& _solver_name, SparseLesCaps _caps) :
      solver_name(_solver_name), caps(_caps) {}
    SparseLesCaps get_caps() const { return caps; }
    std::string get_solver_name() const { return solver_name; }
    sparse_les_ptr create(int n, int nr_rhs, int nr_nze) {
        return sparse_les_ptr(new T(n, nr_rhs, nr_nze));
    }
};
 
 
template <class T>
struct register_sparse_les_factory
{
    register_sparse_les_factory(const std::string& _solver_name, SparseLesCaps _caps) {
        sparse_les::register_solver_factory(sparse_les_factory_ptr(
            new sparse_les_factory_impl<T>(_solver_name, _caps)));
    }
};
 
    }
}
 
#include <cgv/config/lib_end.h>