Multiplier.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <vector>
 
#include "storm/solver/MultiplicationStyle.h"
#include "storm/solver/OptimizationDirection.h"
 
namespace storm {
 
class Environment;
 
namespace storage {
template<typename ValueType>
class SparseMatrix;
}
 
namespace solver {
 
template<typename ValueType>
class Multiplier {
   public:
    Multiplier(storm::storage::SparseMatrix<ValueType> const& matrix);
 
    virtual ~Multiplier() = default;
 
    /*
     * Clears the currently cached data of this multiplier in order to free some memory.
     */
    virtual void clearCache() const;
 
    virtual void multiply(Environment const& env, std::vector<ValueType> const& x, std::vector<ValueType> const* b, std::vector<ValueType>& result) const = 0;
 
    virtual void multiplyGaussSeidel(Environment const& env, std::vector<ValueType>& x, std::vector<ValueType> const* b, bool backwards = true) const = 0;
 
    void multiplyAndReduce(Environment const& env, OptimizationDirection const& dir, std::vector<ValueType> const& x, std::vector<ValueType> const* b,
                           std::vector<ValueType>& result, std::vector<uint_fast64_t>* choices = nullptr) const;
    virtual void multiplyAndReduce(Environment const& env, OptimizationDirection const& dir, std::vector<uint64_t> const& rowGroupIndices,
                                   std::vector<ValueType> const& x, std::vector<ValueType> const* b, std::vector<ValueType>& result,
                                   std::vector<uint_fast64_t>* choices = nullptr) const = 0;
 
    void multiplyAndReduceGaussSeidel(Environment const& env, OptimizationDirection const& dir, std::vector<ValueType>& x, std::vector<ValueType> const* b,
                                      std::vector<uint_fast64_t>* choices = nullptr, bool backwards = true) const;
    virtual void multiplyAndReduceGaussSeidel(Environment const& env, OptimizationDirection const& dir, std::vector<uint64_t> const& rowGroupIndices,
                                              std::vector<ValueType>& x, std::vector<ValueType> const* b, std::vector<uint_fast64_t>* choices = nullptr,
                                              bool backwards = true) const = 0;
 
    void repeatedMultiply(Environment const& env, std::vector<ValueType>& x, std::vector<ValueType> const* b, uint64_t n) const;
 
    void repeatedMultiplyAndReduce(Environment const& env, OptimizationDirection const& dir, std::vector<ValueType>& x, std::vector<ValueType> const* b,
                                   uint64_t n) const;
 
    virtual void multiplyRow(uint64_t const& rowIndex, std::vector<ValueType> const& x, ValueType& value) const = 0;
 
    virtual void multiplyRow2(uint64_t const& rowIndex, std::vector<ValueType> const& x1, ValueType& val1, std::vector<ValueType> const& x2,
                              ValueType& val2) const;
 
   protected:
    mutable std::unique_ptr<std::vector<ValueType>> cachedVector;
    storm::storage::SparseMatrix<ValueType> const& matrix;
};
class Multiplier {…};
 
template<typename ValueType>
class MultiplierFactory {
   public:
    MultiplierFactory() = default;
    ~MultiplierFactory() = default;
 
    std::unique_ptr<Multiplier<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix);
};
class MultiplierFactory {…};
 
}  // namespace solver
}  // namespace storm