sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

update on restrictions 

Former-commit-id: 5b14895f07
main
sjunges 9 years ago
parent
27b57f055e
commit
73c88a4faf
5 changed files with 35 additions and 42 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      src/storage/dft/DFT.cpp
  2. 11
      src/storage/dft/DFTBuilder.cpp
  3. 14
      src/storage/dft/DFTElements.cpp
  4. 32
      src/storage/dft/DFTElements.h
  5. 14
      src/storage/dft/elements/DFTRestriction.h

6
src/storage/dft/DFT.cpp
View File

@ -321,7 +321,7 @@ namespace storm {
template <typename ValueType> template <typename ValueType>
std::vector<size_t> DFT<ValueType>::getIndependentSubDftRoots(size_t index) const { std::vector<size_t> DFT<ValueType>::getIndependentSubDftRoots(size_t index) const {
auto elem = getElement(index); auto elem = getElement(index);
auto ISD = elem->independentSubDft();
auto ISD = elem->independentSubDft(false);
return ISD; return ISD;
} }
@ -373,8 +373,8 @@ namespace storm {
if(influencedElem1Ids == getSortedParentAndOutDepIds(*it2)) { if(influencedElem1Ids == getSortedParentAndOutDepIds(*it2)) {
std::cout << "Considering ids " << *it1 << ", " << *it2 << " for isomorphism." << std::endl; std::cout << "Considering ids " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
bool isSymmetry = false; bool isSymmetry = false;
std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft();
std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft();
std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft(false);
std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft(false);
if(isubdft1.empty() || isubdft2.empty() || isubdft1.size() != isubdft2.size()) { if(isubdft1.empty() || isubdft2.empty() || isubdft1.size() != isubdft2.size()) {
continue; continue;
} }

11
src/storage/dft/DFTBuilder.cpp
View File

@ -57,16 +57,7 @@ namespace storm {
dependentEvent->addIngoingDependency(dependency); dependentEvent->addIngoingDependency(dependency);
} }
// for (auto& restriction : mRestrictions) {
// std::set<DFTGatePointer> parentsOfRestrictedElements;
// for (auto& child : restriction->children()) {
// for(DFTGatePointer& parent : child->parents()) {
// parentsOfRestrictedElements.insert(parent);
// }
// }
//
//
// }
// Sort elements topologically // Sort elements topologically
// compute rank // compute rank

14
src/storage/dft/DFTElements.cpp
View File

@ -63,7 +63,7 @@ namespace storm {
} }
template<typename ValueType> template<typename ValueType>
std::vector<size_t> DFTElement<ValueType>::independentSubDft() const {
std::vector<size_t> DFTElement<ValueType>::independentSubDft(bool blockParents) const {
//std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl; //std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl;
std::vector<size_t> res; std::vector<size_t> res;
res.push_back(this->id()); res.push_back(this->id());
@ -71,7 +71,7 @@ namespace storm {
} }
template<typename ValueType> template<typename ValueType>
void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const {
void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const {
if(elemsInSubtree.count(this->id()) > 0) return; if(elemsInSubtree.count(this->id()) > 0) return;
if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) { if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) {
// This is a parent of the suspected root, thus it is not a subdft. // This is a parent of the suspected root, thus it is not a subdft.
@ -80,14 +80,16 @@ namespace storm {
} }
elemsInSubtree.insert(mId); elemsInSubtree.insert(mId);
for(auto const& parent : mParents) { for(auto const& parent : mParents) {
parent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
if(blockParents && std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), parent->id()) != parentsOfSubRoot.end()) {
continue;
}
parent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
return; return;
} }
} }
for(auto const& dep : mOutgoingDependencies) { for(auto const& dep : mOutgoingDependencies) {
dep->extendSubDft(elemsInSubtree, parentsOfSubRoot);
dep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
return; return;
} }
@ -95,7 +97,7 @@ namespace storm {
} }
for(auto const& restr : mRestrictions) { for(auto const& restr : mRestrictions) {
restr->extendSubDft(elemsInSubtree, parentsOfSubRoot);
restr->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
return; return;
} }

32
src/storage/dft/DFTElements.h
View File

@ -262,15 +262,15 @@ namespace storm {
/** /**
* Computes independent subtrees starting with this element (this), that is, all elements (x) which are connected to either * Computes independent subtrees starting with this element (this), that is, all elements (x) which are connected to either
* - one of the children of the element, * - one of the children of the element,
* - a propabilisistic dependency
* - a probabilistic dependency
* such that there exists a path from x to a child of this does not go through this. * such that there exists a path from x to a child of this does not go through this.
*/ */
virtual std::vector<size_t> independentSubDft() const;
virtual std::vector<size_t> independentSubDft(bool blockParents) const;
/** /**
* Helper to the independent subtree computation * Helper to the independent subtree computation
* @see independentSubDft * @see independentSubDft
*/ */
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const;
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const;
virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const { virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const {
return type() == other.type(); return type() == other.type();
@ -351,8 +351,8 @@ namespace storm {
} }
} }
virtual std::vector<size_t> independentSubDft() const override {
auto prelRes = DFTElement<ValueType>::independentSubDft();
virtual std::vector<size_t> independentSubDft(bool blockParents) const override {
auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
if(prelRes.empty()) { if(prelRes.empty()) {
// No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft. // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
return prelRes; return prelRes;
@ -360,7 +360,7 @@ namespace storm {
std::set<size_t> unit(prelRes.begin(), prelRes.end()); std::set<size_t> unit(prelRes.begin(), prelRes.end());
std::vector<size_t> pids = this->parentIds(); std::vector<size_t> pids = this->parentIds();
for(auto const& child : mChildren) { for(auto const& child : mChildren) {
child->extendSubDft(unit, pids);
child->extendSubDft(unit, pids, blockParents);
if(unit.empty()) { if(unit.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
break; break;
@ -369,15 +369,15 @@ namespace storm {
return std::vector<size_t>(unit.begin(), unit.end()); return std::vector<size_t>(unit.begin(), unit.end());
} }
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
if(elemsInSubtree.count(this->id()) > 0) return; if(elemsInSubtree.count(this->id()) > 0) return;
DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
return; return;
} }
for(auto const& child : mChildren) { for(auto const& child : mChildren) {
child->extendSubDft(elemsInSubtree, parentsOfSubRoot);
child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
return; return;
@ -531,15 +531,15 @@ namespace storm {
return storm::utility::isZero(mPassiveFailureRate); return storm::utility::isZero(mPassiveFailureRate);
} }
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
if(elemsInSubtree.count(this->id())) return; if(elemsInSubtree.count(this->id())) return;
DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
return; return;
} }
for(auto const& incDep : mIngoingDependencies) { for(auto const& incDep : mIngoingDependencies) {
incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot);
incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
return; return;
@ -683,19 +683,19 @@ namespace storm {
return std::vector<size_t>(unit.begin(), unit.end()); return std::vector<size_t>(unit.begin(), unit.end());
} }
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
if(elemsInSubtree.count(this->id())) return; if(elemsInSubtree.count(this->id())) return;
DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
return; return;
} }
mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
return; return;
} }
mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
} }

14
src/storage/dft/elements/DFTRestriction.h
View File

@ -66,8 +66,8 @@ namespace storm {
} }
} }
virtual std::vector<size_t> independentSubDft() const override {
auto prelRes = DFTElement<ValueType>::independentSubDft();
virtual std::vector<size_t> independentSubDft(bool blockParents) const override {
auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
if(prelRes.empty()) { if(prelRes.empty()) {
// No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft. // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
return prelRes; return prelRes;
@ -75,7 +75,7 @@ namespace storm {
std::set<size_t> unit(prelRes.begin(), prelRes.end()); std::set<size_t> unit(prelRes.begin(), prelRes.end());
std::vector<size_t> pids = this->parentIds(); std::vector<size_t> pids = this->parentIds();
for(auto const& child : mChildren) { for(auto const& child : mChildren) {
child->extendSubDft(unit, pids);
child->extendSubDft(unit, pids, blockParents);
if(unit.empty()) { if(unit.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
break; break;
@ -84,15 +84,15 @@ namespace storm {
return std::vector<size_t>(unit.begin(), unit.end()); return std::vector<size_t>(unit.begin(), unit.end());
} }
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
if(elemsInSubtree.count(this->id()) > 0) return; if(elemsInSubtree.count(this->id()) > 0) return;
DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
return; return;
} }
for(auto const& child : mChildren) { for(auto const& child : mChildren) {
child->extendSubDft(elemsInSubtree, parentsOfSubRoot);
child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
if(elemsInSubtree.empty()) { if(elemsInSubtree.empty()) {
// Parent in the subdft, ie it is *not* a subdft // Parent in the subdft, ie it is *not* a subdft
return; return;
@ -183,7 +183,7 @@ namespace storm {
} }
bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
} }

Write Preview
Loading…
Cancel
Save