Merge remote-tracking branch 'origin/master' into environment

resources/3rdparty/CMakeLists.txt

@@ -208,9 +208,7 @@ include(${STORM_3RDPARTY_SOURCE_DIR}/include_cudd.cmake)
 #############################################################
 
 set(STORM_HAVE_CARL OFF)
-set(CARL_MINYEAR 17)
-set(CARL_MINMONTH 08)
-set(CARL_MINPATCH 0)
+set(CARL_MINVERSION "17.08")
 if (NOT STORM_FORCE_SHIPPED_CARL)
     if (NOT "${STORM_CARL_DIR_HINT}" STREQUAL "")
 		find_package(carl QUIET PATHS ${STORM_CARL_DIR_HINT} NO_DEFAULT_PATH)
@@ -228,20 +226,8 @@ if(carl_FOUND AND NOT STORM_FORCE_SHIPPED_CARL)
     else()
         message(SEND_ERROR "File ${carlLOCATION} does not exist, did you build carl?")
     endif()
-    if("${carl_MINORYEARVERSION}" STREQUAL "" OR "${carl_MINORMONTHVERSION}" STREQUAL "" OR "${carl_MAINTENANCEVERSION}" STREQUAL "")
-        # don't have detailed version information, probably an old version of carl
-        message(FATAL_ERROR "Carl at ${carlLOCATION} outdated, require ${CARL_MINYEAR}.${CARL_MINMONTH}.${CARL_MINPATCH}, have ${carl_VERSION}")
-    endif()
-    if(${carl_MINORYEARVERSION} LESS ${CARL_MINYEAR})
-        message(SEND_ERROR "Carl outdated, require ${CARL_MINYEAR}.${CARL_MINMONTH}.${CARL_MINPATCH}, have ${carl_VERSION}")
-    elseif(${carl_MINORYEARVERSION} EQUAL ${CARL_MINYEAR})
-        if(${carl_MINORMONTHVERSION} LESS ${CARL_MINMONTH})
-            message(SEND_ERROR "Carl outdated, require ${CARL_MINYEAR}.${CARL_MINMONTH}.${CARL_MINPATCH}, have ${carl_VERSION}")
-         elseif(${carl_MINORMONTHVERSION} EQUAL ${CARL_MINMONTH})
-            if(${carl_MAINTENANCEVERSION} LESS ${CARL_MINPATCH})
-                message(SEND_ERROR "Carl outdated, require ${CARL_MINYEAR}.${CARL_MINMONTH}.${CARL_MINPATCH}, have ${carl_VERSION}")
-            endif()
-        endif()
+    if("${carl_VERSION}" VERSION_LESS "${CARL_MINVERSION}")
+    	message(SEND_ERROR "Carl outdated, require ${CARL_MINVERSION}, have ${carl_VERSION}")
     endif()
 
     set(STORM_SHIPPED_CARL OFF)

src/storm-dft/builder/DftExplorationHeuristic.h

@@ -22,6 +22,8 @@ namespace storm {
 
             DFTExplorationHeuristic(size_t id, DFTExplorationHeuristic const& predecessor, ValueType rate, ValueType exitRate);
 
+            virtual ~DFTExplorationHeuristic() = default;
+
             void setBounds(ValueType lowerBound, ValueType upperBound);
 
             virtual bool updateHeuristicValues(DFTExplorationHeuristic const& predecessor, ValueType rate, ValueType exitRate) = 0;

src/storm-pgcl/storage/pgcl/AbstractStatementVisitor.h

@@ -13,6 +13,8 @@ namespace storm {
          */
         class AbstractStatementVisitor {
         public:
+            virtual ~AbstractStatementVisitor() = default;
+
             // Those functions need to be implemented for every possible
             // statement instantiation.
             virtual void visit(class AssignmentStatement const&) = 0;

src/storm-pgcl/storage/ppg/ProgramAction.h

@@ -14,6 +14,8 @@ namespace storm {
                 
             }
 
+            virtual ~ProgramAction() = default;
+
             ProgramActionIdentifier id() const {
                 return actId;
             }

src/storm/abstraction/MenuGameAbstractor.h

@@ -24,6 +24,8 @@ namespace storm {
         template <storm::dd::DdType DdType, typename ValueType>
         class MenuGameAbstractor {
         public:
+            virtual ~MenuGameAbstractor() = default;
+
             /// Retrieves the abstraction.
             virtual MenuGame<DdType, ValueType> abstract() = 0;
 

src/storm/abstraction/QualitativeResult.h

@@ -13,6 +13,8 @@ namespace storm {
         template <storm::dd::DdType Type>
         class QualitativeResult {
         public:
+            virtual ~QualitativeResult() = default;
+
             virtual storm::dd::Bdd<Type> const& getStates() const = 0;
         };
         

src/storm/abstraction/QualitativeResultMinMax.h

@@ -10,6 +10,8 @@ namespace storm {
         
         class QualitativeResultMinMax {
         public:
+            virtual ~QualitativeResultMinMax() = default;
+
             virtual bool isSymbolic() const;
             
             template<storm::dd::DdType Type>

src/storm/abstraction/StateSet.h

@@ -10,6 +10,8 @@ namespace storm {
         
         class StateSet {
         public:
+            virtual ~StateSet() = default;
+
             virtual bool isSymbolic() const;
             
             template<storm::dd::DdType Type>

src/storm/counterexamples/Counterexample.h

@@ -7,6 +7,8 @@ namespace storm {
         
         class Counterexample {
         public:
+            virtual ~Counterexample() = default;
+
             virtual void writeToStream(std::ostream& out) const = 0;
         };
         

src/storm/exceptions/BaseException.cpp

@@ -19,11 +19,8 @@ namespace storm {
 		}
         
         const char* BaseException::what() const NOEXCEPT {
-            std::string errorString = this->stream.str();
-            char* result = new char[errorString.size() + 1];
-            result[errorString.size()] = '\0';
-            std::copy(errorString.begin(), errorString.end(), result);
-            return result;
+            errorString = this->stream.str();
+            return errorString.c_str();
         }
     }
 }

src/storm/exceptions/BaseException.h

@@ -46,6 +46,10 @@ namespace storm {
         protected:
             // This stream stores the message of this exception.
             std::stringstream stream;
+
+        private:
+            // storage for the string backing the C string returned by what()
+            mutable std::string errorString;
         };
         
     } // namespace exceptions

src/storm/logic/FormulaVisitor.h

@@ -10,6 +10,8 @@ namespace storm {
 
         class FormulaVisitor {
         public:
+            virtual ~FormulaVisitor() = default;
+
             virtual boost::any visit(AtomicExpressionFormula const& f, boost::any const& data) const = 0;
             virtual boost::any visit(AtomicLabelFormula const& f, boost::any const& data) const = 0;
             virtual boost::any visit(BinaryBooleanStateFormula const& f, boost::any const& data) const = 0;

src/storm/modelchecker/hints/ModelCheckerHint.h

@@ -15,6 +15,7 @@ namespace storm {
         class ModelCheckerHint {
         public:
             ModelCheckerHint() = default;
+            virtual ~ModelCheckerHint() = default;
 
             // Returns true iff this hint does not contain any information.
             virtual bool isEmpty() const;

src/storm/modelchecker/multiobjective/SparseMultiObjectivePreprocessorTask.h

@@ -25,6 +25,8 @@ namespace storm {
                     // intentionally left empty
                 }
 
+                virtual ~SparseMultiObjectivePreprocessorTask() = default;
+
                 virtual void perform(SparseModelType& preprocessedModel) const = 0;
                 
                 virtual bool requiresEndComponentAnalysis() const {

src/storm/modelchecker/prctl/helper/DsMpiUpperRewardBoundsComputer.h

@@ -28,6 +28,8 @@ namespace storm {
                  */
                 DsMpiDtmcUpperRewardBoundsComputer(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType> const& rewards, std::vector<ValueType> const& oneStepTargetProbabilities);
 
+                virtual ~DsMpiDtmcUpperRewardBoundsComputer() = default;
+
                 /*!
                  * Computes upper bounds on the expected rewards.
                  */

src/storm/models/sparse/ItemLabeling.h

@@ -33,6 +33,7 @@ namespace storm {
                 ItemLabeling(ItemLabeling const& other) = default;
                 ItemLabeling& operator=(ItemLabeling const& other) = default;
 
+                virtual ~ItemLabeling() = default;
 
                 virtual bool isStateLabeling() const;
                 virtual bool isChoiceLabeling() const;

src/storm/models/sparse/StateAnnotation.h

@@ -9,6 +9,8 @@ namespace storm {
             
             class StateAnnotation {
             public:
+                virtual ~StateAnnotation() = default;
+
                 virtual std::string getStateInfo(storm::storage::sparse::state_type const& state) const = 0;
             };
             

src/storm/permissivesched/PermissiveSchedulerComputation.h

@@ -27,6 +27,7 @@ namespace storm {
                 
             }
 
+            virtual ~PermissiveSchedulerComputation() = default;
 
             virtual void calculatePermissiveScheduler(bool lowerBound, double boundary) = 0;
             

src/storm/settings/ArgumentBase.h

@@ -27,6 +27,8 @@ namespace storm {
                 // Intentionally left empty.
             }
 
+            virtual ~ArgumentBase() = default;
+
             /*!
              * Retrieves the type of the argument.
              *

src/storm/settings/ArgumentValidators.h

@@ -12,6 +12,8 @@ namespace storm {
         template <typename ValueType>
         class ArgumentValidator {
         public:
+            virtual ~ArgumentValidator() = default;
+
             /*!
              * Checks whether the argument passes the validation.
              */

src/storm/solver/GameSolver.h

@@ -137,6 +137,7 @@ namespace storm {
         class GameSolverFactory {
         public:
             GameSolverFactory();
+            virtual ~GameSolverFactory() = default;
 
             virtual std::unique_ptr<GameSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<storm::storage::sparse::state_type> const& player1Matrix, storm::storage::SparseMatrix<ValueType> const& player2Matrix) const;
             virtual std::unique_ptr<GameSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<storm::storage::sparse::state_type>&& player1Matrix, storm::storage::SparseMatrix<ValueType>&& player2Matrix) const;

src/storm/solver/LinearEquationSolver.h

@@ -182,6 +182,8 @@ namespace storm {
         template<typename ValueType>
         class LinearEquationSolverFactory {
         public:
+            virtual ~LinearEquationSolverFactory() = default;
+
             /*!
              * Creates a new linear equation solver instance with the given matrix.
              *

src/storm/solver/LpSolver.h

@@ -36,6 +36,8 @@ namespace storm {
              */
             LpSolver(OptimizationDirection const& optDir);
 
+            virtual ~LpSolver() = default;
+
             /*!
              * Registers an upper- and lower-bounded continuous variable, i.e. a variable that may take all real values
              * within its bounds.

src/storm/solver/MinMaxLinearEquationSolver.h

@@ -210,6 +210,7 @@ namespace storm {
         class MinMaxLinearEquationSolverFactory {
         public:
             MinMaxLinearEquationSolverFactory();
+	    virtual ~MinMaxLinearEquationSolverFactory() = default;
             
             std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix) const;
             std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType>&& matrix) const;

src/storm/solver/SmtSolver.h

@@ -36,6 +36,7 @@ namespace storm {
                  * @param manager The manager responsible for the variables whose value can be requested.
                  */
                 ModelReference(storm::expressions::ExpressionManager const& manager);
+                virtual ~ModelReference() = default;
 
                 virtual bool getBooleanValue(storm::expressions::Variable const& variable) const = 0;
 				virtual int_fast64_t getIntegerValue(storm::expressions::Variable const& variable) const = 0;

src/storm/solver/SymbolicEquationSolver.h

@@ -13,6 +13,7 @@ namespace storm {
         public:
             SymbolicEquationSolver() = default;
             SymbolicEquationSolver(storm::dd::Bdd<DdType> const& allRows);
+            virtual ~SymbolicEquationSolver() = default;
 
             virtual void setLowerBounds(storm::dd::Add<DdType, ValueType> const& lowerBounds);
             virtual void setLowerBound(ValueType const& lowerBound);

src/storm/solver/SymbolicGameSolver.h

@@ -38,6 +38,8 @@ namespace storm {
              */
             SymbolicGameSolver(storm::dd::Add<Type, ValueType> const& A, storm::dd::Bdd<Type> const& allRows, storm::dd::Bdd<Type> const& illegalPlayer1Mask, storm::dd::Bdd<Type> const& illegalPlayer2Mask, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables, std::vector<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& rowColumnMetaVariablePairs, std::set<storm::expressions::Variable> const& player1Variables, std::set<storm::expressions::Variable> const& player2Variables);
             
+            virtual ~SymbolicGameSolver() = default;
+
             /*!
              * Solves the equation system defined by the game matrix. Note that the game matrix has to be given upon
              * construction time of the solver object.
@@ -108,6 +110,8 @@ namespace storm {
         template<storm::dd::DdType Type, typename ValueType>
         class SymbolicGameSolverFactory {
         public:
+            virtual ~SymbolicGameSolverFactory() = default;
+
             virtual std::unique_ptr<storm::solver::SymbolicGameSolver<Type, ValueType>> create(storm::dd::Add<Type, ValueType> const& A, storm::dd::Bdd<Type> const& allRows, storm::dd::Bdd<Type> const& illegalPlayer1Mask, storm::dd::Bdd<Type> const& illegalPlayer2Mask, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables, std::vector<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& rowColumnMetaVariablePairs, std::set<storm::expressions::Variable> const& player1Variables, std::set<storm::expressions::Variable> const& player2Variables) const;
         };
         

src/storm/solver/SymbolicLinearEquationSolver.h

@@ -36,6 +36,7 @@ namespace storm {
         class SymbolicLinearEquationSolver : public SymbolicEquationSolver<DdType, ValueType> {
         public:
             SymbolicLinearEquationSolver();
+            virtual ~SymbolicLinearEquationSolver() = default;
 
             /*!
              * Constructs a symbolic linear equation solver with the given meta variable sets and pairs.
@@ -119,6 +120,8 @@ namespace storm {
         template<storm::dd::DdType DdType, typename ValueType>
         class SymbolicLinearEquationSolverFactory {
         public:
+            virtual ~SymbolicLinearEquationSolverFactory() = default;
+            
             std::unique_ptr<storm::solver::SymbolicLinearEquationSolver<DdType, ValueType>> create(Environment const& env, storm::dd::Bdd<DdType> const& allRows, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables, std::vector<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& rowColumnMetaVariablePairs) const;
             
             std::unique_ptr<storm::solver::SymbolicLinearEquationSolver<DdType, ValueType>> create(Environment const& env, storm::dd::Add<DdType, ValueType> const& A, storm::dd::Bdd<DdType> const& allRows, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables, std::vector<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& rowColumnMetaVariablePairs) const;

src/storm/solver/SymbolicMinMaxLinearEquationSolver.cpp

@@ -277,6 +277,7 @@ namespace storm {
             if (solver.getEquationProblemFormat(env) == storm::solver::LinearEquationSolverProblemFormat::EquationSystem) {
                 schedulerA = diagonal - schedulerA;
             }
+
             storm::dd::Add<DdType, ValueType> schedulerB = scheduler.ite(b, scheduler.getDdManager().template getAddZero<ValueType>()).sumAbstract(this->choiceVariables);
 
             // Set the matrix for the solver.
@@ -314,9 +315,16 @@ namespace storm {
                 storm::dd::Bdd<DdType> nextScheduler;
                 if (dir == storm::solver::OptimizationDirection::Minimize) {
                     choiceValues += illegalMaskAdd;
-                    nextScheduler = choiceValues.minAbstractRepresentative(this->choiceVariables);
+                    
+                    storm::dd::Add<DdType, ValueType> newStateValues = choiceValues.minAbstract(this->choiceVariables);
+                    storm::dd::Bdd<DdType> improvedStates = newStateValues.less(schedulerX);
+                    
+                    nextScheduler = improvedStates.ite(choiceValues.minAbstractRepresentative(this->choiceVariables), scheduler);
                 } else {
-                    nextScheduler = choiceValues.maxAbstractRepresentative(this->choiceVariables);
+                    storm::dd::Add<DdType, ValueType> newStateValues = choiceValues.maxAbstract(this->choiceVariables);
+                    storm::dd::Bdd<DdType> improvedStates = newStateValues.greater(schedulerX);
+
+                    nextScheduler = improvedStates.ite(choiceValues.maxAbstractRepresentative(this->choiceVariables), scheduler);
                 }
                 
                 // Check for convergence.

src/storm/solver/SymbolicMinMaxLinearEquationSolver.h

@@ -40,6 +40,7 @@ namespace storm {
         class SymbolicMinMaxLinearEquationSolver : public SymbolicEquationSolver<DdType, ValueType> {
         public:
             SymbolicMinMaxLinearEquationSolver();
+            virtual ~SymbolicMinMaxLinearEquationSolver() = default;
 
             /*!
              * Constructs a symbolic min/max linear equation solver with the given meta variable sets and pairs.
@@ -213,6 +214,8 @@ namespace storm {
         template<storm::dd::DdType DdType, typename ValueType>
         class SymbolicMinMaxLinearEquationSolverFactory {
         public:
+            virtual ~SymbolicMinMaxLinearEquationSolverFactory() = default;
+
             virtual std::unique_ptr<storm::solver::SymbolicMinMaxLinearEquationSolver<DdType, ValueType>> create(storm::dd::Add<DdType, ValueType> const& A, storm::dd::Bdd<DdType> const& allRows, storm::dd::Bdd<DdType> const& illegalMask, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables, std::set<storm::expressions::Variable> const& choiceVariables, std::vector<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& rowColumnMetaVariablePairs) const = 0;
             
             /*!

src/storm/solver/TerminationCondition.h

@@ -10,6 +10,8 @@ namespace storm {
         template<typename ValueType>
         class TerminationCondition {
         public:
+            virtual ~TerminationCondition() = default;
+
             /*!
              * Retrieves whether the guarantee provided by the solver for the current result is sufficient to terminate.
              */

src/storm/solver/stateelimination/EliminatorBase.h

@@ -19,6 +19,7 @@ namespace storm {
                 typedef typename FlexibleRowType::iterator FlexibleRowIterator;
                 
                 EliminatorBase(storm::storage::FlexibleSparseMatrix<ValueType>& matrix, storm::storage::FlexibleSparseMatrix<ValueType>& transposedMatrix);
+                virtual ~EliminatorBase() = default;
 
                 void eliminate(uint64_t row, uint64_t column, bool clearRow);
                 

src/storm/solver/stateelimination/StatePriorityQueue.h

@@ -10,6 +10,8 @@ namespace storm {
          
             class StatePriorityQueue {
             public:
+                virtual ~StatePriorityQueue() = default;
+
                 virtual bool hasNext() const = 0;
                 virtual storm::storage::sparse::state_type pop() = 0;
                 virtual void update(storm::storage::sparse::state_type state);

src/storm/storage/BitVector.cpp

@@ -118,6 +118,7 @@ namespace storm {
                 bitCount = other.bitCount;
                 if (buckets && bucketCount() != other.bucketCount()) {
                     delete[] buckets;
+                    buckets = nullptr;
                 }
                 if (!buckets) {
                     buckets = new uint64_t[other.bucketCount()];
@@ -157,6 +158,9 @@ namespace storm {
             // Only perform the assignment if the source and target are not identical.
             if (this != &other) {
                 bitCount = other.bitCount;
+                if (this->buckets) {
+                    delete[] this->buckets;
+                }
                 this->buckets = other.buckets;
                 other.buckets = nullptr;
             }

src/storm/storage/bisimulation/BisimulationDecomposition.h

@@ -181,6 +181,8 @@ namespace storm {
              */
             BisimulationDecomposition(ModelType const& model, Options const& options);
 
+            virtual ~BisimulationDecomposition() = default;
+
             /*!
              * Retrieves the quotient of the model under the computed bisimulation.
              *

src/storm/storage/dd/bisimulation/QuotientExtractor.cpp

@@ -255,6 +255,8 @@ namespace storm {
                     STORM_LOG_TRACE("Partition has " << partitionBdd.existsAbstract(model.getRowVariables()).getNonZeroCount() << " states in " << this->numberOfBlocks << " blocks.");
                 }
 
+                virtual ~InternalSparseQuotientExtractorBase() = default;
+
                 storm::storage::SparseMatrix<ValueType> extractTransitionMatrix(storm::dd::Add<DdType, ValueType> const& transitionMatrix) {
                     return extractMatrixInternal(transitionMatrix);
                 }

src/storm/storage/dd/cudd/InternalCuddAdd.h

@@ -67,6 +67,7 @@ namespace storm {
             InternalAdd& operator=(InternalAdd<DdType::CUDD, ValueType> const& other) = default;
             InternalAdd(InternalAdd<DdType::CUDD, ValueType>&& other) = default;
             InternalAdd& operator=(InternalAdd<DdType::CUDD, ValueType>&& other) = default;
+            virtual ~InternalAdd() = default;
 
             /*!
              * Retrieves whether the two DDs represent the same function.

src/storm/storage/dd/sylvan/InternalSylvanAdd.h

@@ -60,6 +60,7 @@ namespace storm {
             InternalAdd& operator=(InternalAdd<DdType::Sylvan, ValueType> const& other) = default;
             InternalAdd(InternalAdd<DdType::Sylvan, ValueType>&& other) = default;
             InternalAdd& operator=(InternalAdd<DdType::Sylvan, ValueType>&& other) = default;
+            virtual ~InternalAdd() = default;
 
             /*!
              * Retrieves whether the two DDs represent the same function.
@@ -732,7 +733,7 @@ namespace storm {
             static MTBDD getLeaf(uint_fast64_t value);
 
             /*!
-             * Retrieves the sylvan representation of the given storm::RatíonalNumber.
+             * Retrieves the sylvan representation of the given storm::Rat�onalNumber.
              *
              * @return The sylvan node for the given value.
              */

src/storm/storage/expressions/CompiledExpression.h

@@ -7,6 +7,7 @@ namespace storm {
         
         class CompiledExpression {
         public:
+            virtual ~CompiledExpression() = default;
             
             virtual bool isExprtkCompiledExpression() const;
             ExprtkCompiledExpression& asExprtkCompiledExpression();

src/storm/storage/expressions/ExpressionEvaluatorBase.h

@@ -9,6 +9,7 @@ namespace storm {
         class ExpressionEvaluatorBase {
         public:
             ExpressionEvaluatorBase(storm::expressions::ExpressionManager const& manager);
+            virtual ~ExpressionEvaluatorBase() = default;
 
             virtual bool asBool(Expression const& expression) const = 0;
             virtual int_fast64_t asInt(Expression const& expression) const = 0;

src/storm/storage/expressions/ExpressionVisitor.h

@@ -20,6 +20,8 @@ namespace storm {
         
         class ExpressionVisitor {
         public:
+            virtual ~ExpressionVisitor() = default;
+
             virtual boost::any visit(IfThenElseExpression const& expression, boost::any const& data) = 0;
             virtual boost::any visit(BinaryBooleanFunctionExpression const& expression, boost::any const& data) = 0;
             virtual boost::any visit(BinaryNumericalFunctionExpression const& expression, boost::any const& data) = 0;

src/storm/storage/expressions/Type.h

@@ -15,6 +15,7 @@ namespace storm {
         class BaseType {
         public:
             BaseType();
+            virtual ~BaseType() = default;
             
             /*!
              * Retrieves the mask that is associated with this type.

src/storm/storage/expressions/Variable.cpp

@@ -16,7 +16,7 @@ namespace storm {
         }
 
         bool Variable::operator==(Variable const& other) const {
-            return manager == other.manager && index == other.index;
+            return &this->getManager() == &other.getManager() && index == other.index;
         }
 
         bool Variable::operator!=(Variable const& other) const {
@@ -48,8 +48,7 @@ namespace storm {
         }
         
         ExpressionManager const& Variable::getManager() const {
-            STORM_LOG_ASSERT(manager != nullptr, "Manager is null.");
-            return *manager;
+            return *manager.lock();
         }
 
         bool Variable::hasBooleanType() const {

src/storm/storage/expressions/Variable.h

@@ -138,7 +138,7 @@ namespace storm {
 
         private:
             // The manager that is responsible for this variable.
-            std::shared_ptr<ExpressionManager const> manager;
+            std::weak_ptr<ExpressionManager const> manager;
             
             // The index of the variable.
             uint_fast64_t index;

src/storm/storage/jani/Composition.h

@@ -9,6 +9,8 @@ namespace storm {
         
         class Composition {
         public:
+            virtual ~Composition() = default;
+
             virtual boost::any accept(CompositionVisitor& visitor, boost::any const& data) const = 0;
             
             virtual void write(std::ostream& stream) const = 0;

src/storm/storage/jani/CompositionVisitor.h

@@ -11,6 +11,8 @@ namespace storm {
         
         class CompositionVisitor {
         public:
+            virtual ~CompositionVisitor() = default;
+
             virtual boost::any visit(AutomatonComposition const& composition, boost::any const& data) = 0;
             virtual boost::any visit(ParallelComposition const& composition, boost::any const& data) = 0;
         };

src/storm/storage/prism/Composition.h

@@ -10,6 +10,7 @@ namespace storm {
         class Composition {
         public:
             Composition() = default;
+            virtual ~Composition() = default;
             
             friend std::ostream& operator<<(std::ostream& stream, Composition const& composition);
             

src/storm/storage/prism/CompositionVisitor.h

@@ -15,6 +15,8 @@ namespace storm {
         
         class CompositionVisitor {
         public:
+            virtual ~CompositionVisitor() = default;
+
             virtual boost::any visit(ModuleComposition const& composition, boost::any const& data) = 0;
             virtual boost::any visit(RenamingComposition const& composition, boost::any const& data) = 0;
             virtual boost::any visit(HidingComposition const& composition, boost::any const& data) = 0;

src/storm/storage/prism/Variable.h

@@ -17,6 +17,7 @@ namespace storm {
             Variable& operator=(Variable const& otherVariable)= default;
             Variable(Variable&& otherVariable) = default;
             Variable& operator=(Variable&& otherVariable) = default;
+            virtual ~Variable() = default;
             
             /*!
              * Retrieves the name of the variable.

src/storm/utility/solver.h

@@ -59,6 +59,8 @@ namespace storm {
             template<typename ValueType>
             class LpSolverFactory {
             public:
+                virtual ~LpSolverFactory() = default;
+
                 /*!
                  * Creates a new linear equation solver instance with the given name.
                  *
@@ -98,6 +100,8 @@ namespace storm {
 
             class SmtSolverFactory {
             public:
+                virtual ~SmtSolverFactory() = default;
+
                 /*!
                  * Creates a new SMT solver instance.
                  *