LinearEquationSolver.h

Go to the documentation of this file.

#ifndef STORM_SOLVER_LINEAREQUATIONSOLVER_H_
#define STORM_SOLVER_LINEAREQUATIONSOLVER_H_
 
#include <memory>
#include <vector>
 
#include "storm/solver/AbstractEquationSolver.h"
#include "storm/solver/LinearEquationSolverProblemFormat.h"
#include "storm/solver/LinearEquationSolverRequirements.h"
#include "storm/solver/MultiplicationStyle.h"
#include "storm/solver/OptimizationDirection.h"
 
#include "storm/utility/VectorHelper.h"
 
#include "storm/storage/SparseMatrix.h"
 
namespace storm {
 
class Environment;
 
namespace solver {
 
template<class ValueType>
class LinearEquationSolver : public AbstractEquationSolver<ValueType> {
   public:
    LinearEquationSolver();
 
    virtual ~LinearEquationSolver() {
        // Intentionally left empty.
    }
 
    virtual void setMatrix(storm::storage::SparseMatrix<ValueType> const& A) = 0;
    virtual void setMatrix(storm::storage::SparseMatrix<ValueType>&& A) = 0;
 
    bool solveEquations(Environment const& env, std::vector<ValueType>& x, std::vector<ValueType> const& b) const;
 
    virtual LinearEquationSolverProblemFormat getEquationProblemFormat(Environment const& env) const = 0;
 
    virtual LinearEquationSolverRequirements getRequirements(Environment const& env) const;
 
    void setCachingEnabled(bool value) const;
 
    bool isCachingEnabled() const;
 
    /*
     * Clears the currently cached data that has been stored during previous calls of the solver.
     */
    virtual void clearCache() const;
 
   protected:
    virtual bool internalSolveEquations(Environment const& env, std::vector<ValueType>& x, std::vector<ValueType> const& b) const = 0;
 
    // auxiliary storage. If set, this vector has getMatrixRowCount() entries.
    mutable std::unique_ptr<std::vector<ValueType>> cachedRowVector;
 
   private:
    virtual uint64_t getMatrixRowCount() const = 0;
 
    virtual uint64_t getMatrixColumnCount() const = 0;
 
    mutable bool cachingEnabled;
 
    storm::utility::VectorHelper<ValueType> vectorHelper;
};
 
enum class EquationSolverType;
 
template<typename ValueType>
class LinearEquationSolverFactory {
   public:
    virtual ~LinearEquationSolverFactory() = default;
 
    std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix) const;
 
    std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType>&& matrix) const;
 
    virtual std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env) const = 0;
 
    virtual std::unique_ptr<LinearEquationSolverFactory<ValueType>> clone() const = 0;
 
    virtual LinearEquationSolverProblemFormat getEquationProblemFormat(Environment const& env) const;
 
    LinearEquationSolverRequirements getRequirements(Environment const& env) const;
};
 
template<typename ValueType>
class GeneralLinearEquationSolverFactory : public LinearEquationSolverFactory<ValueType> {
   public:
    GeneralLinearEquationSolverFactory();
 
    using LinearEquationSolverFactory<ValueType>::create;
 
    virtual std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env) const override;
 
    virtual std::unique_ptr<LinearEquationSolverFactory<ValueType>> clone() const override;
};
 
}  // namespace solver
}  // namespace storm
 
#endif /* STORM_SOLVER_LINEAREQUATIONSOLVER_H_ */