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 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:
        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>