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"
#include "storm/solver/UncertaintyResolutionMode.h"
 
namespace storm {
 
class Environment;
 
namespace storage {
template<typename ValueType>
class SparseMatrix;
}
 
namespace solver {
 
template<typename ValueType, typename SolutionType = 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<SolutionType> const& x, std::vector<ValueType> const* b,
                          std::vector<SolutionType>& result) const = 0;

    virtual void multiplyGaussSeidel(Environment const& env, std::vector<SolutionType>& x, std::vector<ValueType> const* b, bool backwards = true) const = 0;

    void multiplyAndReduce(Environment const& env, OptimizationDirection const& dir, std::vector<SolutionType> const& x, std::vector<ValueType> const* b,
                           std::vector<SolutionType>& result, UncertaintyResolutionMode const& uncertaintyResolutionMode = UncertaintyResolutionMode::Unset,
                           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<SolutionType> const& x, std::vector<ValueType> const* b, std::vector<SolutionType>& result,
                                   UncertaintyResolutionMode const& uncertaintyResolutionMode = UncertaintyResolutionMode::Unset,
                                   std::vector<uint_fast64_t>* choices = nullptr) const = 0;

    void multiplyAndReduceGaussSeidel(Environment const& env, OptimizationDirection const& dir, std::vector<SolutionType>& 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<SolutionType>& 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<SolutionType>& x, std::vector<ValueType> const* b, uint64_t n) const;

    void repeatedMultiplyAndReduce(Environment const& env, OptimizationDirection const& dir, std::vector<SolutionType>& x, std::vector<ValueType> const* b,
                                   uint64_t n, UncertaintyResolutionMode const& uncertaintyResolutionMode = UncertaintyResolutionMode::Unset) const;
    void repeatedMultiplyWithFactor(Environment const& env, std::vector<SolutionType>& x, std::vector<ValueType> const* b, uint64_t n,
                                    SolutionType factor) const;

    void repeatedMultiplyAndReduceWithFactor(Environment const& env, OptimizationDirection const& dir, std::vector<SolutionType>& x,
                                             std::vector<ValueType> const* b, uint64_t n, SolutionType factor,
                                             UncertaintyResolutionMode const& uncertaintyResolutionMode = UncertaintyResolutionMode::Unset) const;
 
   protected:
    std::vector<SolutionType>& provideCachedVector(uint64_t size) const;
 
    mutable std::unique_ptr<std::vector<SolutionType>> cachedVector;
    storm::storage::SparseMatrix<ValueType> const& matrix;
};
 
template<typename ValueType, typename SolutionType = ValueType>
class MultiplierFactory {
   public:
    MultiplierFactory() = default;
    ~MultiplierFactory() = default;
 
    std::unique_ptr<Multiplier<ValueType, SolutionType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix);
};
 
}  // namespace solver
}  // namespace storm