diff --git a/src/adapters/ExplicitModelAdapter.h b/src/adapters/ExplicitModelAdapter.h
index 70834ee9b..f82b4dcee 100644
--- a/src/adapters/ExplicitModelAdapter.h
+++ b/src/adapters/ExplicitModelAdapter.h
@@ -1,6 +1,6 @@
/*
* File: ExplicitModelAdapter.h
- * Author: Gereon Kremer
+ * Author: Christian Dehnert
*
* Created on March 15, 2013, 11:42 AM
*/
@@ -27,6 +27,7 @@
#include "src/models/Ctmdp.h"
#include "src/models/AtomicPropositionsLabeling.h"
#include "src/storage/SparseMatrix.h"
+#include "src/storage/LabeledValues.h"
#include "src/settings/Settings.h"
#include "src/exceptions/WrongFormatException.h"
@@ -71,6 +72,71 @@ namespace storm {
}
};
+ // A structure holding information about a particular choice.
+ template<typename ValueType>
+ struct Choice {
+ Choice(std::string const& actionLabel) : distribution(), actionLabel(actionLabel), choiceLabels() {
+ // Intentionally left empty.
+ }
+
+ /*!
+ * Returns an iterator to the first element of this choice.
+ *
+ * @return An iterator to the first element of this choice.
+ */
+ typename std::map<uint_fast64_t, ValueType>::const_iterator begin() const {
+ return distribution.cbegin();
+ }
+
+ /*!
+ * Returns an iterator that points past the elements of this choice.
+ *
+ * @return An iterator that points past the elements of this choice.
+ */
+ typename std::map<uint_fast64_t, ValueType>::const_iterator end() const {
+ return distribution.cend();
+ }
+
+ /*!
+ * Adds the given label to the labels associated with this choice.
+ *
+ * @param label The label to associate with this choice.
+ */
+ void addChoiceLabel(uint_fast64_t label) {
+ choiceLabels.insert(label);
+ }
+
+ // The distribution that is associated with the choice.
+ std::map<uint_fast64_t, ValueType> distribution;
+
+ // The label of the choice.
+ std::string actionLabel;
+
+ // The labels that are associated with this choice.
+ std::set<uint_fast64_t> choiceLabels;
+ };
+
+ template<typename ValueType>
+ void addProbabilityToChoice(Choice<ValueType>& choice, uint_fast64_t state, ValueType probability, std::set<uint_fast64_t> const& labels) {
+ auto stateProbabilityPair = choice.distribution.find(state);
+
+ if (stateProbabilityPair == choice.distribution.end()) {
+ choice.distribution[state] = probability;
+ } else {
+ choice.distribution[state] += probability;
+ }
+ }
+
+ template<typename ValueType>
+ void addProbabilityToChoice(Choice<storm::storage::LabeledValues<ValueType>>& choice, uint_fast64_t state, ValueType probability, std::set<uint_fast64_t> const& labels) {
+ auto stateProbabilityPair = choice.distribution.find(state);
+
+ if (stateProbabilityPair == choice.distribution.end()) {
+ choice.distribution[state] = storm::storage::LabeledValues<ValueType>();
+ }
+ choice.distribution[state].addValue(probability);
+ }
+
template<typename ValueType>
class ExplicitModelAdapter {
public:
@@ -80,9 +146,16 @@ namespace storm {
// Intentionally left empty.
}
+ // A list of reachable states.
std::vector<StateType*> reachableStates;
+
+ // A mapping from states to indices in the list of reachable states.
std::unordered_map<StateType*, uint_fast64_t, StateHash, StateCompare> stateToIndexMap;
+
+ // A vector storing the number of choices for each state.
std::vector<uint_fast64_t> numberOfChoices;
+
+ // The total number of transitions discovered.
uint_fast64_t numberOfTransitions;
};
@@ -92,12 +165,23 @@ namespace storm {
// Intentionally left empty.
}
- storm::storage::SparseMatrix<double> transitionMatrix;
+ // The transition matrix.
+ storm::storage::SparseMatrix<ValueType> transitionMatrix;
+
+ // The state labeling.
storm::models::AtomicPropositionsLabeling stateLabeling;
+
+ // A vector indicating at which row the choices for a particular state begin.
std::vector<uint_fast64_t> nondeterministicChoiceIndices;
- std::vector<double> stateRewards;
- storm::storage::SparseMatrix<double> transitionRewardMatrix;
- std::vector<std::list<uint_fast64_t>> choiceLabeling;
+
+ // The state reward vector.
+ std::vector<ValueType> stateRewards;
+
+ // A matrix storing the reward for particular transitions.
+ storm::storage::SparseMatrix<ValueType> transitionRewardMatrix;
+
+ // A vector that stores a labeling for each choice.
+ std::vector<std::set<uint_fast64_t>> choiceLabeling;
};
// A structure storing information about the used variables of the program.
@@ -131,26 +215,25 @@ namespace storm {
* rewards.
* @return The explicit model that was given by the probabilistic program.
*/
- static std::shared_ptr<storm::models::AbstractModel<double>> translateProgram(storm::ir::Program program, std::string const& constantDefinitionString = "", std::string const& rewardModelName = "") {
+ static std::shared_ptr<storm::models::AbstractModel<ValueType>> translateProgram(storm::ir::Program program, std::string const& constantDefinitionString = "", std::string const& rewardModelName = "") {
// Start by defining the undefined constants in the model.
defineUndefinedConstants(program, constantDefinitionString);
ModelComponents modelComponents = buildModelComponents(program, rewardModelName);
- std::shared_ptr<storm::models::AbstractModel<double>> result;
+ std::shared_ptr<storm::models::AbstractModel<ValueType>> result;
switch (program.getModelType()) {
case storm::ir::Program::DTMC:
- result = std::shared_ptr<storm::models::AbstractModel<double>>(new storm::models::Dtmc<double>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.stateRewards), std::move(modelComponents.transitionRewardMatrix), std::move(modelComponents.choiceLabeling)));
+ result = std::shared_ptr<storm::models::AbstractModel<ValueType>>(new storm::models::Dtmc<ValueType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.stateRewards), std::move(modelComponents.transitionRewardMatrix), std::move(modelComponents.choiceLabeling)));
break;
case storm::ir::Program::CTMC:
- result = std::shared_ptr<storm::models::AbstractModel<double>>(new storm::models::Ctmc<double>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.stateRewards), std::move(modelComponents.transitionRewardMatrix), std::move(modelComponents.choiceLabeling)));
- break;
+ result = std::shared_ptr<storm::models::AbstractModel<ValueType>>(new storm::models::Ctmc<ValueType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.stateRewards), std::move(modelComponents.transitionRewardMatrix), std::move(modelComponents.choiceLabeling)));
break;
case storm::ir::Program::MDP:
- result = std::shared_ptr<storm::models::AbstractModel<double>>(new storm::models::Mdp<double>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.nondeterministicChoiceIndices), std::move(modelComponents.stateRewards), std::move(modelComponents.transitionRewardMatrix), std::move(modelComponents.choiceLabeling)));
+ result = std::shared_ptr<storm::models::AbstractModel<ValueType>>(new storm::models::Mdp<ValueType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.nondeterministicChoiceIndices), std::move(modelComponents.stateRewards), std::move(modelComponents.transitionRewardMatrix), std::move(modelComponents.choiceLabeling)));
break;
case storm::ir::Program::CTMDP:
- result = std::shared_ptr<storm::models::AbstractModel<double>>(new storm::models::Ctmdp<double>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.nondeterministicChoiceIndices), std::move(modelComponents.stateRewards), std::move(modelComponents.transitionRewardMatrix), std::move(modelComponents.choiceLabeling)));
+ result = std::shared_ptr<storm::models::AbstractModel<ValueType>>(new storm::models::Ctmdp<ValueType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.nondeterministicChoiceIndices), std::move(modelComponents.stateRewards), std::move(modelComponents.transitionRewardMatrix), std::move(modelComponents.choiceLabeling)));
break;
default:
LOG4CPLUS_ERROR(logger, "Error while creating model from probabilistic program: cannot handle this model type.");
@@ -681,8 +764,8 @@ namespace storm {
return result;
}
- static std::list<std::map<uint_fast64_t, ValueType>> getUnlabeledTransitions(storm::ir::Program const& program, StateInformation const& stateInformation, VariableInformation const& variableInformation, uint_fast64_t stateIndex) {
- std::list<std::map<uint_fast64_t, ValueType>> result;
+ static std::list<Choice<ValueType>> getUnlabeledTransitions(storm::ir::Program const& program, StateInformation const& stateInformation, VariableInformation const& variableInformation, uint_fast64_t stateIndex) {
+ std::list<Choice<ValueType>> result;
StateType const* currentState = stateInformation.reachableStates[stateIndex];
@@ -699,8 +782,9 @@ namespace storm {
// Skip the command, if it is not enabled.
if (!command.getGuard()->getValueAsBool(currentState)) continue;
- result.push_back(std::map<uint_fast64_t, ValueType>());
- std::map<uint_fast64_t, ValueType>& targetStates = result.back();
+ result.push_back(Choice<ValueType>(""));
+ Choice<ValueType>& choice = result.back();
+ choice.addChoiceLabel(command.getGlobalIndex());
double probabilitySum = 0;
// Iterate over all updates of the current command.
@@ -711,13 +795,12 @@ namespace storm {
uint_fast64_t targetStateIndex = stateInformation.stateToIndexMap.at(applyUpdate(variableInformation, currentState, update));
// Check, if we already saw this state in another update and, if so, add up probabilities.
- probabilitySum += update.getLikelihoodExpression()->getValueAsDouble(currentState);
- auto stateIt = targetStates.find(targetStateIndex);
- if (stateIt == targetStates.end()) {
- targetStates[targetStateIndex] = update.getLikelihoodExpression()->getValueAsDouble(currentState);
- } else {
- targetStates[targetStateIndex] += update.getLikelihoodExpression()->getValueAsDouble(currentState);
- }
+ double probabilityToAdd = update.getLikelihoodExpression()->getValueAsDouble(currentState);
+ probabilitySum += probabilityToAdd;
+ std::set<uint_fast64_t> labels;
+ // FIXME: We have to retrieve the index of the update here, which is currently not possible.
+ // labels.insert(update.getGlobalIndex());
+ addProbabilityToChoice(choice, targetStateIndex, probabilityToAdd, labels);
}
// Check that the resulting distribution is in fact a distribution.
@@ -731,8 +814,8 @@ namespace storm {
return result;
}
- static std::list<std::map<uint_fast64_t, ValueType>> getLabeledTransitions(storm::ir::Program const& program, StateInformation const& stateInformation, VariableInformation const& variableInformation, uint_fast64_t stateIndex) {
- std::list<std::map<uint_fast64_t, ValueType>> result;
+ static std::list<Choice<ValueType>> getLabeledTransitions(storm::ir::Program const& program, StateInformation const& stateInformation, VariableInformation const& variableInformation, uint_fast64_t stateIndex) {
+ std::list<Choice<ValueType>> result;
for (std::string const& action : program.getActions()) {
StateType const* currentState = stateInformation.reachableStates[stateIndex];
@@ -791,14 +874,21 @@ namespace storm {
// At this point, we applied all commands of the current command combination and newTargetStates
// contains all target states and their respective probabilities. That means we are now ready to
// add the choice to the list of transitions.
- result.push_back(std::map<uint_fast64_t, ValueType>());
-
+ result.push_back(Choice<ValueType>(action));
+
// Now create the actual distribution.
- std::map<uint_fast64_t, ValueType>& targetStates = result.back();
+ Choice<ValueType>& choice = result.back();
+
+ // Add the labels of all commands to this choice.
+ for (uint_fast64_t i = 0; i < iteratorList.size(); ++i) {
+ choice.addChoiceLabel(iteratorList[i]->getGlobalIndex());
+ }
+
double probabilitySum = 0;
+ std::set<uint_fast64_t> labels;
for (auto const& stateProbabilityPair : *newTargetStates) {
uint_fast64_t newStateIndex = stateInformation.stateToIndexMap.at(stateProbabilityPair.first);
- targetStates[newStateIndex] = stateProbabilityPair.second;
+ addProbabilityToChoice(choice, newStateIndex, stateProbabilityPair.second, labels);
probabilitySum += stateProbabilityPair.second;
}
@@ -835,22 +925,24 @@ namespace storm {
/*!
*
*/
- static std::vector<uint_fast64_t> buildTransitionMatrix(storm::ir::Program const& program, VariableInformation const& variableInformation, storm::ir::RewardModel const& rewardModel, StateInformation const& stateInformation, bool deterministicModel, storm::storage::SparseMatrix<ValueType>& transitionMatrix, storm::storage::SparseMatrix<ValueType>& transitionRewardMatrix) {
+ static std::pair<std::vector<uint_fast64_t>, std::vector<std::set<uint_fast64_t>>> buildMatrices(storm::ir::Program const& program, VariableInformation const& variableInformation, std::vector<storm::ir::TransitionReward> const& transitionRewards, StateInformation const& stateInformation, bool deterministicModel, storm::storage::SparseMatrix<ValueType>& transitionMatrix, storm::storage::SparseMatrix<ValueType>& transitionRewardMatrix) {
std::vector<uint_fast64_t> nondeterministicChoiceIndices(stateInformation.reachableStates.size() + 1);
+ std::vector<std::set<uint_fast64_t>> choiceLabels;
// Add transitions and rewards for all states.
uint_fast64_t currentRow = 0;
for (uint_fast64_t currentState = 0; currentState < stateInformation.reachableStates.size(); ++currentState) {
// Retrieve all choices for the current state.
- std::list<std::map<uint_fast64_t, ValueType>> allChoices = getUnlabeledTransitions(program, stateInformation, variableInformation, currentState);
- std::list<std::map<uint_fast64_t, ValueType>> allLabeledChoices = getLabeledTransitions(program, stateInformation, variableInformation, currentState);
- allChoices.insert(allChoices.end(), allLabeledChoices.begin(), allLabeledChoices.end());
+ std::list<Choice<ValueType>> allUnlabeledChoices = getUnlabeledTransitions(program, stateInformation, variableInformation, currentState);
+ std::list<Choice<ValueType>> allLabeledChoices = getLabeledTransitions(program, stateInformation, variableInformation, currentState);
+
+ uint_fast64_t totalNumberOfChoices = allUnlabeledChoices.size() + allLabeledChoices.size();
// If the current state does not have a single choice, we equip it with a self-loop if that was
// requested and issue an error otherwise.
- if (allChoices.size() == 0) {
+ if (totalNumberOfChoices == 0) {
if (storm::settings::Settings::getInstance()->isSet("fixDeadlocks")) {
- transitionMatrix.insertNextValue(currentRow, currentState, 1);
+ transitionMatrix.insertNextValue(currentRow, currentState, storm::utility::constGetOne<ValueType>());
++currentRow;
} else {
LOG4CPLUS_ERROR(logger, "Error while creating sparse matrix from probabilistic program: found deadlock state. For fixing these, please provide the appropriate option.");
@@ -861,21 +953,35 @@ namespace storm {
// or compose them to one choice.
if (deterministicModel) {
std::map<uint_fast64_t, ValueType> globalDistribution;
+ std::set<uint_fast64_t> allChoiceLabels;
// Combine all the choices and scale them with the total number of choices of the current state.
- for (auto const& choice : allChoices) {
+ for (auto const& choice : allUnlabeledChoices) {
+ allChoiceLabels.insert(choice.choiceLabels.begin(), choice.choiceLabels.end());
+ for (auto const& stateProbabilityPair : choice) {
+ auto existingStateProbabilityPair = globalDistribution.find(stateProbabilityPair.first);
+ if (existingStateProbabilityPair == globalDistribution.end()) {
+ globalDistribution[stateProbabilityPair.first] += stateProbabilityPair.second / totalNumberOfChoices;
+ } else {
+ globalDistribution[stateProbabilityPair.first] = stateProbabilityPair.second / totalNumberOfChoices;
+ }
+ }
+ }
+ for (auto const& choice : allLabeledChoices) {
for (auto const& stateProbabilityPair : choice) {
auto existingStateProbabilityPair = globalDistribution.find(stateProbabilityPair.first);
if (existingStateProbabilityPair == globalDistribution.end()) {
- globalDistribution[stateProbabilityPair.first] += stateProbabilityPair.second / allChoices.size();
+ globalDistribution[stateProbabilityPair.first] += stateProbabilityPair.second / totalNumberOfChoices;
} else {
- globalDistribution[stateProbabilityPair.first] = stateProbabilityPair.second / allChoices.size();
+ globalDistribution[stateProbabilityPair.first] = stateProbabilityPair.second / totalNumberOfChoices;
}
}
}
+
// Now add the resulting distribution as the only choice of the current state.
nondeterministicChoiceIndices[currentState] = currentRow;
+ choiceLabels.push_back(allChoiceLabels);
for (auto const& stateProbabilityPair : globalDistribution) {
transitionMatrix.insertNextValue(currentRow, stateProbabilityPair.first, stateProbabilityPair.second);
@@ -885,10 +991,54 @@ namespace storm {
} else {
// If the model is nondeterministic, we add all choices individually.
nondeterministicChoiceIndices[currentState] = currentRow;
- for (auto const& choice : allChoices) {
+
+ // First, process all unlabeled choices.
+ for (auto const& choice : allUnlabeledChoices) {
+ std::map<uint_fast64_t, ValueType> stateToRewardMap;
+ choiceLabels.emplace_back(std::move(choice.choiceLabels));
+
+ for (auto const& stateProbabilityPair : choice) {
+ transitionMatrix.insertNextValue(currentRow, stateProbabilityPair.first, stateProbabilityPair.second);
+
+ // Now add all rewards that match this choice.
+ for (auto const& transitionReward : transitionRewards) {
+ if (transitionReward.getActionName() == "" && transitionReward.getStatePredicate()->getValueAsBool(stateInformation.reachableStates.at(currentState))) {
+ stateToRewardMap[stateProbabilityPair.first] += transitionReward.getRewardValue()->getValueAsDouble(stateInformation.reachableStates.at(currentState));
+ }
+ }
+
+ }
+
+ // Add all transition rewards to the matrix.
+ for (auto const& stateRewardPair : stateToRewardMap) {
+ transitionRewardMatrix.insertNextValue(currentRow, stateRewardPair.first, stateRewardPair.second);
+ }
+
+ ++currentRow;
+ }
+
+ // Then, process all labeled choices.
+ for (auto const& choice : allLabeledChoices) {
+ std::map<uint_fast64_t, ValueType> stateToRewardMap;
+ choiceLabels.emplace_back(std::move(choice.choiceLabels));
+
for (auto const& stateProbabilityPair : choice) {
transitionMatrix.insertNextValue(currentRow, stateProbabilityPair.first, stateProbabilityPair.second);
+
+ // Now add all rewards that match this choice.
+ for (auto const& transitionReward : transitionRewards) {
+ if (transitionReward.getActionName() == "" && transitionReward.getStatePredicate()->getValueAsBool(stateInformation.reachableStates.at(currentState))) {
+ stateToRewardMap[stateProbabilityPair.first] += transitionReward.getRewardValue()->getValueAsDouble(stateInformation.reachableStates.at(currentState));
+ }
+ }
+
}
+
+ // Add all transition rewards to the matrix.
+ for (auto const& stateRewardPair : stateToRewardMap) {
+ transitionRewardMatrix.insertNextValue(currentRow, stateRewardPair.first, stateRewardPair.second);
+ }
+
++currentRow;
}
}
@@ -897,7 +1047,7 @@ namespace storm {
nondeterministicChoiceIndices[stateInformation.reachableStates.size()] = currentRow;
- return nondeterministicChoiceIndices;
+ return std::make_pair(nondeterministicChoiceIndices, choiceLabels);
}
/*!
@@ -934,9 +1084,13 @@ namespace storm {
modelComponents.transitionRewardMatrix.initialize();
}
- storm::ir::RewardModel rewardModel = rewardModelName != "" ? program.getRewardModel(rewardModelName) : storm::ir::RewardModel();
+ // Get the selected reward model or create an empty one if none is selected.
+ storm::ir::RewardModel const& rewardModel = rewardModelName != "" ? program.getRewardModel(rewardModelName) : storm::ir::RewardModel();
- modelComponents.nondeterministicChoiceIndices = buildTransitionMatrix(program, variableInformation, rewardModel, stateInformation, deterministicModel, modelComponents.transitionMatrix, modelComponents.transitionRewardMatrix);
+ // Build the transition and reward matrices.
+ std::pair<std::vector<uint_fast64_t>, std::vector<std::set<uint_fast64_t>>> nondeterministicChoiceIndicesAndChoiceLabelsPair = buildMatrices(program, variableInformation, rewardModel.getTransitionRewards(), stateInformation, deterministicModel, modelComponents.transitionMatrix, modelComponents.transitionRewardMatrix);
+ modelComponents.nondeterministicChoiceIndices = std::move(nondeterministicChoiceIndicesAndChoiceLabelsPair.first);
+ modelComponents.choiceLabeling = std::move(nondeterministicChoiceIndicesAndChoiceLabelsPair.second);
// Finalize the resulting matrices.
modelComponents.transitionMatrix.finalize();
@@ -997,63 +1151,6 @@ namespace storm {
}
return result;
}
-
- /*!
- * Retrieves the state rewards for every reachable state based on the given state rewards.
- *
- * @param rewards The rewards to use.
- * @return The reward values for every (reachable) state.
- */
-// static std::vector<double> getStateRewards(std::vector<storm::ir::StateReward> const& rewards);
-
- /*!
- * Computes the labels for every reachable state based on a list of available labels.
- *
- * @param labels A mapping from label names to boolean expressions to use for the labeling.
- * @return The resulting labeling.
- */
-// static storm::models::AtomicPropositionsLabeling getStateLabeling(std::map<std::string, std::shared_ptr<storm::ir::expressions::BaseExpression>> labels);
-
- /*!
- * Builds the transition matrix of a deterministic model from the current list of transitions.
- *
- * @return The transition matrix.
- */
-// static storm::storage::SparseMatrix<double> buildDeterministicMatrix();
-
- /*!
- * Builds the transition matrix of a nondeterministic model from the current list of transitions.
- *
- * @return result The transition matrix.
- */
-// static storm::storage::SparseMatrix<double> buildNondeterministicMatrix();
-
- /*!
- * Generate the (internal) list of all transitions of the model.
- */
-// void buildTransitionMap();
-
- //// Members that are filled during the conversion.
- // The selected reward model.
- std::unique_ptr<storm::ir::RewardModel> rewardModel;
-
- // The number of choices for each state of a nondeterministic model.
- std::vector<uint_fast64_t> choiceIndices;
-
- // The result of the translation of transition rewards to a sparse matrix (if any).
- boost::optional<storm::storage::SparseMatrix<double>> transitionRewards;
-
- // A labeling for the choices of each state.
- std::vector<std::list<uint_fast64_t>> choiceLabeling;
-
- /*!
- * Maps a source state to a list of probability distributions over target states. Each distribution
- * corresponds to an unlabeled command or a feasible combination of labeled commands. Therefore, each
- * distribution is represented by a structure that contains the label of the participating commands, a list
- * of labels associated with that particular command combination and a mapping from target states to their
- * probabilities.
- */
- std::map<uint_fast64_t, std::list<std::pair<std::pair<std::string, std::list<uint_fast64_t>>, std::map<uint_fast64_t, double>>>> transitionMap;
};
} // namespace adapters
diff --git a/src/models/AbstractDeterministicModel.h b/src/models/AbstractDeterministicModel.h
index 53d95449e..d2e24cbbd 100644
--- a/src/models/AbstractDeterministicModel.h
+++ b/src/models/AbstractDeterministicModel.h
@@ -29,7 +29,7 @@ class AbstractDeterministicModel: public AbstractModel<T> {
*/
AbstractDeterministicModel(storm::storage::SparseMatrix<T> const& transitionMatrix, storm::models::AtomicPropositionsLabeling const& stateLabeling,
boost::optional<std::vector<T>> const& optionalStateRewardVector, boost::optional<storm::storage::SparseMatrix<T>> const& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>> const& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>> const& optionalChoiceLabeling)
: AbstractModel<T>(transitionMatrix, stateLabeling, optionalStateRewardVector, optionalTransitionRewardMatrix, optionalChoiceLabeling) {
}
@@ -43,7 +43,7 @@ class AbstractDeterministicModel: public AbstractModel<T> {
*/
AbstractDeterministicModel(storm::storage::SparseMatrix<T>&& transitionMatrix, storm::models::AtomicPropositionsLabeling&& stateLabeling,
boost::optional<std::vector<T>>&& optionalStateRewardVector, boost::optional<storm::storage::SparseMatrix<T>>&& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>>&& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>>&& optionalChoiceLabeling)
// The std::move call must be repeated here because otherwise this calls the copy constructor of the Base Class
: AbstractModel<T>(std::move(transitionMatrix), std::move(stateLabeling), std::move(optionalStateRewardVector), std::move(optionalTransitionRewardMatrix),
std::move(optionalChoiceLabeling)) {
@@ -116,13 +116,13 @@ class AbstractDeterministicModel: public AbstractModel<T> {
* @return void
*/
virtual void setStateIdBasedChoiceLabeling() override {
- std::vector<std::list<uint_fast64_t>> newChoiceLabeling;
+ std::vector<std::set<uint_fast64_t>> newChoiceLabeling;
size_t stateCount = this->getNumberOfStates();
newChoiceLabeling.resize(stateCount);
for (size_t state = 0; state < stateCount; ++state) {
- newChoiceLabeling.at(state).push_back(state);
+ newChoiceLabeling.at(state).insert(state);
}
this->choiceLabeling.reset(newChoiceLabeling);
diff --git a/src/models/AbstractModel.h b/src/models/AbstractModel.h
index fa34a1cf3..5a67c3e98 100644
--- a/src/models/AbstractModel.h
+++ b/src/models/AbstractModel.h
@@ -71,7 +71,7 @@ class AbstractModel: public std::enable_shared_from_this<AbstractModel<T>> {
*/
AbstractModel(storm::storage::SparseMatrix<T> const& transitionMatrix, storm::models::AtomicPropositionsLabeling const& stateLabeling,
boost::optional<std::vector<T>> const& optionalStateRewardVector, boost::optional<storm::storage::SparseMatrix<T>> const& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>> const& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>> const& optionalChoiceLabeling)
: transitionMatrix(transitionMatrix), stateLabeling(stateLabeling) {
if (optionalStateRewardVector) {
@@ -95,7 +95,7 @@ class AbstractModel: public std::enable_shared_from_this<AbstractModel<T>> {
*/
AbstractModel(storm::storage::SparseMatrix<T>&& transitionMatrix, storm::models::AtomicPropositionsLabeling&& stateLabeling,
boost::optional<std::vector<T>>&& optionalStateRewardVector, boost::optional<storm::storage::SparseMatrix<T>>&& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>>&& optionalChoiceLabeling) :
+ boost::optional<std::vector<std::set<uint_fast64_t>>>&& optionalChoiceLabeling) :
transitionMatrix(std::move(transitionMatrix)), choiceLabeling(std::move(optionalChoiceLabeling)),
stateLabeling(std::move(stateLabeling)), stateRewardVector(std::move(optionalStateRewardVector)),
transitionRewardMatrix(std::move(optionalTransitionRewardMatrix)) {
@@ -359,7 +359,7 @@ class AbstractModel: public std::enable_shared_from_this<AbstractModel<T>> {
* Returns the labels for the choices of the model, if there are any.
* @return The labels for the choices of the model.
*/
- std::vector<std::list<uint_fast64_t>> const& getChoiceLabeling() const {
+ std::vector<std::set<uint_fast64_t>> const& getChoiceLabeling() const {
return choiceLabeling.get();
}
@@ -538,7 +538,7 @@ protected:
storm::storage::SparseMatrix<T> transitionMatrix;
/*! The labeling that is associated with the choices for each state. */
- boost::optional<std::vector<std::list<uint_fast64_t>>> choiceLabeling;
+ boost::optional<std::vector<std::set<uint_fast64_t>>> choiceLabeling;
private:
/*! The labeling of the states of the model. */
storm::models::AtomicPropositionsLabeling stateLabeling;
diff --git a/src/models/AbstractNondeterministicModel.h b/src/models/AbstractNondeterministicModel.h
index 9e01e224f..bb6b0fd37 100644
--- a/src/models/AbstractNondeterministicModel.h
+++ b/src/models/AbstractNondeterministicModel.h
@@ -34,7 +34,7 @@ class AbstractNondeterministicModel: public AbstractModel<T> {
std::vector<uint_fast64_t> const& nondeterministicChoiceIndices,
boost::optional<std::vector<T>> const& optionalStateRewardVector,
boost::optional<storm::storage::SparseMatrix<T>> const& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>> const& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>> const& optionalChoiceLabeling)
: AbstractModel<T>(transitionMatrix, stateLabeling, optionalStateRewardVector, optionalTransitionRewardMatrix, optionalChoiceLabeling) {
this->nondeterministicChoiceIndices = nondeterministicChoiceIndices;
}
@@ -54,7 +54,7 @@ class AbstractNondeterministicModel: public AbstractModel<T> {
std::vector<uint_fast64_t>&& nondeterministicChoiceIndices,
boost::optional<std::vector<T>>&& optionalStateRewardVector,
boost::optional<storm::storage::SparseMatrix<T>>&& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>>&& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>>&& optionalChoiceLabeling)
// The std::move call must be repeated here because otherwise this calls the copy constructor of the Base Class
: AbstractModel<T>(std::move(transitionMatrix), std::move(stateLabeling), std::move(optionalStateRewardVector), std::move(optionalTransitionRewardMatrix),
std::move(optionalChoiceLabeling)), nondeterministicChoiceIndices(std::move(nondeterministicChoiceIndices)) {
@@ -225,7 +225,7 @@ class AbstractNondeterministicModel: public AbstractModel<T> {
* @return void
*/
virtual void setStateIdBasedChoiceLabeling() override {
- std::vector<std::list<uint_fast64_t>> newChoiceLabeling;
+ std::vector<std::set<uint_fast64_t>> newChoiceLabeling;
size_t stateCount = this->getNumberOfStates();
size_t choiceCount = this->getNumberOfChoices();
@@ -233,7 +233,7 @@ class AbstractNondeterministicModel: public AbstractModel<T> {
for (size_t state = 0; state < stateCount; ++state) {
for (size_t choice = this->nondeterministicChoiceIndices.at(state); choice < this->nondeterministicChoiceIndices.at(state + 1); ++choice) {
- newChoiceLabeling.at(choice).push_back(state);
+ newChoiceLabeling.at(choice).insert(state);
}
}
diff --git a/src/models/AtomicPropositionsLabeling.h b/src/models/AtomicPropositionsLabeling.h
index 9ad1dfb86..f4ba0de50 100644
--- a/src/models/AtomicPropositionsLabeling.h
+++ b/src/models/AtomicPropositionsLabeling.h
@@ -40,7 +40,7 @@ public:
* @param apCountMax The number of atomic propositions.
*/
AtomicPropositionsLabeling(const uint_fast64_t stateCount = 0, uint_fast64_t const apCountMax = 0)
- : stateCount(stateCount), apCountMax(apCountMax), apsCurrent(0), singleLabelings() {
+ : stateCount(stateCount), apCountMax(apCountMax), apsCurrent(0), nameToLabelingMap(), singleLabelings() {
singleLabelings.reserve(apCountMax);
}
@@ -159,7 +159,7 @@ public:
* @return True if the proposition is registered within the labeling, false otherwise.
*/
bool containsAtomicProposition(std::string const& ap) const {
- return (nameToLabelingMap.count(ap) != 0);
+ return nameToLabelingMap.find(ap) != nameToLabelingMap.end();
}
/*!
@@ -279,8 +279,7 @@ public:
}
}
- std::unordered_map<std::string, uint_fast64_t> const& getNameToLabelingMap() const
- {
+ std::unordered_map<std::string, uint_fast64_t> const& getNameToLabelingMap() const {
return this->nameToLabelingMap;
}
diff --git a/src/models/Ctmc.h b/src/models/Ctmc.h
index 9febcfb5f..787649540 100644
--- a/src/models/Ctmc.h
+++ b/src/models/Ctmc.h
@@ -37,7 +37,7 @@ public:
*/
Ctmc(storm::storage::SparseMatrix<T> const& rateMatrix, storm::models::AtomicPropositionsLabeling const& stateLabeling,
boost::optional<std::vector<T>> const& optionalStateRewardVector, boost::optional<storm::storage::SparseMatrix<T>> const& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>> const& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>> const& optionalChoiceLabeling)
: AbstractDeterministicModel<T>(rateMatrix, stateLabeling, optionalStateRewardVector, optionalTransitionRewardMatrix, optionalChoiceLabeling) {
// Intentionally left empty.
}
@@ -52,7 +52,7 @@ public:
*/
Ctmc(storm::storage::SparseMatrix<T>&& rateMatrix, storm::models::AtomicPropositionsLabeling&& stateLabeling,
boost::optional<std::vector<T>>&& optionalStateRewardVector, boost::optional<storm::storage::SparseMatrix<T>>&& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>>&& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>>&& optionalChoiceLabeling)
// The std::move call must be repeated here because otherwise this calls the copy constructor of the Base Class
: AbstractDeterministicModel<T>(std::move(rateMatrix), std::move(stateLabeling), std::move(optionalStateRewardVector), std::move(optionalTransitionRewardMatrix),
std::move(optionalChoiceLabeling)) {
diff --git a/src/models/Ctmdp.h b/src/models/Ctmdp.h
index f80525602..c8966357c 100644
--- a/src/models/Ctmdp.h
+++ b/src/models/Ctmdp.h
@@ -42,7 +42,7 @@ public:
std::vector<uint_fast64_t> const& nondeterministicChoiceIndices,
boost::optional<std::vector<T>> const& optionalStateRewardVector,
boost::optional<storm::storage::SparseMatrix<T>> const& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>> const& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>> const& optionalChoiceLabeling)
: AbstractNondeterministicModel<T>(probabilityMatrix, stateLabeling, nondeterministicChoiceIndices, optionalStateRewardVector, optionalTransitionRewardMatrix,
optionalChoiceLabeling) {
if (!this->checkValidityOfProbabilityMatrix()) {
@@ -65,7 +65,7 @@ public:
std::vector<uint_fast64_t>&& nondeterministicChoiceIndices,
boost::optional<std::vector<T>>&& optionalStateRewardVector,
boost::optional<storm::storage::SparseMatrix<T>>&& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>> const& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>> const& optionalChoiceLabeling)
// The std::move call must be repeated here because otherwise this calls the copy constructor of the Base Class
: AbstractNondeterministicModel<T>(std::move(probabilityMatrix), std::move(stateLabeling), std::move(nondeterministicChoiceIndices), std::move(optionalStateRewardVector), std::move(optionalTransitionRewardMatrix),
std::move(optionalChoiceLabeling)) {
diff --git a/src/models/Dtmc.h b/src/models/Dtmc.h
index 0254204bb..849a42344 100644
--- a/src/models/Dtmc.h
+++ b/src/models/Dtmc.h
@@ -43,7 +43,7 @@ public:
*/
Dtmc(storm::storage::SparseMatrix<T> const& probabilityMatrix, storm::models::AtomicPropositionsLabeling const& stateLabeling,
boost::optional<std::vector<T>> const& optionalStateRewardVector, boost::optional<storm::storage::SparseMatrix<T>> const& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>> const& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>> const& optionalChoiceLabeling)
: AbstractDeterministicModel<T>(probabilityMatrix, stateLabeling, optionalStateRewardVector, optionalTransitionRewardMatrix, optionalChoiceLabeling) {
if (!this->checkValidityOfProbabilityMatrix()) {
LOG4CPLUS_ERROR(logger, "Probability matrix is invalid.");
@@ -69,7 +69,7 @@ public:
*/
Dtmc(storm::storage::SparseMatrix<T>&& probabilityMatrix, storm::models::AtomicPropositionsLabeling&& stateLabeling,
boost::optional<std::vector<T>>&& optionalStateRewardVector, boost::optional<storm::storage::SparseMatrix<T>>&& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>>&& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>>&& optionalChoiceLabeling)
// The std::move call must be repeated here because otherwise this calls the copy constructor of the Base Class
: AbstractDeterministicModel<T>(std::move(probabilityMatrix), std::move(stateLabeling), std::move(optionalStateRewardVector), std::move(optionalTransitionRewardMatrix),
std::move(optionalChoiceLabeling)) {
diff --git a/src/models/Mdp.h b/src/models/Mdp.h
index 5e0d99955..cb988c90b 100644
--- a/src/models/Mdp.h
+++ b/src/models/Mdp.h
@@ -48,7 +48,7 @@ public:
std::vector<uint_fast64_t> const& nondeterministicChoiceIndices,
boost::optional<std::vector<T>> const& optionalStateRewardVector,
boost::optional<storm::storage::SparseMatrix<T>> const& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>> const& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>> const& optionalChoiceLabeling)
: AbstractNondeterministicModel<T>(transitionMatrix, stateLabeling, nondeterministicChoiceIndices, optionalStateRewardVector, optionalTransitionRewardMatrix, optionalChoiceLabeling) {
if (!this->checkValidityOfProbabilityMatrix()) {
LOG4CPLUS_ERROR(logger, "Probability matrix is invalid.");
@@ -70,7 +70,7 @@ public:
std::vector<uint_fast64_t>&& nondeterministicChoiceIndices,
boost::optional<std::vector<T>>&& optionalStateRewardVector,
boost::optional<storm::storage::SparseMatrix<T>>&& optionalTransitionRewardMatrix,
- boost::optional<std::vector<std::list<uint_fast64_t>>>&& optionalChoiceLabeling)
+ boost::optional<std::vector<std::set<uint_fast64_t>>>&& optionalChoiceLabeling)
// The std::move call must be repeated here because otherwise this calls the copy constructor of the Base Class
: AbstractNondeterministicModel<T>(std::move(transitionMatrix), std::move(stateLabeling), std::move(nondeterministicChoiceIndices), std::move(optionalStateRewardVector), std::move(optionalTransitionRewardMatrix),
std::move(optionalChoiceLabeling)) {
diff --git a/src/parser/DeterministicModelParser.cpp b/src/parser/DeterministicModelParser.cpp
index 03744401b..ec357b3bf 100644
--- a/src/parser/DeterministicModelParser.cpp
+++ b/src/parser/DeterministicModelParser.cpp
@@ -58,7 +58,7 @@ DeterministicModelParserResultContainer<double> parseDeterministicModel(std::str
storm::models::Dtmc<double> DeterministicModelParserAsDtmc(std::string const & transitionSystemFile, std::string const & labelingFile,
std::string const & stateRewardFile, std::string const & transitionRewardFile) {
DeterministicModelParserResultContainer<double> parserResult(std::move(parseDeterministicModel(transitionSystemFile, labelingFile, stateRewardFile, transitionRewardFile)));
- return storm::models::Dtmc<double>(std::move(parserResult.transitionSystem), std::move(parserResult.labeling), std::move(parserResult.stateRewards), std::move(parserResult.transitionRewards), boost::optional<std::vector<std::list<uint_fast64_t>>>());
+ return storm::models::Dtmc<double>(std::move(parserResult.transitionSystem), std::move(parserResult.labeling), std::move(parserResult.stateRewards), std::move(parserResult.transitionRewards), boost::optional<std::vector<std::set<uint_fast64_t>>>());
}
/*!
@@ -69,7 +69,7 @@ storm::models::Dtmc<double> DeterministicModelParserAsDtmc(std::string const & t
storm::models::Ctmc<double> DeterministicModelParserAsCtmc(std::string const & transitionSystemFile, std::string const & labelingFile,
std::string const & stateRewardFile, std::string const & transitionRewardFile) {
DeterministicModelParserResultContainer<double> parserResult(std::move(parseDeterministicModel(transitionSystemFile, labelingFile, stateRewardFile, transitionRewardFile)));
- return storm::models::Ctmc<double>(std::move(parserResult.transitionSystem), std::move(parserResult.labeling), std::move(parserResult.stateRewards), std::move(parserResult.transitionRewards), boost::optional<std::vector<std::list<uint_fast64_t>>>());
+ return storm::models::Ctmc<double>(std::move(parserResult.transitionSystem), std::move(parserResult.labeling), std::move(parserResult.stateRewards), std::move(parserResult.transitionRewards), boost::optional<std::vector<std::set<uint_fast64_t>>>());
}
} /* namespace parser */
diff --git a/src/parser/NondeterministicModelParser.cpp b/src/parser/NondeterministicModelParser.cpp
index bbe39ae02..536a6ec88 100644
--- a/src/parser/NondeterministicModelParser.cpp
+++ b/src/parser/NondeterministicModelParser.cpp
@@ -58,7 +58,7 @@ NondeterministicModelParserResultContainer<double> parseNondeterministicModel(st
storm::models::Mdp<double> NondeterministicModelParserAsMdp(std::string const & transitionSystemFile, std::string const & labelingFile,
std::string const & stateRewardFile, std::string const & transitionRewardFile) {
NondeterministicModelParserResultContainer<double> parserResult = parseNondeterministicModel(transitionSystemFile, labelingFile, stateRewardFile, transitionRewardFile);
- return storm::models::Mdp<double>(std::move(parserResult.transitionSystem), std::move(parserResult.labeling), std::move(parserResult.rowMapping), std::move(parserResult.stateRewards), std::move(parserResult.transitionRewards), boost::optional<std::vector<std::list<uint_fast64_t>>>());
+ return storm::models::Mdp<double>(std::move(parserResult.transitionSystem), std::move(parserResult.labeling), std::move(parserResult.rowMapping), std::move(parserResult.stateRewards), std::move(parserResult.transitionRewards), boost::optional<std::vector<std::set<uint_fast64_t>>>());
}
/*!
@@ -69,7 +69,7 @@ storm::models::Mdp<double> NondeterministicModelParserAsMdp(std::string const &
storm::models::Ctmdp<double> NondeterministicModelParserAsCtmdp(std::string const & transitionSystemFile, std::string const & labelingFile,
std::string const & stateRewardFile, std::string const & transitionRewardFile) {
NondeterministicModelParserResultContainer<double> parserResult = parseNondeterministicModel(transitionSystemFile, labelingFile, stateRewardFile, transitionRewardFile);
- return storm::models::Ctmdp<double>(std::move(parserResult.transitionSystem), std::move(parserResult.labeling), std::move(parserResult.rowMapping), std::move(parserResult.stateRewards), std::move(parserResult.transitionRewards), boost::optional<std::vector<std::list<uint_fast64_t>>>());
+ return storm::models::Ctmdp<double>(std::move(parserResult.transitionSystem), std::move(parserResult.labeling), std::move(parserResult.rowMapping), std::move(parserResult.stateRewards), std::move(parserResult.transitionRewards), boost::optional<std::vector<std::set<uint_fast64_t>>>());
}
} /* namespace parser */
diff --git a/src/storage/BitVector.h b/src/storage/BitVector.h
index d36b4d647..d8c19f523 100644
--- a/src/storage/BitVector.h
+++ b/src/storage/BitVector.h
@@ -343,7 +343,7 @@ public:
* @return A reference to the current bit vector corresponding to the logical "and"
* of the two bit vectors.
*/
- BitVector operator&=(BitVector const& bv) {
+ BitVector& operator&=(BitVector const& bv) {
uint_fast64_t minSize = (bv.bucketCount < this->bucketCount) ? bv.bucketCount : this->bucketCount;
for (uint_fast64_t i = 0; i < minSize; ++i) {
diff --git a/src/storage/LabeledProbabilities.h b/src/storage/LabeledProbabilities.h
deleted file mode 100644
index 262f1fc4c..000000000
--- a/src/storage/LabeledProbabilities.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * LabeledProbabilities.h
- *
- * Created on: 26.09.2013
- * Author: Christian Dehnert
- */
-
-#ifndef STORM_STORAGE_LABELEDPROBABILITIES_H
-#define STORM_STORAGE_LABELEDPROBABILITIES_H
-
-namespace storm {
- namespace storage {
-
- // This class provides the functionality to store a list of probabilities, each of which is labeled with a list
- // of labels.
- template<class Container, class ValueType>
- class LabeledProbabilities {
- public:
- /*!
- * Default-constructs an empty object.
- */
- LabeledProbabilities() : probabilityLabelList() {
- // Intentionally left empty.
- }
-
- /*!
- * Adds a probability to the list of labeled probabilities.
- *
- * @return A reference to the list of labels that is associated with the given probability.
- */
- Container<uint_fast64_t>& addProbability(ValueType probability) {
- probabilityLabelList.emplace_back(probability, Container<uint_fast64_t>());
- return probabilityLabelList.back().second;
- }
-
- /*!
- * Returns an iterator pointing to the first labeled probability.
- *
- * @return An iterator pointing to the first labeled probability.
- */
- Container<std::pair<ValueType, Container<uint_fast64_t>>>::iterator begin() {
- return probabilityLabelList.begin();
- }
-
- /*!
- * Returns an iterator pointing past the last labeled probability.
- *
- * @return An iterator pointing past the last labeled probability.
- */
- Container<std::pair<ValueType, Container<uint_fast64_t>>>::const_iterator end() {
- return probabilityLabelList.end();
- }
-
- /*!
- * Returns a const iterator pointing to the first labeled probability.
- *
- * @return A const iterator pointing to the first labeled probability.
- */
- Container<std::pair<ValueType, Container<uint_fast64_t>>>::const_iterator begin() const {
- return probabilityLabelList.begin();
- }
-
- /*!
- * Returns a const iterator pointing past the last labeled probability.
- *
- * @return A const iterator pointing past the last labeled probability.
- */
- Container<std::pair<ValueType, Container<uint_fast64_t>>>::const_iterator end() const {
- return probabilityLabelList.end();
- }
-
- private:
- // The actual storage used to store the list of probabilities and the associated labels.
- Container<std::pair<ValueType, Container<uint_fast64_t>>> probabilityLabelList;
- };
- }
-}
-
-#endif /* STORM_STORAGE_LABELEDPROBABILITIES_H */
diff --git a/src/storage/LabeledValues.h b/src/storage/LabeledValues.h
new file mode 100644
index 000000000..e8abf35c4
--- /dev/null
+++ b/src/storage/LabeledValues.h
@@ -0,0 +1,180 @@
+/*
+ * LabeledValues.h
+ *
+ * Created on: 26.09.2013
+ * Author: Christian Dehnert
+ */
+
+#ifndef STORM_STORAGE_LABELEDVALUES_H
+#define STORM_STORAGE_LABELEDVALUES_H
+
+#include <list>
+
+namespace storm {
+ namespace utility {
+ template<class ValueType>
+ static ValueType constGetZero();
+ }
+
+ namespace storage {
+ // This class provides the functionality to store a list of values, each of which is labeled with possibly several
+ // labels.
+ template<class ValueType>
+ class LabeledValues {
+ public:
+ /*!
+ * Default-constructs an empty object.
+ */
+ LabeledValues() : valueLabelList() {
+ // Intentionally left empty.
+ }
+
+ /*!
+ * Constructs an object that stores the single probability value without any label.
+ *
+ * @param value The probability to sto
+ */
+ LabeledValues(ValueType value) : valueLabelList() {
+ addValue(value);
+ }
+
+ /*!
+ * Adds an (unlabeled) value to the list of labeled values.
+ *
+ * @param value The value to add.
+ * @return A reference to the list of labels that is associated with the given value.
+ */
+ std::set<uint_fast64_t>& addValue(ValueType value) {
+ valueLabelList.emplace_back(value, std::set<uint_fast64_t>());
+ return valueLabelList.back().second;
+ }
+
+ /*!
+ * Adds a labeled value to the list of labeled values.
+ *
+ * @param value The value to add.
+ * @param labels The labels to associate with this value.
+ * @return A reference to the list of labels that is associated with the given value.
+ */
+ std::set<uint_fast64_t>& addValue(ValueType value, std::set<uint_fast64_t> const& labels) {
+ valueLabelList.emplace_back(value, labels);
+ return valueLabelList.back().second;
+ }
+
+ /*!
+ * Returns an iterator pointing to the first labeled probability.
+ *
+ * @return An iterator pointing to the first labeled probability.
+ */
+ typename std::list<std::pair<ValueType, std::set<uint_fast64_t>>>::iterator begin() {
+ return valueLabelList.begin();
+ }
+
+ /*!
+ * Returns an iterator pointing past the last labeled probability.
+ *
+ * @return An iterator pointing past the last labeled probability.
+ */
+ typename std::list<std::pair<ValueType, std::set<uint_fast64_t>>>::const_iterator end() {
+ return valueLabelList.end();
+ }
+
+ /*!
+ * Returns a const iterator pointing to the first labeled probability.
+ *
+ * @return A const iterator pointing to the first labeled probability.
+ */
+ typename std::list<std::pair<ValueType, std::set<uint_fast64_t>>>::const_iterator begin() const {
+ return valueLabelList.begin();
+ }
+
+ /*!
+ * Returns a const iterator pointing past the last labeled probability.
+ *
+ * @return A const iterator pointing past the last labeled probability.
+ */
+ typename std::list<std::pair<ValueType, std::set<uint_fast64_t>>>::const_iterator end() const {
+ return valueLabelList.end();
+ }
+
+ /*!
+ * Inserts the contents of this object to the given output stream.
+ *
+ * @param out The stream in which to insert the contents.
+ */
+ friend std::ostream& operator<<(std::ostream& out, LabeledValues const& labeledValues) {
+ out << "[";
+ for (auto const& element : labeledValues) {
+ out << element.first << "(";
+ for (auto const& label : element.second) {
+ out << label << ", ";
+ }
+ out << ")";
+ }
+ out << "]";
+ return out;
+ }
+
+ /*!
+ * Adds all labeled probabilities of the given object to the current one.
+ *
+ * @param labeledProbabilities The labeled probabilities to add to the object.
+ */
+ LabeledValues<ValueType>& operator+=(LabeledValues<ValueType> const& labeledValues) {
+ for (auto const& valueLabelListPair : labeledValues) {
+ this->valueLabelList.push_back(valueLabelListPair);
+ }
+ return *this;
+ }
+
+ /*!
+ * Converts the object into the value type by returning the sum.
+ *
+ * @return The sum of the values.
+ */
+ operator ValueType() const {
+ return this->getSum();
+ }
+
+ /*!
+ * Retrieves the number of separate entries in this object.
+ *
+ * @return The number of separate entries in this object.
+ */
+ size_t size() const {
+ return this->valueLabelList.size();
+ }
+
+ private:
+ // The actual storage used to store the list of values and the associated labels.
+ std::list<std::pair<ValueType, std::set<uint_fast64_t>>> valueLabelList;
+
+ /*!
+ * Returns the sum of the values.
+ *
+ * @return The sum of the values.
+ */
+ ValueType getSum() const {
+ ValueType sum = storm::utility::constGetZero<ValueType>();
+ for (auto const& valueLabelListPair : *this) {
+ sum += valueLabelListPair.first;
+ }
+ return sum;
+ }
+ };
+
+ /*!
+ * Computes the hash value of a given labeled probabilities object.
+ *
+ * @param labeledProbabilities The labeled probabilities object for which to compute the hash value.
+ * @return A hash value for the labeled probabilities object.
+ */
+ template<typename ValueType>
+ std::size_t hash_value(LabeledValues<ValueType> const& labeledValues) {
+ return labeledValues.size();
+ }
+
+ }
+}
+
+#endif /* STORM_STORAGE_LABELEDVALUES_H */
diff --git a/src/storm.cpp b/src/storm.cpp
index 724ce03dd..69072ba12 100644
--- a/src/storm.cpp
+++ b/src/storm.cpp
@@ -332,8 +332,8 @@ int main(const int argc, const char* argv[]) {
} else if (s->isSet("symbolic")) {
std::string const& programFile = s->getOptionByLongName("symbolic").getArgument(0).getValueAsString();
std::string const& constants = s->getOptionByLongName("constants").getArgument(0).getValueAsString();
- std::shared_ptr<storm::models::AbstractModel<double>> model = storm::adapters::ExplicitModelAdapter<double>::translateProgram(storm::parser::PrismParserFromFile(programFile), constants);
- // model->printModelInformationToStream(std::cout);
+ std::shared_ptr<storm::models::AbstractModel<storm::storage::LabeledValues<double>>> model = storm::adapters::ExplicitModelAdapter<storm::storage::LabeledValues<double>>::translateProgram(storm::parser::PrismParserFromFile(programFile), constants);
+ model->printModelInformationToStream(std::cout);
// Enable the following lines to test the MinimalLabelSetGenerator.
// if (model->getType() == storm::models::MDP) {
diff --git a/src/utility/ConstTemplates.h b/src/utility/ConstTemplates.h
index 20704e3c1..71b489c3d 100644
--- a/src/utility/ConstTemplates.h
+++ b/src/utility/ConstTemplates.h
@@ -20,6 +20,7 @@
#include "src/exceptions/InvalidArgumentException.h"
#include "src/storage/BitVector.h"
+#include "src/storage/LabeledValues.h"
namespace storm {
@@ -46,7 +47,7 @@ static inline _Scalar constGetZero() {
*/
/*!
- * Template specification for int_fast32_t
+ * Template specialization for int_fast32_t
* @return Value 0, fit to the type int_fast32_t
*/
template <>
@@ -55,7 +56,7 @@ inline int_fast32_t constGetZero() {
}
/*!
- * Template specification for uint_fast64_t
+ * Template specialization for uint_fast64_t
* @return Value 0, fit to the type uint_fast64_t
*/
template <>
@@ -64,13 +65,22 @@ inline uint_fast64_t constGetZero() {
}
/*!
- * Template specification for double
+ * Template specialization for double
* @return Value 0.0, fit to the type double
*/
template <>
inline double constGetZero() {
return 0.0;
}
+
+/*!
+ * Template specialization for LabeledValues.
+ * @return A LabeledValues object that represents a value of 0.
+ */
+template<>
+inline storm::storage::LabeledValues<double> constGetZero() {
+ return storm::storage::LabeledValues<double>(0.0);
+}
/*! @endcond */
@@ -91,11 +101,11 @@ static inline _Scalar constGetOne() {
}
/*! @cond TEMPLATE_SPECIALIZATION
- * (By default, the template specifications are not included in the documentation)
+ * (By default, the template specializations are not included in the documentation)
*/
/*!
- * Template specification for int_fast32_t
+ * Template specialization for int_fast32_t
* @return Value 1, fit to the type int_fast32_t
*/
template<>
@@ -104,7 +114,7 @@ inline int_fast32_t constGetOne() {
}
/*!
- * Template specification for uint_fast64_t
+ * Template specialization for uint_fast64_t
* @return Value 1, fit to the type uint_fast61_t
*/
template<>
@@ -113,7 +123,7 @@ inline uint_fast64_t constGetOne() {
}
/*!
- * Template specification for double
+ * Template specialization for double
* @return Value 1.0, fit to the type double
*/
template<>
@@ -121,6 +131,15 @@ inline double constGetOne() {
return 1.0;
}
+/*!
+ * Template specialization for LabeledValues.
+ * @return A LabeledValues object that represents a value of 1.
+ */
+template<>
+inline storm::storage::LabeledValues<double> constGetOne() {
+ return storm::storage::LabeledValues<double>(1.0);
+}
+
/*! @endcond */
/*!
@@ -140,11 +159,11 @@ static inline _Scalar constGetInfinity() {
}
/*! @cond TEMPLATE_SPECIALIZATION
- * (By default, the template specifications are not included in the documentation)
+ * (By default, the template specializations are not included in the documentation)
*/
/*!
- * Template specification for int_fast32_t
+ * Template specialization for int_fast32_t
* @return Value Infinity, fit to the type uint_fast32_t
*/
template<>
@@ -154,7 +173,7 @@ inline int_fast32_t constGetInfinity() {
}
/*!
- * Template specification for uint_fast64_t
+ * Template specialization for uint_fast64_t
* @return Value Infinity, fit to the type uint_fast64_t
*/
template<>
@@ -164,7 +183,7 @@ inline uint_fast64_t constGetInfinity() {
}
/*!
- * Template specification for double
+ * Template specialization for double
* @return Value Infinity, fit to the type double
*/
template<>
@@ -172,11 +191,19 @@ inline double constGetInfinity() {
return std::numeric_limits<double>::infinity();
}
+/*!
+ * Template specialization for LabeledValues.
+ * @return Value Infinity, fit to the type LabeledValues.
+ */
+template<>
+inline storm::storage::LabeledValues<double> constGetInfinity() {
+ return storm::storage::LabeledValues<double>(std::numeric_limits<double>::infinity());
+}
+
/*! @endcond */
} //namespace utility
} //namespace storm
-
#endif /* STORM_UTILITY_CONSTTEMPLATES_H_ */