Browse Source
Merge branch 'deterministicScheds' of https://srv-i2.informatik.rwth-aachen.de/scm/git/storm into deterministicScheds
main
Merge branch 'deterministicScheds' of https://srv-i2.informatik.rwth-aachen.de/scm/git/storm into deterministicScheds
main
radioGiorgio
6 years ago
75 changed files with 4524 additions and 2304 deletions
-
261.travis.yml
-
18CMakeLists.txt
-
36resources/doxygen/CMakeLists.txt
-
2891resources/doxygen/Doxyfile.in
-
5resources/examples/testfiles/dft/cyclic.dft
-
15resources/examples/testfiles/dft/fdep_bound.dft
-
40resources/examples/testfiles/dft/hecs_2_2.dft
-
5resources/examples/testfiles/dft/seqChild.dft
-
8resources/examples/testfiles/dft/spare_two_modules.dft
-
24resources/examples/testfiles/dft/symmetry6.dft
-
13src/storm-dft-cli/storm-dft.cpp
-
33src/storm-dft/api/storm-dft.cpp
-
11src/storm-dft/api/storm-dft.h
-
8src/storm-dft/builder/DFTBuilder.cpp
-
2src/storm-dft/builder/DftExplorationHeuristic.h
-
25src/storm-dft/builder/ExplicitDFTModelBuilder.cpp
-
1src/storm-dft/generator/DftNextStateGenerator.cpp
-
1098src/storm-dft/modelchecker/dft/DFTASFChecker.cpp
-
210src/storm-dft/modelchecker/dft/DFTASFChecker.h
-
701src/storm-dft/modelchecker/dft/SmtConstraint.cpp
-
39src/storm-dft/modelchecker/dft/SmtConstraint.h
-
14src/storm-dft/settings/modules/DftIOSettings.cpp
-
15src/storm-dft/settings/modules/DftIOSettings.h
-
40src/storm-dft/settings/modules/FaultTreeSettings.cpp
-
15src/storm-dft/settings/modules/FaultTreeSettings.h
-
13src/storm-dft/storage/dft/DFT.cpp
-
1src/storm-dft/storage/dft/DFT.h
-
2src/storm-dft/storage/dft/DFTState.cpp
-
70src/storm-dft/storage/dft/DFTStateGenerationInfo.h
-
9src/storm-pars/modelchecker/region/SparseDtmcParameterLiftingModelChecker.cpp
-
5src/storm/builder/DdJaniModelBuilder.cpp
-
62src/storm/generator/JaniNextStateGenerator.cpp
-
6src/storm/generator/JaniNextStateGenerator.h
-
2src/storm/logic/EventuallyFormula.cpp
-
14src/storm/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
-
313src/storm/modelchecker/multiobjective/deterministicScheds/DeterministicSchedsLpChecker.cpp
-
10src/storm/modelchecker/multiobjective/deterministicScheds/DeterministicSchedsLpChecker.h
-
4src/storm/modelchecker/multiobjective/deterministicScheds/DeterministicSchedsObjectiveHelper.cpp
-
2src/storm/modelchecker/multiobjective/deterministicScheds/DeterministicSchedsObjectiveHelper.h
-
2src/storm/modelchecker/multiobjective/deterministicScheds/DeterministicSchedsParetoExplorer.cpp
-
1src/storm/modelchecker/multiobjective/pcaa/RewardBoundedMdpPcaaWeightVectorChecker.cpp
-
1src/storm/modelchecker/multiobjective/pcaa/StandardMaPcaaWeightVectorChecker.cpp
-
48src/storm/modelchecker/multiobjective/pcaa/StandardPcaaWeightVectorChecker.cpp
-
52src/storm/modelchecker/prctl/helper/HybridMdpPrctlHelper.cpp
-
36src/storm/modelchecker/prctl/helper/SparseMdpPrctlHelper.cpp
-
8src/storm/modelchecker/prctl/helper/SymbolicMdpPrctlHelper.cpp
-
1src/storm/modelchecker/prctl/helper/rewardbounded/EpochModel.cpp
-
20src/storm/modelchecker/results/ParetoCurveCheckResult.cpp
-
27src/storm/solver/GurobiLpSolver.cpp
-
16src/storm/solver/IterativeMinMaxLinearEquationSolver.cpp
-
2src/storm/solver/LpMinMaxLinearEquationSolver.cpp
-
17src/storm/solver/MinMaxLinearEquationSolver.cpp
-
21src/storm/solver/MinMaxLinearEquationSolver.h
-
25src/storm/solver/MinMaxLinearEquationSolverRequirements.cpp
-
10src/storm/solver/MinMaxLinearEquationSolverRequirements.h
-
2src/storm/solver/SmtSolver.h
-
2src/storm/solver/SymbolicMinMaxLinearEquationSolver.cpp
-
17src/storm/solver/TopologicalMinMaxLinearEquationSolver.cpp
-
3src/storm/storage/Qvbs.cpp
-
9src/storm/storage/expressions/UnaryNumericalFunctionExpression.cpp
-
11src/storm/storage/jani/Model.cpp
-
16src/storm/storage/jani/Model.h
-
9src/storm/storm.cpp
-
41src/test/storm-dft/api/DftModelCheckerTest.cpp
-
10src/test/storm-dft/api/DftParserTest.cpp
-
59src/test/storm-dft/api/DftSmtTest.cpp
-
1src/test/storm/solver/MinMaxLinearEquationSolverTest.cpp
-
33src/test/storm/transformer/EndComponentEliminatorTest.cpp
-
9travis/build.sh
-
59travis/build_helper.sh
-
13travis/deploy_docker.sh
-
47travis/deploy_storm.sh
-
151travis/generate_travis.py
-
3travis/mtime_cache/globs.txt
-
5travis/skip_test.sh
@ -0,0 +1,36 @@ |
|||
# Enable operator IN_LIST to avoid problems with CMake version 3.12 |
|||
if(POLICY CMP0057) |
|||
cmake_policy(SET CMP0057 NEW) |
|||
endif() |
|||
|
|||
find_package(Doxygen) |
|||
# Add a target to generate API documentation with Doxygen |
|||
if(DOXYGEN_FOUND) |
|||
|
|||
# We use the doxygen command of CMake instead of using the separate config file |
|||
set(DOXYGEN_PROJECT_NAME "Storm") |
|||
set(DOXYGEN_PROJECT_BRIEF "A Modern Probabilistic Model Checker") |
|||
set(DOXYGEN_BRIEF_MEMBER_DESC YES) |
|||
set(DOXYGEN_REPEAT_BRIEF YES) |
|||
set(DOXYGEN_JAVADOC_AUTOBRIEF YES) |
|||
set(DOXYGEN_QT_AUTOBRIEF YES) |
|||
set(DOXYGEN_EXTRACT_ALL YES) |
|||
set(DOXYGEN_EXTRACT_STATIC YES) |
|||
set(DOXYGEN_SOURCE_BROWSER YES) |
|||
set(DOXYGEN_GENERATE_TREEVIEW YES) |
|||
set(DOXYGEN_CASE_SENSE_NAMES NO) |
|||
set(DOXYGEN_HTML_TIMESTAMP YES) |
|||
set(DOXYGEN_CREATE_SUBDIRS YES) |
|||
set(DOXYGEN_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/doc") |
|||
doxygen_add_docs( |
|||
doc |
|||
"${PROJECT_SOURCE_DIR}/src" |
|||
COMMENT "Generating API documentation with Doxygen" |
|||
) |
|||
|
|||
# These commands can be used if the separate config files should be used |
|||
#set(CMAKE_DOXYGEN_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/doc") |
|||
#string(REGEX REPLACE ";" " " CMAKE_DOXYGEN_INPUT_LIST "${PROJECT_SOURCE_DIR}/src") |
|||
#configure_file("${CMAKE_CURRENT_SOURCE_DIR}/resources/doxygen/Doxyfile.in.new" "${CMAKE_CURRENT_BINARY_DIR}/Doxyfile" @ONLY) |
|||
#add_custom_target(doc ${DOXYGEN_EXECUTABLE} "${CMAKE_CURRENT_BINARY_DIR}/Doxyfile" DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/Doxyfile" COMMENT "Generating API documentation with Doxygen" VERBATIM) |
|||
endif(DOXYGEN_FOUND) |
|||
2891
resources/doxygen/Doxyfile.in
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,5 @@ |
|||
toplevel "A"; |
|||
"A" and "B"; |
|||
"B" and "C"; |
|||
"C" and "A" "D"; |
|||
"D" lambda=0.5 dorm=0.3; |
|||
@ -0,0 +1,15 @@ |
|||
toplevel "A"; |
|||
"A" or "B" "C"; |
|||
"B" and "D" "L"; |
|||
"C" and "M" "N"; |
|||
"D" and "I" "J" "K"; |
|||
"DEP1" fdep "T" "I" "J" "K"; |
|||
"DEP2" fdep "D" "L"; |
|||
|
|||
"I" lambda=0.5 dorm=0; |
|||
"J" lambda=0.5 dorm=0.5; |
|||
"K" lambda=0.5 dorm=0.5; |
|||
"L" lambda=0.5 dorm=0.5; |
|||
"M" lambda=0.5 dorm=0.5; |
|||
"N" lambda=0.5 dorm=0.5; |
|||
"T" lambda=0.5 dorm=0.5; |
|||
@ -0,0 +1,40 @@ |
|||
toplevel "System"; |
|||
"System" or "System_1" "System_2"; |
|||
"System_1" or "PSF_1" "MSF_1" "BSF_1" "IF_1"; |
|||
"PSF_1" and "P_11" "P_12"; |
|||
"P_11" wsp "A_11" "A_1S"; |
|||
"P_12" wsp "A_12" "A_1S"; |
|||
"MSF_1" 3of5 "M_1_1" "M_1_2" "M_1_3" "M_1_4" "M_1_5"; |
|||
"BSF_1" and "BUS_11" "BUS_12"; |
|||
"IF_1" or "HW_1" "SW_1"; |
|||
"System_2" or "PSF_2" "MSF_2" "BSF_2" "IF_2"; |
|||
"PSF_2" and "P_21" "P_22"; |
|||
"P_21" wsp "A_21" "A_2S"; |
|||
"P_22" wsp "A_22" "A_2S"; |
|||
"MSF_2" 3of5 "M_2_1" "M_2_2" "M_2_3" "M_2_4" "M_2_5"; |
|||
"BSF_2" and "BUS_21" "BUS_22"; |
|||
"IF_2" or "HW_2" "SW_2"; |
|||
"A_11" lambda=1.0e-4 dorm=0; |
|||
"A_12" lambda=1.0e-4 dorm=0; |
|||
"A_1S" lambda=1.0e-4 dorm=0; |
|||
"M_1_1" lambda=6.0e-5 dorm=0; |
|||
"M_1_2" lambda=6.0e-5 dorm=0; |
|||
"M_1_3" lambda=6.0e-5 dorm=0; |
|||
"M_1_4" lambda=6.0e-5 dorm=0; |
|||
"M_1_5" lambda=6.0e-5 dorm=0; |
|||
"BUS_11" lambda=1.0e-6 dorm=0; |
|||
"BUS_12" lambda=1.0e-6 dorm=0; |
|||
"HW_1" lambda=5.0e-5 dorm=0; |
|||
"SW_1" lambda=6.0e-5 dorm=0; |
|||
"A_21" lambda=1.0e-4 dorm=0; |
|||
"A_22" lambda=1.0e-4 dorm=0; |
|||
"A_2S" lambda=1.0e-4 dorm=0; |
|||
"M_2_1" lambda=6.0e-5 dorm=0; |
|||
"M_2_2" lambda=6.0e-5 dorm=0; |
|||
"M_2_3" lambda=6.0e-5 dorm=0; |
|||
"M_2_4" lambda=6.0e-5 dorm=0; |
|||
"M_2_5" lambda=6.0e-5 dorm=0; |
|||
"BUS_21" lambda=1.0e-6 dorm=0; |
|||
"BUS_22" lambda=1.0e-6 dorm=0; |
|||
"HW_2" lambda=5.0e-5 dorm=0; |
|||
"SW_2" lambda=6.0e-5 dorm=0; |
|||
@ -0,0 +1,5 @@ |
|||
toplevel "A"; |
|||
"A" and "B" "X"; |
|||
"X" seq "B" "C"; |
|||
"B" lambda=0.5 dorm=0.3; |
|||
"C" lambda=0.5 dorm=0.3; |
|||
@ -0,0 +1,8 @@ |
|||
toplevel "A"; |
|||
"A" or "B" "C"; |
|||
"B" wsp "K" "J" "I"; |
|||
"C" wsp "L" "J" "I"; |
|||
"I" lambda=0.5 dorm=0.5; |
|||
"J" lambda=1 dorm=0.5; |
|||
"K" lambda=0.5 dorm=0.5; |
|||
"L" lambda=0.5 dorm=0.5; |
|||
@ -0,0 +1,24 @@ |
|||
toplevel "A"; |
|||
"A" or "B" "C"; |
|||
"B" and "J" "K" "L"; |
|||
"J" or "J1" "J2"; |
|||
"K" or "K1" "K2"; |
|||
"L" or "L1" "L2"; |
|||
"C" or "M" "N"; |
|||
"M" and "M1" "M2" "M3" "M4"; |
|||
"N" and "N1" "N2" "N3" "N4"; |
|||
"J1" lambda=0.5 dorm=0; |
|||
"J2" lambda=0.5 dorm=0; |
|||
"K1" lambda=0.5 dorm=0; |
|||
"K2" lambda=0.5 dorm=0; |
|||
"L1" lambda=0.5 dorm=0; |
|||
"L2" lambda=0.5 dorm=0; |
|||
"M1" lambda=0.5 dorm=0; |
|||
"M2" lambda=0.5 dorm=0; |
|||
"M3" lambda=1 dorm=0; |
|||
"M4" lambda=1 dorm=0; |
|||
"N1" lambda=0.5 dorm=0; |
|||
"N2" lambda=0.5 dorm=0; |
|||
"N3" lambda=1 dorm=0; |
|||
"N4" lambda=1 dorm=0; |
|||
|
|||
1098
src/storm-dft/modelchecker/dft/DFTASFChecker.cpp
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,701 @@ |
|||
#include "DFTASFChecker.h"
|
|||
#include <storm/storage/expressions/ExpressionManager.h>
|
|||
#include <string>
|
|||
|
|||
namespace storm { |
|||
|
|||
namespace modelchecker { |
|||
|
|||
/*
|
|||
* Variable[VarIndex] is the maximum of the others |
|||
*/ |
|||
class IsMaximum : public SmtConstraint { |
|||
public: |
|||
IsMaximum(uint64_t varIndex, std::vector<uint64_t> const &varIndices) : varIndex(varIndex), |
|||
varIndices(varIndices) { |
|||
} |
|||
|
|||
virtual ~IsMaximum() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(and "; |
|||
// assert it is largereq than all values.
|
|||
for (auto const &ovi : varIndices) { |
|||
sstr << "(>= " << varNames.at(varIndex) << " " << varNames.at(ovi) << ") "; |
|||
} |
|||
// assert it is one of the values.
|
|||
sstr << "(or "; |
|||
for (auto const &ovi : varIndices) { |
|||
sstr << "(= " << varNames.at(varIndex) << " " << varNames.at(ovi) << ") "; |
|||
} |
|||
sstr << ")"; // end of the or
|
|||
sstr << ")"; // end outer and.
|
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
std::vector<storm::expressions::Expression> outerAnd; |
|||
std::vector<storm::expressions::Expression> innerOr; |
|||
for (auto const &ovi : varIndices) { |
|||
outerAnd.push_back((manager->getVariableExpression(varNames.at(varIndex)) >= |
|||
manager->getVariableExpression(varNames.at(ovi)))); |
|||
innerOr.push_back((manager->getVariableExpression(varNames.at(varIndex)) == |
|||
manager->getVariableExpression(varNames.at(ovi)))); |
|||
} |
|||
outerAnd.push_back(disjunction(innerOr)); |
|||
return conjunction(outerAnd); |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
std::vector<uint64_t> varIndices; |
|||
}; |
|||
|
|||
|
|||
/*
|
|||
* First is the minimum of the others |
|||
*/ |
|||
class IsMinimum : public SmtConstraint { |
|||
public: |
|||
IsMinimum(uint64_t varIndex, std::vector<uint64_t> const &varIndices) : varIndex(varIndex), |
|||
varIndices(varIndices) { |
|||
} |
|||
|
|||
virtual ~IsMinimum() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(and "; |
|||
// assert it is smallereq than all values.
|
|||
for (auto const &ovi : varIndices) { |
|||
sstr << "(<= " << varNames.at(varIndex) << " " << varNames.at(ovi) << ") "; |
|||
} |
|||
// assert it is one of the values.
|
|||
sstr << "(or "; |
|||
for (auto const &ovi : varIndices) { |
|||
sstr << "(= " << varNames.at(varIndex) << " " << varNames.at(ovi) << ") "; |
|||
} |
|||
sstr << ")"; // end of the or
|
|||
sstr << ")"; // end outer and.
|
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
std::vector<storm::expressions::Expression> outerAnd; |
|||
std::vector<storm::expressions::Expression> innerOr; |
|||
for (auto const &ovi : varIndices) { |
|||
outerAnd.push_back((manager->getVariableExpression(varNames.at(varIndex)) <= |
|||
manager->getVariableExpression(varNames.at(ovi)))); |
|||
innerOr.push_back((manager->getVariableExpression(varNames.at(varIndex)) == |
|||
manager->getVariableExpression(varNames.at(ovi)))); |
|||
} |
|||
outerAnd.push_back(disjunction(innerOr)); |
|||
return conjunction(outerAnd); |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
std::vector<uint64_t> varIndices; |
|||
}; |
|||
|
|||
|
|||
class BetweenValues : public SmtConstraint { |
|||
public: |
|||
BetweenValues(uint64_t varIndex, uint64_t lower, uint64_t upper) : varIndex(varIndex), upperBound(upper), |
|||
lowerBound(lower) { |
|||
} |
|||
|
|||
virtual ~BetweenValues() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(and "; |
|||
sstr << "(>= " << varNames.at(varIndex) << " " << lowerBound << ")"; |
|||
sstr << "(<= " << varNames.at(varIndex) << " " << upperBound << ")"; |
|||
sstr << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return (manager->getVariableExpression(varNames.at(varIndex)) >= lowerBound) && |
|||
(manager->getVariableExpression(varNames.at(varIndex)) <= upperBound); |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
uint64_t upperBound; |
|||
uint64_t lowerBound; |
|||
}; |
|||
|
|||
|
|||
class And : public SmtConstraint { |
|||
public: |
|||
And(std::vector<std::shared_ptr<SmtConstraint>> const &constraints) : constraints(constraints) { |
|||
} |
|||
|
|||
virtual ~And() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
if (constraints.empty()) { |
|||
sstr << "true"; |
|||
} else { |
|||
sstr << "(and"; |
|||
for (auto const &c : constraints) { |
|||
sstr << " " << c->toSmtlib2(varNames); |
|||
} |
|||
sstr << ")"; |
|||
} |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
if (constraints.empty()) { |
|||
return manager->boolean(true); |
|||
} else { |
|||
std::vector<storm::expressions::Expression> conjuncts; |
|||
for (auto const &c : constraints) { |
|||
conjuncts.push_back(c->toExpression(varNames, manager)); |
|||
} |
|||
return conjunction(conjuncts); |
|||
} |
|||
} |
|||
|
|||
private: |
|||
std::vector<std::shared_ptr<SmtConstraint>> constraints; |
|||
|
|||
}; |
|||
|
|||
|
|||
class Or : public SmtConstraint { |
|||
public: |
|||
Or(std::vector<std::shared_ptr<SmtConstraint>> const &constraints) : constraints(constraints) { |
|||
} |
|||
|
|||
virtual ~Or() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
if (constraints.empty()) { |
|||
sstr << "false"; |
|||
} else { |
|||
sstr << "(or"; |
|||
for (auto const &c : constraints) { |
|||
sstr << " " << c->toSmtlib2(varNames); |
|||
} |
|||
sstr << ")"; |
|||
} |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
if (constraints.empty()) { |
|||
return manager->boolean(false); |
|||
} else { |
|||
std::vector<storm::expressions::Expression> disjuncts; |
|||
for (auto const &c : constraints) { |
|||
disjuncts.push_back(c->toExpression(varNames, manager)); |
|||
} |
|||
return disjunction(disjuncts); |
|||
} |
|||
} |
|||
|
|||
private: |
|||
std::vector<std::shared_ptr<SmtConstraint>> constraints; |
|||
|
|||
}; |
|||
|
|||
|
|||
class Implies : public SmtConstraint { |
|||
public: |
|||
Implies(std::shared_ptr<SmtConstraint> l, std::shared_ptr<SmtConstraint> r) : lhs(l), rhs(r) { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(=> " << lhs->toSmtlib2(varNames) << " " << rhs->toSmtlib2(varNames) << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return implies(lhs->toExpression(varNames, manager), rhs->toExpression(varNames, manager)); |
|||
} |
|||
|
|||
private: |
|||
std::shared_ptr<SmtConstraint> lhs; |
|||
std::shared_ptr<SmtConstraint> rhs; |
|||
}; |
|||
|
|||
|
|||
class Iff : public SmtConstraint { |
|||
public: |
|||
Iff(std::shared_ptr<SmtConstraint> l, std::shared_ptr<SmtConstraint> r) : lhs(l), rhs(r) { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(= " << lhs->toSmtlib2(varNames) << " " << rhs->toSmtlib2(varNames) << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return iff(lhs->toExpression(varNames, manager), rhs->toExpression(varNames, manager)); |
|||
} |
|||
|
|||
private: |
|||
std::shared_ptr<SmtConstraint> lhs; |
|||
std::shared_ptr<SmtConstraint> rhs; |
|||
}; |
|||
|
|||
|
|||
class IsTrue : public SmtConstraint { |
|||
public: |
|||
IsTrue(bool val) : value(val) { |
|||
} |
|||
|
|||
virtual ~IsTrue() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << (value ? "true" : "false"); |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return manager->boolean(value); |
|||
} |
|||
|
|||
private: |
|||
bool value; |
|||
}; |
|||
|
|||
|
|||
class IsBoolValue : public SmtConstraint { |
|||
public: |
|||
IsBoolValue(uint64_t varIndex, bool val) : varIndex(varIndex), value(val) { |
|||
} |
|||
|
|||
virtual ~IsBoolValue() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
assert(varIndex < varNames.size()); |
|||
if (value) { |
|||
sstr << varNames.at(varIndex); |
|||
} else { |
|||
sstr << "(not " << varNames.at(varIndex) << ")"; |
|||
} |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
if (value) { |
|||
return manager->getVariableExpression(varNames.at(varIndex)); |
|||
} else { |
|||
return !(manager->getVariableExpression(varNames.at(varIndex))); |
|||
} |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
bool value; |
|||
}; |
|||
|
|||
|
|||
class IsConstantValue : public SmtConstraint { |
|||
public: |
|||
IsConstantValue(uint64_t varIndex, uint64_t val) : varIndex(varIndex), value(val) { |
|||
} |
|||
|
|||
virtual ~IsConstantValue() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
assert(varIndex < varNames.size()); |
|||
sstr << "(= " << varNames.at(varIndex) << " " << value << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return manager->getVariableExpression(varNames.at(varIndex)) == manager->integer(value); |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
uint64_t value; |
|||
}; |
|||
|
|||
|
|||
class IsLessConstant : public SmtConstraint { |
|||
public: |
|||
IsLessConstant(uint64_t varIndex, uint64_t val) : varIndex(varIndex), value(val) { |
|||
} |
|||
|
|||
virtual ~IsLessConstant() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
assert(varIndex < varNames.size()); |
|||
sstr << "(< " << varNames.at(varIndex) << " " << value << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return manager->getVariableExpression(varNames.at(varIndex)) < value; |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
uint64_t value; |
|||
}; |
|||
|
|||
class IsGreaterConstant : public SmtConstraint { |
|||
public: |
|||
IsGreaterConstant(uint64_t varIndex, uint64_t val) : varIndex(varIndex), value(val) { |
|||
} |
|||
|
|||
virtual ~IsGreaterConstant() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
assert(varIndex < varNames.size()); |
|||
sstr << "(< " << value << " " << varNames.at(varIndex) << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return manager->getVariableExpression(varNames.at(varIndex)) > value; |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
uint64_t value; |
|||
}; |
|||
|
|||
class IsLessEqualConstant : public SmtConstraint { |
|||
public: |
|||
IsLessEqualConstant(uint64_t varIndex, uint64_t val) : varIndex(varIndex), value(val) { |
|||
} |
|||
|
|||
virtual ~IsLessEqualConstant() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
assert(varIndex < varNames.size()); |
|||
sstr << "(<= " << varNames.at(varIndex) << " " << value << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return manager->getVariableExpression(varNames.at(varIndex)) <= value; |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
uint64_t value; |
|||
}; |
|||
|
|||
class IsGreaterEqualConstant : public SmtConstraint { |
|||
public: |
|||
IsGreaterEqualConstant(uint64_t varIndex, uint64_t val) : varIndex(varIndex), value(val) { |
|||
} |
|||
|
|||
virtual ~IsGreaterEqualConstant() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
assert(varIndex < varNames.size()); |
|||
sstr << "(<= " << value << " " << varNames.at(varIndex) << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return manager->getVariableExpression(varNames.at(varIndex)) >= value; |
|||
} |
|||
|
|||
private: |
|||
uint64_t varIndex; |
|||
uint64_t value; |
|||
}; |
|||
|
|||
|
|||
class IsEqual : public SmtConstraint { |
|||
public: |
|||
IsEqual(uint64_t varIndex1, uint64_t varIndex2) : var1Index(varIndex1), var2Index(varIndex2) { |
|||
} |
|||
|
|||
virtual ~IsEqual() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
return "(= " + varNames.at(var1Index) + " " + varNames.at(var2Index) + ")"; |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return manager->getVariableExpression(varNames.at(var1Index)) == |
|||
manager->getVariableExpression(varNames.at(var2Index)); |
|||
} |
|||
|
|||
private: |
|||
uint64_t var1Index; |
|||
uint64_t var2Index; |
|||
}; |
|||
|
|||
|
|||
class IsLess : public SmtConstraint { |
|||
public: |
|||
IsLess(uint64_t varIndex1, uint64_t varIndex2) : var1Index(varIndex1), var2Index(varIndex2) { |
|||
} |
|||
|
|||
virtual ~IsLess() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
return "(< " + varNames.at(var1Index) + " " + varNames.at(var2Index) + ")"; |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return manager->getVariableExpression(varNames.at(var1Index)) < |
|||
manager->getVariableExpression(varNames.at(var2Index)); |
|||
} |
|||
|
|||
private: |
|||
uint64_t var1Index; |
|||
uint64_t var2Index; |
|||
}; |
|||
|
|||
|
|||
class PairwiseDifferent : public SmtConstraint { |
|||
public: |
|||
PairwiseDifferent(std::vector<uint64_t> const &indices) : varIndices(indices) { |
|||
} |
|||
|
|||
virtual ~PairwiseDifferent() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(distinct"; |
|||
// for(uint64_t i = 0; i < varIndices.size(); ++i) {
|
|||
// for(uint64_t j = i + 1; j < varIndices.size(); ++j) {
|
|||
// sstr << "()";
|
|||
// }
|
|||
// }
|
|||
for (auto const &varIndex : varIndices) { |
|||
sstr << " " << varNames.at(varIndex); |
|||
} |
|||
sstr << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
std::vector<storm::expressions::Expression> conjuncts; |
|||
for (uint64_t i = 0; i < varIndices.size(); ++i) { |
|||
for (uint64_t j = i + 1; j < varIndices.size(); ++j) { |
|||
// check all elements pairwise for inequality
|
|||
conjuncts.push_back(manager->getVariableExpression(varNames.at(varIndices.at(i))) != |
|||
manager->getVariableExpression(varNames.at(varIndices.at(j)))); |
|||
} |
|||
} |
|||
// take the conjunction of all pairwise inequalities
|
|||
return conjunction(conjuncts); |
|||
} |
|||
|
|||
private: |
|||
std::vector<uint64_t> varIndices; |
|||
}; |
|||
|
|||
|
|||
class Sorted : public SmtConstraint { |
|||
public: |
|||
Sorted(std::vector<uint64_t> varIndices) : varIndices(varIndices) { |
|||
} |
|||
|
|||
virtual ~Sorted() { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(and "; |
|||
for (uint64_t i = 1; i < varIndices.size(); ++i) { |
|||
sstr << "(<= " << varNames.at(varIndices.at(i - 1)) << " " << varNames.at(varIndices.at(i)) << ")"; |
|||
} |
|||
sstr << ") "; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
std::vector<storm::expressions::Expression> conjuncts; |
|||
for (uint64_t i = 1; i < varIndices.size(); ++i) { |
|||
conjuncts.push_back(manager->getVariableExpression(varNames.at(varIndices.at(i - 1))) <= |
|||
manager->getVariableExpression(varNames.at(varIndices.at(i)))); |
|||
} |
|||
// take the conjunction of all pairwise inequalities
|
|||
return conjunction(conjuncts); |
|||
} |
|||
|
|||
|
|||
private: |
|||
std::vector<uint64_t> varIndices; |
|||
}; |
|||
|
|||
|
|||
class IfThenElse : public SmtConstraint { |
|||
public: |
|||
IfThenElse(std::shared_ptr<SmtConstraint> ifC, std::shared_ptr<SmtConstraint> thenC, |
|||
std::shared_ptr<SmtConstraint> elseC) : ifConstraint(ifC), thenConstraint(thenC), |
|||
elseConstraint(elseC) { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(ite " << ifConstraint->toSmtlib2(varNames) << " " << thenConstraint->toSmtlib2(varNames) |
|||
<< " " << elseConstraint->toSmtlib2(varNames) << ")"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
return ite(ifConstraint->toExpression(varNames, manager), |
|||
thenConstraint->toExpression(varNames, manager), |
|||
elseConstraint->toExpression(varNames, manager)); |
|||
} |
|||
|
|||
private: |
|||
std::shared_ptr<SmtConstraint> ifConstraint; |
|||
std::shared_ptr<SmtConstraint> thenConstraint; |
|||
std::shared_ptr<SmtConstraint> elseConstraint; |
|||
}; |
|||
|
|||
class TrueCountIsLessConstant : public SmtConstraint { |
|||
public: |
|||
TrueCountIsLessConstant(std::vector<uint64_t> varIndices, uint64_t val) : varIndices(varIndices), |
|||
value(val) { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(< (+ "; |
|||
for (uint64_t i = 0; i < varIndices.size(); ++i) { |
|||
sstr << "(ite " << varNames.at(varIndices.at(i)) << " 1 0 )"; |
|||
} |
|||
sstr << ") " << value << " )"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
std::vector<storm::expressions::Expression> boolToInt; |
|||
for (uint64_t i = 0; i < varIndices.size(); ++i) { |
|||
boolToInt.push_back( |
|||
ite(manager->getVariableExpression(varNames.at(varIndices.at(i))), // If variable is true
|
|||
manager->integer(1), // set 1
|
|||
manager->integer(0))); // else 0
|
|||
} |
|||
return sum(boolToInt) < manager->integer(value); |
|||
} |
|||
|
|||
private: |
|||
std::vector<uint64_t> varIndices; |
|||
uint64_t value; |
|||
}; |
|||
|
|||
class FalseCountIsEqualConstant : public SmtConstraint { |
|||
public: |
|||
FalseCountIsEqualConstant(std::vector<uint64_t> varIndices, uint64_t val) : varIndices(varIndices), |
|||
value(val) { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(= (+ "; |
|||
for (uint64_t i = 0; i < varIndices.size(); ++i) { |
|||
sstr << "(ite " << varNames.at(varIndices.at(i)) << " 0 1 )"; |
|||
} |
|||
sstr << ") " << value << " )"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
std::vector<storm::expressions::Expression> boolToInt; |
|||
for (uint64_t i = 0; i < varIndices.size(); ++i) { |
|||
boolToInt.push_back( |
|||
ite(manager->getVariableExpression(varNames.at(varIndices.at(i))), // If variable is true
|
|||
manager->integer(0), // set 0
|
|||
manager->integer(1))); // else 1
|
|||
} |
|||
return sum(boolToInt) == manager->integer(value); |
|||
} |
|||
|
|||
private: |
|||
std::vector<uint64_t> varIndices; |
|||
uint64_t value; |
|||
}; |
|||
|
|||
class TrueCountIsConstantValue : public SmtConstraint { |
|||
public: |
|||
TrueCountIsConstantValue(std::vector<uint64_t> varIndices, uint64_t val) : varIndices(varIndices), |
|||
value(val) { |
|||
} |
|||
|
|||
std::string toSmtlib2(std::vector<std::string> const &varNames) const override { |
|||
std::stringstream sstr; |
|||
sstr << "(= (+ "; |
|||
for (uint64_t i = 0; i < varIndices.size(); ++i) { |
|||
sstr << "(ite " << varNames.at(varIndices.at(i)) << " 1 0 )"; |
|||
} |
|||
sstr << ") " << value << " )"; |
|||
return sstr.str(); |
|||
} |
|||
|
|||
storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const override { |
|||
std::vector<storm::expressions::Expression> boolToInt; |
|||
for (uint64_t i = 0; i < varIndices.size(); ++i) { |
|||
boolToInt.push_back( |
|||
ite(manager->getVariableExpression(varNames.at(varIndices.at(i))), // If variable is true
|
|||
manager->integer(1), // set 1
|
|||
manager->integer(0))); // else 0
|
|||
} |
|||
return sum(boolToInt) == manager->integer(value); |
|||
} |
|||
|
|||
private: |
|||
std::vector<uint64_t> varIndices; |
|||
uint64_t value; |
|||
}; |
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,39 @@ |
|||
#include <string> |
|||
#include <storm/storage/expressions/Expression.h> |
|||
|
|||
namespace storm { |
|||
namespace modelchecker { |
|||
class SmtConstraint { |
|||
public: |
|||
virtual ~SmtConstraint() { |
|||
} |
|||
|
|||
/** Generate a string describing the constraint in Smtlib2 format |
|||
* |
|||
* @param varNames vector of variable names |
|||
* @return Smtlib2 format string |
|||
*/ |
|||
virtual std::string toSmtlib2(std::vector<std::string> const &varNames) const = 0; |
|||
|
|||
/** Generate an expression describing the constraint in Storm format |
|||
* |
|||
* @param varNames vector of variable names |
|||
* @param manager the expression manager used to handle the expressions |
|||
* @return the expression |
|||
*/ |
|||
virtual storm::expressions::Expression toExpression(std::vector<std::string> const &varNames, |
|||
std::shared_ptr<storm::expressions::ExpressionManager> manager) const = 0; |
|||
|
|||
virtual std::string description() const { |
|||
return descript; |
|||
} |
|||
|
|||
void setDescription(std::string const &descr) { |
|||
descript = descr; |
|||
} |
|||
|
|||
private: |
|||
std::string descript; |
|||
}; |
|||
} |
|||
} |
|||
@ -0,0 +1,59 @@ |
|||
#include "gtest/gtest.h"
|
|||
#include "storm-config.h"
|
|||
|
|||
#include "storm-dft/api/storm-dft.h"
|
|||
|
|||
namespace { |
|||
TEST(DftSmtTest, AndTest) { |
|||
std::shared_ptr<storm::storage::DFT<double>> dft = |
|||
storm::api::loadDFTGalileoFile<double>(STORM_TEST_RESOURCES_DIR "/dft/and.dft"); |
|||
EXPECT_TRUE(storm::api::isWellFormed(*dft)); |
|||
storm::modelchecker::DFTASFChecker smtChecker(*dft); |
|||
smtChecker.convert(); |
|||
smtChecker.toSolver(); |
|||
EXPECT_EQ(smtChecker.checkTleNeverFailed(), storm::solver::SmtSolver::CheckResult::Unsat); |
|||
} |
|||
|
|||
TEST(DftSmtTest, PandTest) { |
|||
std::shared_ptr<storm::storage::DFT<double>> dft = |
|||
storm::api::loadDFTGalileoFile<double>(STORM_TEST_RESOURCES_DIR "/dft/pand.dft"); |
|||
EXPECT_TRUE(storm::api::isWellFormed(*dft)); |
|||
storm::modelchecker::DFTASFChecker smtChecker(*dft); |
|||
smtChecker.convert(); |
|||
smtChecker.toSolver(); |
|||
EXPECT_EQ(smtChecker.checkTleNeverFailed(), storm::solver::SmtSolver::CheckResult::Sat); |
|||
} |
|||
|
|||
TEST(DftSmtTest, SpareTest) { |
|||
std::shared_ptr<storm::storage::DFT<double>> dft = |
|||
storm::api::loadDFTGalileoFile<double>(STORM_TEST_RESOURCES_DIR "/dft/spare_two_modules.dft"); |
|||
EXPECT_TRUE(storm::api::isWellFormed(*dft)); |
|||
storm::modelchecker::DFTASFChecker smtChecker(*dft); |
|||
smtChecker.convert(); |
|||
smtChecker.toSolver(); |
|||
EXPECT_EQ(smtChecker.checkTleFailsWithLeq(2), storm::solver::SmtSolver::CheckResult::Unsat); |
|||
EXPECT_EQ(smtChecker.checkTleFailsWithEq(3), storm::solver::SmtSolver::CheckResult::Sat); |
|||
} |
|||
|
|||
TEST(DftSmtTest, BoundTest) { |
|||
std::shared_ptr<storm::storage::DFT<double>> dft = |
|||
storm::api::loadDFTGalileoFile<double>(STORM_TEST_RESOURCES_DIR "/dft/spare5.dft"); |
|||
EXPECT_TRUE(storm::api::isWellFormed(*dft)); |
|||
storm::modelchecker::DFTASFChecker smtChecker(*dft); |
|||
smtChecker.convert(); |
|||
smtChecker.toSolver(); |
|||
EXPECT_EQ(smtChecker.getLeastFailureBound(30), uint64_t(2)); |
|||
EXPECT_EQ(smtChecker.getAlwaysFailedBound(30), uint64_t(4)); |
|||
} |
|||
|
|||
TEST(DftSmtTest, FDEPBoundTest) { |
|||
std::shared_ptr<storm::storage::DFT<double>> dft = |
|||
storm::api::loadDFTGalileoFile<double>(STORM_TEST_RESOURCES_DIR "/dft/fdep_bound.dft"); |
|||
EXPECT_TRUE(storm::api::isWellFormed(*dft)); |
|||
storm::modelchecker::DFTASFChecker smtChecker(*dft); |
|||
smtChecker.convert(); |
|||
smtChecker.toSolver(); |
|||
EXPECT_EQ(smtChecker.getLeastFailureBound(30), uint64_t(1)); |
|||
EXPECT_EQ(smtChecker.getAlwaysFailedBound(30), uint64_t(5)); |
|||
} |
|||
} |
|||
@ -1,47 +0,0 @@ |
|||
#!/bin/bash -x |
|||
|
|||
set -e |
|||
|
|||
OS=$TRAVIS_OS_NAME |
|||
|
|||
# Do not deploy if credentials are not given |
|||
if [ "${TRAVIS_SECURE_ENV_VARS}" == "false" ]; then |
|||
echo "WARNING: Not deploying as no credentials are given." |
|||
exit 0; |
|||
fi |
|||
|
|||
# Do not deploy for pull requests |
|||
if [ "${TRAVIS_PULL_REQUEST}" != "false" ]; then |
|||
exit 0; |
|||
fi |
|||
|
|||
case $OS in |
|||
linux) |
|||
echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin |
|||
# Deploy as debug/release |
|||
case "$CONFIG" in |
|||
*DebugTravis) |
|||
docker commit storm movesrwth/storm:travis-debug |
|||
docker push movesrwth/storm:travis-debug |
|||
;; |
|||
*ReleaseTravis) |
|||
docker commit storm movesrwth/storm:travis |
|||
docker push movesrwth/storm:travis |
|||
;; |
|||
*) |
|||
echo "Unrecognized value of CONFIG: $CONFIG"; exit 1 |
|||
;; |
|||
esac |
|||
;; |
|||
|
|||
osx) |
|||
echo "Building Storm on Mac OSX not used." |
|||
exit 1 |
|||
;; |
|||
|
|||
*) |
|||
# Unknown OS |
|||
echo "Unsupported OS: $OS" |
|||
exit 1 |
|||
esac |
|||
|
|||
@ -1,5 +1,8 @@ |
|||
src/**/*.{%{cpp}} |
|||
src/**/*.{in} |
|||
src/**/CMakeLists.txt |
|||
CMakeLists.txt |
|||
*.{in} |
|||
resources/3rdparty/**/*.{%{cpp}} |
|||
resources/3rdparty/eigen-3.3-beta1/StormEigen/**/* |
|||
resources/3rdparty/eigen-3.3-beta1/unsupported/**/* |
|||
@ -1,11 +1,6 @@ |
|||
#!/bin/bash |
|||
|
|||
set -e |
|||
|
|||
# Skip this run? |
|||
if [ -f build/skip.txt ] |
|||
then |
|||
exit 0 |
|||
fi |
|||
|
|||
#sudo apt-get install -qq -y docker |
|||
Reference in new issue
xxxxxxxxxx