CDataNode::TDataNodeSet CDataNode::FindChildrenOfType( const CString& name , const bool recursive ) {GUCEF_TRACE; TDataNodeSet children; TDataNodeList::iterator m = m_children.begin(); while ( m != m_children.end() ) { if ( (*m)->_name == name ) { children.insert( (*m) ); } if ( recursive ) { TDataNodeSet subSet( (*m)->FindChildrenOfType( name, recursive ) ); TDataNodeSet::const_iterator i = subSet.begin(); while ( i != subSet.end() ) { children.insert( (*i) ); ++i; } } ++m; } return children; }
rice::pastry::IdSet* rice::pastry::IdSet::subSet(IdRange* range) { if(npc(range)->isEmpty()) { return new ::rice::pastry::IdSet(); } else if(npc(npc(range)->getCCW())->equals(npc(range)->getCW())) { return this; } else { return subSet(npc(range)->getCCW(), npc(range)->getCW()); } }
ValueSetPtr ExtQuntifier::Subset( std::string id, ValueSetPtr values, AtomPtr term, ContextPtr context) { ValueSetPtr subSet(new ValueSet()); for (ValueSet::Iterator it = values->Begin(); it != values->End(); ++it) { context->PushParam(id, *it); bool result = term->Calc(context); context->PopParam(id); if (result) subSet->AddValue(*it); } return subSet; }
//---------- void SolveSet::solveNL() { if (this->dataSet.empty()) { throw(ofxRulr::Exception("Data set is empty!")); } this->model.initialiseParameters(); auto fitter = make_shared<ofxNonLinearFit::Fit<ofxNonLinearFit::Models::RigidBody>>(); double residual; bool success; auto startTime = chrono::system_clock::now(); if (this->parameters.nlSettings.trimOutliers == 0.0f) { //Use full data set. success = fitter->optimise(this->model, &this->dataSet, &residual); } else { //Use subset with top results. This will only work if the full set is calculated previously. auto firstIt = dataSet.begin(); auto lastIt = firstIt + (int)(this->dataSet.size() * (1.0f - this->parameters.nlSettings.trimOutliers)); ofxNonLinearFit::Models::RigidBody::DataSet subSet(firstIt, lastIt); success = fitter->optimise(this->model, &subSet, &residual); } auto endTime = chrono::system_clock::now(); sort(this->dataSet.begin(), this->dataSet.end(), [this](auto & a, auto & b) { return (this->model.getResidual(a) < this->model.getResidual(b)); }); this->result.success = success; this->result.totalTime = endTime - startTime; this->result.residual = residual; this->result.transform = this->model.getCachedTransform(); this->completed = true; }
rice::p2p::commonapi::IdSet* rice::pastry::IdSet::subSet(::rice::p2p::commonapi::IdRange* range) { return subSet(java_cast< IdRange* >(range)); }
void Foam::regionToCell::combine(topoSet& set, const bool add) const { label cellI = mesh_.findCell(insidePoint_); // Load the subset of cells boolList blockedFace(mesh_.nFaces(), false); { Info<< "Loading subset " << setName_ << " to delimit search region." << endl; cellSet subSet(mesh_, setName_); boolList inSubset(mesh_.nCells(), false); forAllConstIter(cellSet, subSet, iter) { inSubset[iter.key()] = true; } if (cellI != -1 && inSubset[cellI]) { Pout<< "Point " << insidePoint_ << " is inside cellSet " << setName_ << endl << "Collecting all cells connected to " << cellI << " and inside cellSet " << setName_ << endl; } else { Pout<< "Point " << insidePoint_ << " is outside cellSet " << setName_ << endl << "Collecting all cells connected to " << cellI << " and outside cellSet " << setName_ << endl; } // Get coupled cell status label nInt = mesh_.nInternalFaces(); boolList neiSet(mesh_.nFaces()-nInt, false); for (label faceI = nInt; faceI < mesh_.nFaces(); faceI++) { neiSet[faceI-nInt] = inSubset[mesh_.faceOwner()[faceI]]; } syncTools::swapBoundaryFaceList(mesh_, neiSet, false); // Find faces inbetween subSet and non-subset. for (label faceI = 0; faceI < nInt; faceI++) { bool ownInSet = inSubset[mesh_.faceOwner()[faceI]]; bool neiInSet = inSubset[mesh_.faceNeighbour()[faceI]]; blockedFace[faceI] = (ownInSet != neiInSet); } for (label faceI = nInt; faceI < mesh_.nFaces(); faceI++) { bool ownInSet = inSubset[mesh_.faceOwner()[faceI]]; bool neiInSet = neiSet[faceI-nInt]; blockedFace[faceI] = (ownInSet != neiInSet); } } // Find connected regions without crossing boundary of the cellset. regionSplit regions(mesh_, blockedFace); // Get the region containing the insidePoint label regionI = -1; if (cellI != -1) { // On processor that has found cell. regionI = regions[cellI]; } reduce(regionI, maxOp<label>()); if (regionI == -1) { WarningIn ( "regionToCell::combine(topoSet&, const bool) const" ) << "Point " << insidePoint_ << " is not inside the mesh." << nl << "Bounding box of the mesh:" << mesh_.globalData().bb() << endl; return; } // Pick up the cells of the region const labelList regionCells(findIndices(regions, regionI)); forAll(regionCells, i) { addOrDelete(set, regionCells[i], add); }
void SetTest::run() { CSetT<TestKey, TestSetFuncs> defSet; TestKey tk1; tk1.setValue("obj1"); TestKey tk2; tk2.setValue("obj2"); TestKey tk3; tk3.setValue("obj3"); defSet.addObject(tk1); defSet.addObject(tk2); defSet.addObject(tk3); if (3 != defSet.count()) testFail(er0); CSetT<TestKey, TestSetFuncs>::Iterator iter1(&defSet); while (iter1.next()) { if (TestSetFuncs<TestKey>::isEqualKeys(&iter1.object(), &tk1, nil)) continue; if (TestSetFuncs<TestKey>::isEqualKeys(&iter1.object(), &tk2, nil)) continue; if (TestSetFuncs<TestKey>::isEqualKeys(&iter1.object(), &tk3, nil)) continue; testFail(er1); } defSet.removeObject(tk3); if (2 != defSet.count()) testFail(er2); defSet.removeAllObjects(); if (0 != defSet.count()) testFail(er3); TestKey k5; k5.setValue("k5"); TestKey k6; k6.setValue("k6"); TestKey k7; k7.setValue("k7"); TestKey k8; k8.setValue("k8"); TestKey k9; k9.setValue("k9"); TestKey s_1; s_1.setValue("s1"); TestKey s_2; s_2.setValue("s2"); TestKey s_3; s_3.setValue("s3"); TestKey arrms[] = { k5, k6, k7, k8 }; CArrayT<TestKey> arr(arrms, 4); TestKey tkss[] = { s_1, s_2, s_3 }; CSetT<TestKey, TestSetFuncs> set(tkss, 3); set.addObjectsFromArray(&arr); if (7 != set.count()) testFail(er4); CSetT<TestKey, TestSetFuncs> set2(&arr); if (4 != set2.count()) testFail(er5); set.removeObject(s_1); set.removeObject(s_2); set.removeObject(s_3); if (!set2.isEqualToSet(&set)) testFail(er6); if (!set2.containsObject(k5)) testFail(er7); if (set2.containsObject(s_1)) testFail(er7); set.allObjects(&arr); if (arr.count() != set.count()) testFail(er8); for (dInteger i = 0, cnt = arr.count(); i < cnt; ++i) if (!set.containsObject(arr.objectAtIndex(i))) testFail(er8); try { set.member(k6); } catch (CSetT<TestKey, TestSetFuncs>::ExSetObjectNotFound* e) { testFail(er9); SAFE_DELETE(e); } try { set.member(k9); testFail(er9); } catch (CSetT<TestKey, TestSetFuncs>::ExSetObjectNotFound* e) { SAFE_DELETE(e); } CSetT<TestKey, TestSetFuncs> set3(set2); if (!set3.isEqualToSet(&set2)) testFail(er5); TestKey* cSet = new TestKey[3]; cSet[0].setValue("b1"); cSet[1].setValue("b2"); cSet[2].setValue("b3"); CSetT<TestKey, TestSetFuncs> setCSet(cSet, 3); SAFE_DELETE_ARRAY(cSet); if (3 != setCSet.count()) testFail(er5); TestKey b1; b1.setValue("b1"); TestKey b2; b2.setValue("b2"); TestKey b3; b3.setValue("b3"); TestKey b4; b4.setValue("b4"); if (!setCSet.containsObject(b1)) testFail(er5); if (!setCSet.containsObject(b2)) testFail(er5); if (!setCSet.containsObject(b3)) testFail(er5); if (setCSet.containsObject(b4)) testFail(er5); try { TestKey anyKey = setCSet.anyObject(); if (!setCSet.containsObject(anyKey)) testFail(er10); } catch (CSetT<TestKey, TestSetFuncs>::ExSetObjectNotFound* e) { testFail(er10); SAFE_DELETE(e); } setCSet.removeAllObjects(); try { setCSet.anyObject(); testFail(er10); } catch (CSetT<TestKey, TestSetFuncs>::ExSetObjectNotFound* e) { SAFE_DELETE(e); } TestKey newobj; newobj.setValue("newObj"); CSetT<TestKey, TestSetFuncs>* newly = set3.newSetByAddingObject(newobj); if (!newly->containsObject(newobj)) testFail(er11); SAFE_DELETE(newly); TestKey k1; k1.setValue("kk1"); TestKey k2; k2.setValue("kk2"); TestKey k3; k3.setValue("kk3"); TestKey k4; k4.setValue("kk4"); TestKey l1; l1.setValue("l1"); TestKey l2; l2.setValue("l2"); TestKey l3; l3.setValue("l3"); TestKey keysms[] = { k1, k2, k3 }; CArrayT<TestKey> keys(keysms, 3); CSetT<TestKey, TestSetFuncs>* newly2 = set3.newSetByAddingObjectsFromArray(&keys); if (!newly2->containsObject(k1)) testFail(er12); if (!newly2->containsObject(k2)) testFail(er12); if (newly2->containsObject(k4)) testFail(er12); if (!newly2->containsObject(k3)) testFail(er12); if (!newly2->containsObject(set3.anyObject())) testFail(er12); SAFE_DELETE(newly2); TestKey oness[] = { l1, l2 }; CSetT<TestKey, TestSetFuncs> oneSet(oness, 2); CSetT<TestKey, TestSetFuncs> secondSet(&l3, 1); secondSet.unionSet(&oneSet); if (3 != secondSet.count()) testFail(er14); if (!secondSet.containsObject(l2)) testFail(er14); if (!secondSet.containsObject(l3)) testFail(er14); if (!secondSet.containsObject(l1)) testFail(er14); CSetT<TestKey, TestSetFuncs>* thirdSet = secondSet.newSetByAddingObjectsFromSet(&set3); if (!thirdSet->containsObject(l2)) testFail(er13); if (!thirdSet->containsObject(set3.anyObject())) testFail(er13); if (!thirdSet->containsObject(l3)) testFail(er13); if (!thirdSet->containsObject(l1)) testFail(er13); SAFE_DELETE(thirdSet); TestKey one; one.setValue("one"); TestKey two; two.setValue("two"); TestKey three; three.setValue("three"); TestKey four; four.setValue("four"); TestKey fifth; fifth.setValue("fifth"); TestKey six; six.setValue("six"); TestKey rss[] = { one, two, three, four }; CSetT<TestKey, TestSetFuncs> rSet(rss, 4); TestKey r2ss[] = { one, three, four }; CSetT<TestKey, TestSetFuncs> rSet2(r2ss, 3); rSet.minusSet(&rSet2); if (1 != rSet.count()) testFail(er15); TestKey tTwo; tTwo.setValue("two"); if (!TestSetFuncs<TestKey>::isEqualKeys(&rSet.anyObject(), &tTwo, nil)) testFail(er15); TestKey iss[] = { one, fifth, six, four }; CSetT<TestKey, TestSetFuncs> iSet(rss, 4); CSetT<TestKey, TestSetFuncs> iSet2(iss, 4); iSet.intersectSet(&iSet2); CSetT<TestKey, TestSetFuncs>::Iterator iSetIter(&iSet); TestKey tOne; tOne.setValue("one"); TestKey tFour; tFour.setValue("four"); while (iSetIter.next()) { if (TestSetFuncs<TestKey>::isEqualKeys(&iSetIter.object(), &tOne, nil)) continue; if (TestSetFuncs<TestKey>::isEqualKeys(&iSetIter.object(), &tFour, nil)) continue; testFail(er16); } TestKey boo1; boo1.setValue("boo1"); TestKey boo2; boo2.setValue("boo2"); TestKey boo3; boo3.setValue("boo3"); TestKey boo4; boo4.setValue("boo4"); TestKey capacity; capacity.setValue("capacity"); TestKey other; other.setValue("other"); TestKey bla; bla.setValue("bla-bla"); TestKey yahoo; yahoo.setValue("yahoo"); TestKey pss[] = { boo1, boo2, boo3 }; CSetT<TestKey, TestSetFuncs> pSet(pss, 3); iSet.setSet(&pSet); if (iSet.containsObject(one)) testFail(er17); if (iSet.containsObject(four)) testFail(er17); if (!iSet.containsObject(boo1)) testFail(er17); if (!iSet.containsObject(boo3)) testFail(er17); CSetT<TestKey, TestSetFuncs> capacitySet(10); capacitySet.addObject(capacity); if (1 != capacitySet.count()) testFail(er5); if (!capacitySet.containsObject(capacity)) testFail(er5); iSet.addObject(other); TestKey subss[] = { boo1, boo3 }; CSetT<TestKey, TestSetFuncs> subSet(subss, 2); if (!subSet.isSubsetOfSet(&iSet)) testFail(er18); if (subSet.isSubsetOfSet(&capacitySet)) testFail(er18); TestKey i1ss[] = { yahoo, bla, boo3 }; CSetT<TestKey, TestSetFuncs> interSet1(i1ss, 3); TestKey i2ss[] = { yahoo, bla, boo4 }; CSetT<TestKey, TestSetFuncs> interSet2(i2ss, 3); if (!subSet.intersectsSet(&interSet1)) testFail(er19); if (subSet.intersectsSet(&interSet2)) testFail(er19); }