int wpl_text_chunks::text::output_json ( wpl_text_state *state, const set<wpl_value*> &vars, wpl_text_chunk_it *it, wpl_value *final_result ) { const char id_string[] = "id=\""; const int id_string_len = sizeof(id_string)-1; wpl_io &io = state->get_io(); wpl_io_void io_void; wpl_value_string json_name; wpl_value_string json_value; wpl_value_unsafe_pointer unsafe_pointer; json_name.set_do_finalize(); json_value.set_do_finalize(); unsafe_pointer.set_do_finalize(); /* If we end with an HTML id tag, use this the text value of the next chunk as the JSON name. */ if (strncmp (end - id_string_len, id_string, id_string_len) != 0) { return (*(++(*it)))->output_json(state, vars, it, final_result); } /* If no return from the next block, just proceed with output_json */ if (!((*(++(*it)))->run(state, it->get_pos(), &json_name, io_void) & WPL_OP_OK)) { return (*it)->output_json(state, vars, it, final_result); } /* The next block which returns WPL_OP_OK is the expression whos pointer is used to match against the list of requested variables to output. */ while (true) { // it++ throws wpl_text_chunk_end_reached() when we're done (*it)++; /* Check if the next chuck is an expression with return value */ if (!((*it)->run(state, it->get_pos(), &unsafe_pointer, io_void) & WPL_OP_OK)) { continue; } /* Check if the value exists in the list */ if (vars.find(unsafe_pointer.dereference()) == vars.end()) { continue; } /* All OK, output this variable */ (*it)->run(state, it->get_pos(), &json_value, io_void); io << "\""; json_name.output_json(io); io << "\": \""; json_value.output_json(io); io << "\",\n"; (*it)++; return (*it)->output_json(state, vars, it, final_result); } return WPL_OP_NO_RETURN; }
void BilinearFormUtility::computeOptimalStiffnessMatrix(FieldContainer<double> &stiffness, FieldContainer<double> &optimalTestWeights, BilinearFormPtr bilinearForm, Teuchos::RCP<DofOrdering> trialOrdering, Teuchos::RCP<DofOrdering> testOrdering, shards::CellTopology &cellTopo, FieldContainer<double> &physicalCellNodes, FieldContainer<double> &cellSideParities) { // lots of code copied and pasted from the very similar computeStiffnessMatrix. The difference here is that for each optimal test function, // we need to ask the bilinear form about each of its components (it's a vector whereas the other guy had just a single basis function // for each...), and then apply the appropriate weights.... // physicalCellNodes: the nodal points for the element(s) with topology cellTopo // The dimensions are (numCells, numNodesPerElement, spaceDimension) // optimalTestWeights dimensions are: (numCells, numTrial, numTest) -- numTrial is the optTest index // stiffness dimensions are: (numCells, # trialOrdering Dofs, # trialOrdering Dofs) // (while (cell,trial,test) is more natural conceptually, I believe the above ordering makes // more sense given the inversion that we must do to compute the optimal test functions...) // steps: // 0. Set up BasisCache // 3. For each (test, trial) combination: // a. Apply the specified operators to the basis in the DofOrdering, at the cubature points // b. Multiply the two bases together, weighted with Jacobian/Piola transform and cubature weights // c. Pass the result to bilinearForm's applyBilinearFormData method // d. Sum up (integrate) and place in stiffness matrix according to DofOrdering indices // 0. Set up Cubature unsigned numCells = physicalCellNodes.dimension(0); unsigned numNodesPerElem = physicalCellNodes.dimension(1); unsigned spaceDim = physicalCellNodes.dimension(2); // Check that cellTopo and physicalCellNodes agree TEUCHOS_TEST_FOR_EXCEPTION( ( numNodesPerElem != cellTopo.getNodeCount() ), std::invalid_argument, "Second dimension of physicalCellNodes and cellTopo.getNodeCount() do not match."); TEUCHOS_TEST_FOR_EXCEPTION( ( spaceDim != cellTopo.getDimension() ), std::invalid_argument, "Third dimension of physicalCellNodes and cellTopo.getDimension() do not match."); int numOptTestFunctions = optimalTestWeights.dimension(1); // should also == numTrialDofs TEUCHOS_TEST_FOR_EXCEPTION( ( optimalTestWeights.dimension(1) != stiffness.dimension(2) ), std::invalid_argument, "optimalTestWeights.dimension(1) (=" << optimalTestWeights.dimension(1) << ") and stiffness.dimension(2) (=" << stiffness.dimension(2) << ") do not match."); TEUCHOS_TEST_FOR_EXCEPTION( ( stiffness.dimension(1) != stiffness.dimension(2) ), std::invalid_argument, "stiffness.dimension(1) (=" << stiffness.dimension(1) << ") and stiffness.dimension(2) (=" << stiffness.dimension(2) << ") do not match."); // Set up BasisCache int cubDegreeTrial = trialOrdering->maxBasisDegree(); int cubDegreeTest = testOrdering->maxBasisDegree(); int cubDegree = cubDegreeTrial + cubDegreeTest; BasisCache basisCache(physicalCellNodes, cellTopo, *trialOrdering, cubDegreeTest, true); // DO create side caches, too unsigned numSides = CamelliaCellTools::getSideCount(cellTopo); vector<int> testIDs = bilinearForm->testIDs(); vector<int>::iterator testIterator; vector<int> trialIDs = bilinearForm->trialIDs(); vector<int>::iterator trialIterator; BasisPtr trialBasis,testBasis; stiffness.initialize(0.0); for (trialIterator = trialIDs.begin(); trialIterator != trialIDs.end(); trialIterator++) { int trialID = *trialIterator; for (int optTestIndex=0; optTestIndex < numOptTestFunctions; optTestIndex++) { FieldContainer<double> weights(numCells,testOrdering->totalDofs()); for (unsigned i=0; i<numCells; i++) { for (int j=0; j<testOrdering->totalDofs(); j++) { weights(i,j) = optimalTestWeights(i,optTestIndex,j); } } for (testIterator = testIDs.begin(); testIterator != testIDs.end(); testIterator++) { int testID = *testIterator; vector<EOperatorExtended> trialOperators, testOperators; bilinearForm->trialTestOperators(trialID, testID, trialOperators, testOperators); vector<EOperatorExtended>::iterator trialOpIt, testOpIt; testOpIt = testOperators.begin(); int operatorIndex = -1; for (trialOpIt = trialOperators.begin(); trialOpIt != trialOperators.end(); trialOpIt++) { IntrepidExtendedTypes::EOperatorExtended trialOperator = *trialOpIt; IntrepidExtendedTypes::EOperatorExtended testOperator = *testOpIt; operatorIndex++; if (testOperator==OP_TIMES_NORMAL) { TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,"OP_TIMES_NORMAL not supported for tests. Use for trial only"); } Teuchos::RCP < const FieldContainer<double> > testValuesTransformed; Teuchos::RCP < const FieldContainer<double> > trialValuesTransformed; Teuchos::RCP < const FieldContainer<double> > testValuesTransformedWeighted; if (! bilinearForm->isFluxOrTrace(trialID)) { trialBasis = trialOrdering->getBasis(trialID); testBasis = testOrdering->getBasis(testID); FieldContainer<double> miniStiffness( numCells, testBasis->getCardinality(), trialBasis->getCardinality() ); trialValuesTransformed = basisCache.getTransformedValues(trialBasis,trialOperator); testValuesTransformedWeighted = basisCache.getTransformedWeightedValues(testBasis,testOperator); FieldContainer<double> physicalCubaturePoints = basisCache.getPhysicalCubaturePoints(); FieldContainer<double> materialDataAppliedToTrialValues = *trialValuesTransformed; // copy first FieldContainer<double> materialDataAppliedToTestValues = *testValuesTransformedWeighted; // copy first bilinearForm->applyBilinearFormData(materialDataAppliedToTrialValues,materialDataAppliedToTestValues, trialID,testID,operatorIndex,physicalCubaturePoints); int testDofOffset = testOrdering->getDofIndex(testID,0); // note that weightCellBasisValues does depend on contiguous test basis dofs... // (this is the plan, since there shouldn't be any kind of identification between different test dofs, // especially since test functions live only inside the cell) weightCellBasisValues(materialDataAppliedToTestValues, weights, testDofOffset); FunctionSpaceTools::integrate<double>(miniStiffness,materialDataAppliedToTestValues,materialDataAppliedToTrialValues,COMP_BLAS); // place in the appropriate spot in the element-stiffness matrix // copy goes from (cell,trial_basis_dof,test_basis_dof) to (cell,element_trial_dof,element_test_dof) // there may be a more efficient way to do this copying: // (one strategy would be to reimplement fst::integrate to support offsets, so that no copying needs to be done...) for (int i=0; i < testBasis->getCardinality(); i++) { for (int j=0; j < trialBasis->getCardinality(); j++) { int trialDofIndex = trialOrdering->getDofIndex(trialID,j); for (unsigned k=0; k < numCells; k++) { stiffness(k,optTestIndex,trialDofIndex) += miniStiffness(k,i,j); } } } } else { // boundary integral int trialBasisRank = trialOrdering->getBasisRank(trialID); int testBasisRank = testOrdering->getBasisRank(testID); TEUCHOS_TEST_FOR_EXCEPTION( ( trialBasisRank != 0 ), std::invalid_argument, "Boundary trial variable (flux or trace) given with non-scalar basis. Unsupported."); bool isFlux = false; // i.e. the normal is "folded into" the variable definition, so that we must take parity into account const set<int> normalOperators = BilinearForm::normalOperators(); if ( (normalOperators.find(testOperator) == normalOperators.end() ) && (normalOperators.find(trialOperator) == normalOperators.end() ) ) { // normal not yet taken into account -- so it must be "hidden" in the trial variable isFlux = true; } for (unsigned sideOrdinal=0; sideOrdinal<numSides; sideOrdinal++) { trialBasis = trialOrdering->getBasis(trialID,sideOrdinal); testBasis = testOrdering->getBasis(testID); FieldContainer<double> miniStiffness( numCells, testBasis->getCardinality(), trialBasis->getCardinality() ); // for trial: we never dot with normal, and the value lives on the side, so we don't use the volume coords either: trialValuesTransformed = basisCache.getTransformedValues(trialBasis,trialOperator,sideOrdinal,false); // for test: first, don't dot with normal, but do use the volume coords: //testValuesTransformed = basisCache.getTransformedValues(testBasis,testOperator,sideOrdinal,true); testValuesTransformedWeighted = basisCache.getTransformedWeightedValues(testBasis,testOperator,sideOrdinal,true); // copy before manipulating trialValues--these are the ones stored in the cache, so we're not allowed to change them!! FieldContainer<double> materialDataAppliedToTrialValues = *trialValuesTransformed; if (isFlux) { // this being a flux ==> take cell parity into account (because then there must be a normal folded into the flux definition) // we need to multiply the trialValues by the parity of the normal, since // the trial implicitly contains an outward normal, and we need to adjust for the fact // that the neighboring cells have opposite normal // trialValues should have dimensions (numCells,numFields,numCubPointsSide) int numFields = trialValuesTransformed->dimension(1); int numPoints = trialValuesTransformed->dimension(2); for (unsigned cellIndex=0; cellIndex<numCells; cellIndex++) { double parity = cellSideParities(cellIndex,sideOrdinal); if (parity != 1.0) { // otherwise, we can just leave things be... for (int fieldIndex=0; fieldIndex<numFields; fieldIndex++) { for (int ptIndex=0; ptIndex<numPoints; ptIndex++) { materialDataAppliedToTrialValues(cellIndex,fieldIndex,ptIndex) *= parity; } } } } } FieldContainer<double> cubPointsSidePhysical = basisCache.getPhysicalCubaturePointsForSide(sideOrdinal); FieldContainer<double> materialDataAppliedToTestValues = *testValuesTransformedWeighted; // copy first bilinearForm->applyBilinearFormData(materialDataAppliedToTrialValues,materialDataAppliedToTestValues, trialID,testID,operatorIndex,cubPointsSidePhysical); int testDofOffset = testOrdering->getDofIndex(testID,0,0); weightCellBasisValues(materialDataAppliedToTestValues, weights, testDofOffset); // d. Sum up (integrate) and place in stiffness matrix according to DofOrdering indices FunctionSpaceTools::integrate<double>(miniStiffness,materialDataAppliedToTestValues,materialDataAppliedToTrialValues,COMP_BLAS); // place in the appropriate spot in the element-stiffness matrix // copy goes from (cell,trial_basis_dof,test_basis_dof) to (cell,element_trial_dof,element_test_dof) for (int i=0; i < testBasis->getCardinality(); i++) { for (int j=0; j < trialBasis->getCardinality(); j++) { int trialDofIndex = trialOrdering->getDofIndex(trialID,j,sideOrdinal); for (unsigned k=0; k < numCells; k++) { stiffness(k,optTestIndex,trialDofIndex) += miniStiffness(k,i,j); } } } } } testOpIt++; } } } } }
int _tmain(int argc, _TCHAR* argv[]) { long pmax = 10000000; vector<long> primes = sieve_of_eratosthenes(pmax); long long sum = 0; for (vector<long>::iterator it=primes.begin(); it!= primes.end(); it++) { long p = *it; // every 1 digit prime is a relative if (p<10) { relatives.insert(*it); continue; } bool condition_met = false; // condition 1 // change all digits possible int len = findn(*it); for (long exponent=1; exponent < p ; exponent *= 10) { long limit = p/exponent % 10; long newp = p; for (int n=0; n<limit; n++) { newp -= exponent; if (relatives.find(newp) != relatives.end() && findn(newp) + 1 >= len) { relatives.insert(*it); exponent=p; n=limit; condition_met=true; } } } // condition 2 // remove leftmost digit if ( condition_met == false ) { long newp = p % getexp(p); if (relatives.find(newp) != relatives.end() && findn(newp) + 1 >= len) { relatives.insert(*it); condition_met=true; } } if (condition_met) { if ( no_relatives.size() > 0 ) { set<long> erased = recheck_non_relatives(p); set<long> erased2; set<long> new_erased; while (erased.size() > 0) { erased2.clear(); new_erased.clear(); for (set<long>::iterator sit=erased.begin(); sit != erased.end(); sit++) { erased2 = recheck_non_relatives(*sit); for (set<long>::iterator sit2=erased2.begin(); sit2 != erased2.end(); sit2++) { new_erased.insert(*sit2); } } erased = new_erased; } } } else { no_relatives.insert(*it); sum += *it; cout << *it << endl; } } cout << "--------------" << endl << sum << endl; system("PAUSE"); return 0; }
bool contains(set<T> container, string key) { return container.find(key) != container.end(); }
virtual void handle() { // the host has departed // set<HOST*>::iterator i = hosts.find(this); hosts.erase(i); }
void addUrlIfNotContain(string url) { boost::mutex::scoped_lock mylock(urlsMutex); if ((parsedPages.find(url) == parsedPages.end()) && (pagesToParse.find(url) == pagesToParse.end())) { pagesToParse.insert(url); } }
/*! Return true if a SPICE kernel has already been loaded, false if not. */ bool IsSpiceKernelLoaded(const string& filepath) { return ResidentSpiceKernels.find(filepath) != ResidentSpiceKernels.end(); }
void dfs(string str, int deep) { if (flag) return; if (str.size() == 47) { if (str == original) { flag = 1; times = deep; } return; } int i, j; for (i = 0; i < str.size(); ++i) { if (str[i] == 'C' || str[i] == 'O' || str[i] == 'W') break; } if (!prefix(str, i)) return; if (str[i] != 'C') return; int pre = i + 1, start = i; bool cut = 0; for (i = pre; i < str.size(); ++i) { if (str[i] == 'C' || str[i] == 'O' || str[i] == 'W') { if (!sub(str, pre, i)) { cut = 1; break; } pre = i + 1; } } if (cut) return; if (str[pre - 1] != 'W') return; if (!suffix(str, pre)) return; for (j = 0; j < str.size(); ++j) { if (flag) return; for (i = 0; i < j; ++i) { if (flag) return; for (int k = str.size() - 1; k > j; --k) { if (flag) return; if (str[i] == 'C' && str[j] == 'O' && str[k] == 'W') { string temp; for (int l = 0; l < i; ++l) temp += str[l]; for (int l = j + 1; l < k; ++l) temp += str[l]; for (int l = i + 1; l < j; ++l) temp += str[l]; for (int l = k + 1; l < str.size(); ++l) temp += str[l]; if (st.find(temp) == st.end() && st.size() < 50000) //Ì«¼ÙÁË- - { st.insert(temp); dfs(temp, deep + 1); } } } } } }
void add_include_names( const string& file_name, bool is_root_file = true ) { string path; ifstream inpf( file_name.c_str( ) ); if( is_root_file && !inpf ) { cerr << "Error: Unable to open source file '" << file_name << "' for input." << endl; exit( 1 ); } if( !is_root_file ) { set< string >::iterator i; for( i = include_paths.begin( ); i != include_paths.end( ); ++i ) { string str( *i ); str += '\\'; str += file_name; inpf.clear( ); inpf.open( str.c_str( ), ios::in ); if( inpf ) { path = *i; break; } } if( !inpf ) { cerr << "Error: Unable to open source file '" << file_name << "' for input." << endl; exit( 1 ); } string str( path ); if( !str.empty( ) ) str += '\\'; str += file_name; transform_path_separators( str ); if( include_names.find( str ) != include_names.end( ) ) return; include_names.insert( str ); size_t pos = str.find_last_of( '\\' ); if( pos != string::npos ) { string current = str.substr( 0, pos ); if( include_paths.find( current ) == include_paths.end( ) ) include_paths.insert( current ); } } string line, include; while( getline( inpf, line ) ) { if( get_include_name( line, include ) ) add_include_names( include, false ); } }
int main( ) { freopen( "ttwo.in", "r", stdin ); freopen( "ttwo.out", "w", stdout ); for ( int i = 1; i < MAXN; ++i ) { for ( int j = 1; j < MAXN; ++j ) { scanf( " %c", &maze[i][j] ); } } for ( int i = 0; i <= MAXN; ++i ) { maze[0][i] = '*'; maze[MAXN][i] = '*'; maze[i][0] = '*'; maze[i][MAXN] = '*'; } state start; for ( int i = 1; i <= MAXN; ++i ) for ( int j = 1; j <= MAXN; ++j ) { if ( maze[i][j] == 'F' ) { start.john_x = i; start.john_y = j; start.john_dir = NORTH; maze[i][j] = '.'; }else if ( maze[i][j] == 'C' ) { start.cow_x = i; start.cow_y = j; start.cow_dir = NORTH; maze[i][j] = '.'; } } start.cost = 0; q.push( start ); s.insert( vstate( start ) ); if ( check( start ) ) { printf( "0\n" ); return 0; } while ( !q.empty() ) { state top = q.front(); q.pop(); ++top.cost; state tmp = top; if ( valid( top.cow_x + dx[ top.cow_dir ], top.cow_y + dy[ top.cow_dir ] ) ) { if ( maze[ top.cow_x + dx[ top.cow_dir ] ][ top.cow_y + dy[ top.cow_dir ] ] == '*' ) { tmp.cow_dir += 1; tmp.cow_dir %= MODN; }else { tmp.cow_x += dx[ tmp.cow_dir ]; tmp.cow_y += dy[ tmp.cow_dir ]; } }else { tmp.cow_dir += 1; tmp.cow_dir %= MODN; } if ( valid( top.john_x + dx[ top.john_dir ], top.john_y + dy[ top.john_dir ] ) ) { if ( maze[ top.john_x + dx[ top.john_dir ] ][ top.john_y + dy[ top.john_dir ] ] == '*' ) { tmp.john_dir += 1; tmp.john_dir %= MODN; }else { tmp.john_x += dx[ tmp.john_dir ]; tmp.john_y += dy[ tmp.john_dir ]; } }else { tmp.john_dir += 1; tmp.john_dir %= MODN; } if ( s.find( vstate( tmp ) ) == s.end( ) ) { q.push( tmp ); s.insert( vstate( tmp ) ); if ( check( tmp ) ) { printf( "%d\n", tmp.cost ); found = true; break; } } } if ( !found ) { printf( "0\n" ); } return 0; }
// Map the input segments down until reaching the target genome. If the // target genome is above the source genome, fail miserably. // Destructive to any data in the input or results list. static hal_size_t mapRecursiveDown(list<MappedSegmentPtr> &input, list<MappedSegmentPtr> &results, const Genome *tgtGenome, const set<string> &namesOnPath, bool doDupes, hal_size_t minLength) { list<MappedSegmentPtr> *inputPtr = &input; list<MappedSegmentPtr> *outputPtr = &results; if (inputPtr->empty()) { results = *inputPtr; return 0; } const Genome *curGenome = (*inputPtr->begin())->getGenome(); assert(curGenome != NULL); if (curGenome == tgtGenome) { results = *inputPtr; return 0; } // Find the correct child to move down into. const Genome *nextGenome = NULL; hal_size_t nextChildIndex = numeric_limits<hal_size_t>::max(); const Alignment *alignment = curGenome->getAlignment(); vector<string> childNames = alignment->getChildNames(curGenome->getName()); for (hal_size_t child = 0; nextGenome == NULL && child < childNames.size(); ++child) { if (childNames[child] == tgtGenome->getName() || namesOnPath.find(childNames[child]) != namesOnPath.end()) { const Genome *childGenome = curGenome->getChild(child); nextGenome = childGenome; nextChildIndex = child; } } if (nextGenome == NULL) { throw hal_exception("Could not find correct child that leads from " + curGenome->getName() + " to " + tgtGenome->getName()); } assert(nextGenome->getParent() == curGenome); // Map the actual segments down. list<MappedSegmentPtr>::iterator i = inputPtr->begin(); for (; i != inputPtr->end(); ++i) { assert((*i)->getGenome() == curGenome); mapDown(*i, nextChildIndex, *outputPtr, minLength); } // Find paralogs. if (doDupes == true) { swap(inputPtr, outputPtr); outputPtr->clear(); list<MappedSegmentPtr>::iterator i = inputPtr->begin(); for (; i != inputPtr->end(); ++i) { assert((*i)->getGenome() == nextGenome); mapSelf(*i, *outputPtr, minLength); } } if (nextGenome != tgtGenome) { // Continue the recursion. swap(inputPtr, outputPtr); outputPtr->clear(); mapRecursiveDown(*inputPtr, *outputPtr, tgtGenome, namesOnPath, doDupes, minLength); } if (outputPtr != &results) { results = *outputPtr; } results.sort(MappedSegment::LessSourcePtr()); results.unique(MappedSegment::EqualToPtr()); return results.size(); }
long long getSum(int n, int q, int A, int B, int C){ ll a = A, b = B, c = C; ::n = n; have.clear(); for(int i = 0; i < n; i++) { a = (a * b + c) % mod; ll p = a % (mod - n + i + 1); if(have.find(p) != have.end()) p = mod - n + i; have.insert(p); arr[i] = mpr(p, i); } for(int i = 0; i < q; i++) { a = (a * b + c) % mod; que[i].first = a % n; a = (a * b + c) % mod; que[i].second = a; } sort(arr, arr + n); nl = 0, nr = 0; for(int i = 0; i < n; i++) { if(arr[i].first % 2 == 0) r[nr++] = arr[i]; else l[nl++] = arr[i]; loc[arr[i].second] = i; } ll ans = 0; for(int i = 0; i < q; i++) { int rloc = loc[que[i].first]; int pl = 0, pr = nl - 1; while(pl != pr) { int mid = (pl + pr) / 2; int rl = 0, rr = nr; while(rl < rr) { int rmid = (rl + rr) / 2; if(l[mid].first - que[i].second * 2 > r[rmid].first) rl = rmid + 1; else rr = rmid; } if(mid + rl >= rloc) pr = mid; else pl = mid + 1; } int pans = pl; int rl = 0, rr = nr; while(rl < rr) { int rmid = (rl + rr) / 2; if(l[pl].first - que[i].second * 2 > r[rmid].first) rl = rmid + 1; else rr = rmid; } pans += rl; if(pans == rloc) { ans += abs(l[pl].first - que[i].second); continue; } pl = 0, pr = nr - 1; while(pl != pr) { int mid = (pl + pr) / 2; int rl = 0, rr = nl; while(rl < rr) { int rmid = (rl + rr) / 2; if(r[mid].first + que[i].second * 2 > l[rmid].first) rl = rmid + 1; else rr = rmid; } pans = mid + rl; if(mid + rl >= rloc) pr = mid; else pl = mid + 1; } ans += abs(r[pl].first + que[i].second); // #ifdef DEBUG //...................................................................................................... pans = pl; rl = 0, rr = nl; while(rl < rr) { int rmid = (rl + rr) / 2; if(r[pl].first + que[i].second * 2 > l[rmid].first) rl = rmid + 1; else rr = rmid; } pans += rl; if(pans != rloc) { cerr << 1 << endl; } #endif //........................................................................................................... } return ans; }
bool IpDoesPush (ADDRINT ip) { return (pushIps.find(ip) != pushIps.end()); }
void CSSHScheduler::scheduleTasks(const CTopoCore& _topology, const weakChannelInfoVector_t& _channels, hostToChannelMap_t& _hostToChannelMap, set<uint64_t>& _scheduledTasks, const set<uint64_t>& _tasksInCollections, bool useRequirement, const CTopoCore::IdSet_t* _addedTasks) { STopoRuntimeTask::FilterIteratorPair_t tasks = _topology.getRuntimeTaskIterator(); for (auto it = tasks.first; it != tasks.second; it++) { uint64_t id = it->first; // Check if tasks is in the added tasks if (_addedTasks != nullptr && _addedTasks->find(it->first) == _addedTasks->end()) continue; // Check if task has to be scheduled in the collection if (_tasksInCollections.find(id) != _tasksInCollections.end()) continue; // Check if task was already scheduled in the collection if (_scheduledTasks.find(id) != _scheduledTasks.end()) continue; CTopoTask::Ptr_t task = it->second.m_task; // First path only for tasks with requirements; // Second path for tasks without requirements. // SSH scheduler doesn't support multiple requirements if (task->getNofRequirements() > 1) { stringstream ss; ss << "Unable to schedule task <" << id << "> with path " << task->getPath() << ": SSH scheduler doesn't support multiple requirements."; throw runtime_error(ss.str()); } CTopoRequirement::Ptr_t requirement = (task->getNofRequirements() == 1) ? task->getRequirements()[0] : nullptr; if ((useRequirement && requirement == nullptr) || (!useRequirement && requirement != nullptr)) continue; bool taskAssigned = false; for (auto& v : _hostToChannelMap) { const bool requirementOk = checkRequirement(requirement, useRequirement, v.first.first, v.first.second); if (requirementOk) { if (!v.second.empty()) { size_t channelIndex = v.second.back(); const auto& channel = _channels[channelIndex]; SSchedule schedule; schedule.m_weakChannelInfo = channel; schedule.m_taskInfo = it->second; schedule.m_taskID = id; m_schedule.push_back(schedule); v.second.pop_back(); taskAssigned = true; break; } } } if (!taskAssigned) { LOG(debug) << toString(); stringstream ss; string requirementStr = (useRequirement) ? ("Requirement " + requirement->getName() + " couldn't be satisfied.") : "Not enough worker nodes."; ss << "Unable to schedule task <" << id << "> with path " << task->getPath() << ".\n" << requirementStr; throw runtime_error(ss.str()); } } }
/* * === FUNCTION ====================================================================== * Name: removeDeadEndNodes * Description: remove dead end nodes and their incident edges * ===================================================================================== */ UINT64 OverlapGraphSimple::removeParDeadEndNodes(map<UINT64, t_edge_vec* > *parGraph, set<UINT64> &markedNodes, vector<UINT64> &nodeList) { CLOCKSTART; vector<UINT64> nodes_to_remove; #pragma omp parallel for schedule(dynamic) num_threads(p_ThreadPoolSize) for(size_t i=0; i<nodeList.size(); i++) { map<UINT64, vector<EdgeSimple*> * >::iterator it=parGraph->find(nodeList[i]); if(!it->second->empty()) // If the read has some edges. { bool isDeadEnd = true; // flag for dead end edge UINT64 inEdge = 0; // number of incoming edges to this node UINT64 outEdge = 0; // number of outgoing edges from this node // Find number of in- and out- edges for(UINT64 j=0; j < it->second->size(); j++) { EdgeSimple * edge = it->second->at(j); //If edge points to a node not marked in this partition donot assume dead end delete it. UINT64 destID = edge->getDestinationRead(); if(markedNodes.find(destID) == markedNodes.end()) { isDeadEnd = false; break; } /* Break case: * 0. edge already marked as not dead end * 1. composite edge with more than minReadsCountInEdgeToBeNotDeadEnd (deafult: 10) * 2. composite edge longer than minEdgeLengthToBeNotDeadEnd (default: 500) * 3. the edge is loop for the current node * Then flag=1 and exit the loop */ if (edge->isNotDeadEnd()){ isDeadEnd = false; break; } if(edge->isListofReads() && edge->getListofReadsSize() >= minReadsCountInEdgeToBeNotDeadEnd) { edge->markNotDeadEnd(); isDeadEnd = false; break; } if(edge->getEdgeLength() >= minEdgeLengthToBeNotDeadEnd) { edge->markNotDeadEnd(); isDeadEnd = false; break; } if(edge->isLoop()) { edge->markNotDeadEnd(); isDeadEnd = false; break; } if((edge->getOrientation() >> 1) & 1) ++outEdge; else ++inEdge; } // no good edges incident to the node and only in-edges or out-edges if( isDeadEnd && inEdge*outEdge == 0 && inEdge + outEdge > 0){ #pragma omp critical(updateNodeList) { nodes_to_remove.push_back(it->first); } } }
void addLocations(const vector<MemoryBlock> &blocks,unsigned int value,const set<BlockValueLocation> &locationsToIntersect,vector<BlockValueLocation> &newLocations,const vector<pair<unsigned char *,int> > &ramBlocks) { //cout << "ON SIZE: " << sizeof(T) << endl; for(int a=0;a<(int)blocks.size();a++) { //cout << "ON BLOCK: " << a << " WITH SIZE " << blocks[a].size << endl; for(int b=0;b<int(blocks[a].size);b++) { //cout << "BLOCK INDEX: " << b << endl; //if(b<=(int(blocks[a].size)-sizeof(T))) //cout << "IN RANGE\n"; //cout << "VALUE: " << *((T*)(blocks[a].data+b)) << endl; if(b>(int(blocks[a].size)-sizeof(T))) continue; if( (((T)value) == *((T*)(blocks[a].data+b))) ) { bool doNotAdd=false; if(!doNotAdd) { BlockValueLocation bvl(0,a,b,sizeof(T),0); if(locationsToIntersect.empty()==false) { doNotAdd=false; if(locationsToIntersect.find(bvl)==locationsToIntersect.end()) doNotAdd=true; if(!doNotAdd) { newLocations.push_back(bvl); } } else { newLocations.push_back(bvl); } } } } } //cout << "ON SIZE: " << sizeof(T) << endl; for(int a=0;a<(int)ramBlocks.size();a++) { //cout << "ON BLOCK: " << a << " WITH SIZE " << blocks[a].size << endl; for(int b=0;b<int(ramBlocks[a].second);b++) { //cout << "BLOCK INDEX: " << b << endl; //if(b<=(int(blocks[a].size)-sizeof(T))) //cout << "IN RANGE\n"; //cout << "VALUE: " << *((T*)(blocks[a].data+b)) << endl; if(b>(int(ramBlocks[a].second)-sizeof(T))) continue; if( (((T)value) == *((T*)(ramBlocks[a].first+b))) ) { bool doNotAdd=false; if(!doNotAdd) { BlockValueLocation bvl(1,a,b,sizeof(T),0); if(locationsToIntersect.empty()==false) { doNotAdd=false; if(locationsToIntersect.find(bvl)==locationsToIntersect.end()) doNotAdd=true; if(!doNotAdd) { newLocations.push_back(bvl); } } else { newLocations.push_back(bvl); } } } } } }
// The execution function for the retransmission thread void FMTPSender::RunRetransThread(int sock, map<uint, int>& retrans_fd_map, set<uint>& timeout_set) { int sock_fd = sock; map<uint, int>::iterator it; char recv_buf[FMTP_PACKET_LEN]; FmtpHeader* recv_header = (FmtpHeader*)recv_buf; char* recv_packet_data = recv_buf + FMTP_HLEN; FmtpRetransRequest* retx_request = (FmtpRetransRequest*)recv_packet_data; char send_buf[FMTP_PACKET_LEN]; FmtpHeader* send_header = (FmtpHeader*)send_buf; char* send_packet_data = send_buf + FMTP_HLEN; while (true) { if (retrans_tcp_server->Receive(sock_fd, recv_header, FMTP_HLEN) <= 0) { SysError("FMTPSender::RunRetransThread()::receive header error"); } // Handle a retransmission request if (recv_header->flags & FMTP_RETRANS_REQ) { if (retrans_tcp_server->Receive(sock_fd, retx_request, recv_header->data_len) < 0) { SysError("FMTPSender::RunRetransThread()::receive retx request data error"); } MessageMetadata* meta = metadata.GetMetadata(retx_request->msg_id); if (meta == NULL) { //cout << "Error: could not find metadata for file " << retx_request->msg_id << endl; continue; } else if (timeout_set.find(retx_request->msg_id) != timeout_set.end()) { continue; } // check whether the retransmission for the file has already time out if (GetElapsedSeconds(meta->multicast_start_cpu_time) > meta->retx_timeout_seconds) { //cout << "Retx timeout for file " << retx_request->msg_id << ". Elapsed Time: " // << GetElapsedSeconds(meta->multicast_start_cpu_time) << " Timeout: " << meta->retx_timeout_seconds << endl; send_header->session_id = retx_request->msg_id; send_header->flags = FMTP_RETRANS_TIMEOUT; send_header->data_len = 0; retrans_tcp_server->SelectSend(sock_fd, send_buf, FMTP_HLEN); timeout_set.insert(retx_request->msg_id); } else if (meta->is_disk_file) { // is disk file transfer FileMessageMetadata* file_meta = (FileMessageMetadata*)meta; // get the file descriptor to read data from the file int fd; if ( (it = retrans_fd_map.find(recv_header->session_id)) != retrans_fd_map.end()) { fd = it->second; } else { if ( (fd = open(file_meta->file_name.c_str(), O_RDONLY)) < 0) SysError("FMTPSender::RunRetransThread() file open error"); else retrans_fd_map[recv_header->session_id] = fd; } // send the missing blocks to the receiver lseek(fd, retx_request->seq_num, SEEK_SET); size_t remained_size = retx_request->data_len; size_t curr_pos = retx_request->seq_num; send_header->session_id = recv_header->session_id; send_header->flags = FMTP_RETRANS_DATA; while (remained_size > 0) { size_t data_length = remained_size > FMTP_DATA_LEN ? FMTP_DATA_LEN : remained_size; send_header->seq_number = curr_pos; send_header->data_len = data_length; read(fd, send_packet_data, send_header->data_len); retrans_tcp_server->SelectSend(sock_fd, send_buf, FMTP_HLEN + send_header->data_len); curr_pos += data_length; remained_size -= data_length; // Update statistics send_stats.total_retrans_packets++; send_stats.total_retrans_bytes += send_header->data_len; //file_meta->stats.session_retrans_packets++; //file_meta->stats.session_retrans_bytes += header->data_len; } } else { // is memory data transfer } } else if (recv_header->flags & FMTP_RETRANS_END) { if (retrans_tcp_server->Receive(sock_fd, retx_request, recv_header->data_len) < 0) { SysError("FMTPSender::RunRetransThread()::receive retx end msg error"); } // send back the retransmission end message to the receiver send_header->session_id = recv_header->session_id; send_header->seq_number = 0; send_header->data_len = 0; send_header->flags = FMTP_RETRANS_END; retrans_tcp_server->SelectSend(sock_fd, send_header, FMTP_HLEN); map<uint, int>::iterator it = retrans_fd_map.find(recv_header->session_id); if ( it != retrans_fd_map.end() ) { close(it->second); retrans_fd_map.erase(it); } if ( timeout_set.find(recv_header->session_id) != timeout_set.end() ) timeout_set.erase(recv_header->session_id); // mark the completion of retransmission to one receiver metadata.RemoveFinishedReceiver(recv_header->session_id, sock_fd); } else if (recv_header->flags & FMTP_HISTORY_STATISTICS) { char* buf = new char[recv_header->data_len + 1]; if (retrans_tcp_server->Receive(sock_fd, buf, recv_header->data_len) < 0) { break; } buf[recv_header->data_len] = '\0'; status_proxy->SendMessageLocal(EXP_RESULT_REPORT, buf); delete[] buf; cout << "Received a history statistics from socket " << sock_fd << endl; } } cout << "Retransmission thread exited for socket " << sock_fd << endl; }
int Canvas::_key_up(lua_State *l) { int key = pop_key(l); lua_pushboolean(l, keys_up.find(key) != keys_up.end()); return 1; }
int main() { int i = 0, j = 0, k = 0, idx; int a, b; P e; scanf("%d %d", &n, &m); for(i = 0; i < m; i++) { scanf("%d %d", &a, &b); G[a].push_back(b); G[b].push_back(a); ori_edges.push_back(make_pair(a, b)); } Fill(parent, 0); Fill(dfn, 0); Fill(low, 0); Fill(vis, 0); get_bridge(1); /*for(it = bridge.begin(); it != bridge.end(); it++) cout << (*it).first << " " << (*it).second << endl;*/ Fill(vis, 0); Fill(tag, 0); count_ = 0; ans = 0; for(i = 1; i <= n; i++) { if(!vis[i]) {//Debug(i); cnt = 0; count_++; dfs_common(i); //Debug(cnt); //ans = max(ans, cnt); if(cnt > ans) { ans = cnt; idx = count_; } } } //4 0 1 1 0 0 1 /*for(i = 1; i<= n; i++) cout << tag[i] << " "; cout << endl;*/ //Fill(tag_inv, 0); /* 将bridge中的边转换为用tag值练成的边,存到G2中 */ for(it = bridge.begin(); it != bridge.end(); it++) { e = (*it); G2[tag[e.first]].push_back(e); } /* 对G2的点进行深搜,按照顺序连边,并且把tag转为边的点 */ //Debug(idx); dfs_bridge(idx, -1); printf("%d\n", ans); for(i = 0; i < m; i++) { if(ans_set.find(ori_edges[i])!=ans_set.end()) { printf("%d %d\n", ori_edges[i].second, ori_edges[i].first); } else { printf("%d %d\n", ori_edges[i].first, ori_edges[i].second); } } return 0; }
bool is_edge(int i, int j) const{ return _edges.find(make_tuple(i,j))!=_edges.end();}
static int FillShapeValueJson (v8::Isolate* isolate, VocShaper* shaper, TRI_shape_value_t* dst, v8::Handle<v8::Value> const json, size_t level, set<int>& seenHashes, vector<v8::Handle<v8::Object>>& seenObjects, bool create) { v8::HandleScope scope(isolate); if (json->IsRegExp() || json->IsFunction() || json->IsExternal()) { LOG_TRACE("shaper failed because regexp/function/external/date object cannot be converted"); return TRI_ERROR_BAD_PARAMETER; } if (json->IsNull() || json->IsUndefined()) { return FillShapeValueNull(shaper, dst); } if (json->IsBoolean()) { return FillShapeValueBoolean(shaper, dst, json->ToBoolean()); } if (json->IsBooleanObject()) { return FillShapeValueBoolean(shaper, dst, v8::Handle<v8::BooleanObject>::Cast(json)); } if (json->IsNumber()) { return FillShapeValueNumber(shaper, dst, json->ToNumber()); } if (json->IsNumberObject()) { return FillShapeValueNumber(shaper, dst, v8::Handle<v8::NumberObject>::Cast(json)); } if (json->IsString()) { return FillShapeValueString(shaper, dst, json->ToString()); } if (json->IsStringObject()) { return FillShapeValueString(shaper, dst, v8::Handle<v8::StringObject>::Cast(json)->ValueOf()); } else if (json->IsArray()) { return FillShapeValueList(isolate, shaper, dst, v8::Handle<v8::Array>::Cast(json), level, seenHashes, seenObjects, create); } if (json->IsObject()) { v8::Handle<v8::Object> o = json->ToObject(); v8::Handle<v8::String> toJsonString = TRI_V8_PAIR_STRING("toJSON", 6); if (o->Has(toJsonString)) { v8::Handle<v8::Value> func = o->Get(toJsonString); if (func->IsFunction()) { v8::Handle<v8::Function> toJson = v8::Handle<v8::Function>::Cast(func); v8::Handle<v8::Value> args; v8::Handle<v8::Value> result = toJson->Call(o, 0, &args); if (! result.IsEmpty()) { return FillShapeValueString(shaper, dst, result->ToString()); } } } // fall-through intentional // check for cycles int hash = o->GetIdentityHash(); if (seenHashes.find(hash) != seenHashes.end()) { for (auto it = seenObjects.begin(); it != seenObjects.end(); ++it) { if (json->StrictEquals(*it)) { return TRI_ERROR_ARANGO_SHAPER_FAILED; } } } else { seenHashes.insert(hash); } seenObjects.push_back(o); int res = FillShapeValueArray(isolate, shaper, dst, json->ToObject(), level, seenHashes, seenObjects, create); seenObjects.pop_back(); // cannot remove hash value from seenHashes because multiple objects might have the same // hash values (collisions) return res; } LOG_TRACE("shaper failed to convert object"); return TRI_ERROR_BAD_PARAMETER; }
//if is_arc(i,j) is true, is_arc(j,i ) is false //IMORTANT: is_no_edge() is false for (i,j) AND (j,i) bool is_arc(int i, int j) const{ return _arcs.find(make_tuple(i,j))!=_arcs.end(); }
bool check(int c, int o, int cpo) { return city[c] && oper[o] && T.find(cpo) != T.end(); }
void ProcessFile( const string& fileName, const char* programName, FILE* fp, const vector<string>& includePath, string& prependDir, size_t nesting, set<string, less<string> >& cache, PrintFunc printFunc, bool& warn) { printFunc(fileName); if (nesting == 100) { ErrorExit(programName, "Infinite include file recursion? nesting level reached 100"); } PEGASUS_ASSERT(fp != NULL); // For each line in the file: char line[4096]; size_t lineNumber = 1; for (; fgets(line, sizeof(line), fp) != NULL; lineNumber++) { // Check for include directive: string path; char openDelim; if (line[0] == '#' && GetIncludePath(fileName, lineNumber, line, path, openDelim)) { // ATTN: danger! not distinguising between angle brack delimited // and quote delimited paths! set<string, less<string> >::const_iterator pos = cache.find(path); if (pos != cache.end()) { continue; } cache.insert(path); string fullPath; FILE* includeFp = FindFile(includePath, prependDir, path, openDelim, fullPath); if (!includeFp) { if (warn) { string message = "header file not found: " + path + " included from " + fileName; Warning(programName, message); } } else { ProcessFile(fullPath, programName, includeFp, includePath, prependDir, nesting + 1, cache, printFunc, warn); } } } fclose(fp); }
bool isVisited(const set<Node>& visited,const Node& node) { if(visited.find(node) == visited.end()) return false; return true; }
int PalindromizationDiv1::getMinimumCost(string s, vector <string> op) { int n = op.size(); for (int i = 0;i < n;i++) { if (op[i][0] == 'a') { sscanf(op[i].c_str(),"%s%s%d",tmp,o[i].c1,&o[i].cost); o[i].typ = 0; } else if (op[i][0] == 'e') { sscanf(op[i].c_str(),"%s%s%d",tmp,o[i].c1,&o[i].cost); o[i].typ = 1; } else if (op[i][0] == 'c') { sscanf(op[i].c_str(),"%s%s%s%d",tmp,o[i].c1,o[i].c2,&o[i].cost); o[i].typ = 2; } } node now; hash.clear(); while (!Q.empty()) Q.pop(); Q.push(node(s,0)); hash.insert(s); int tim = 0; while (!Q.empty()) { now = Q.top(); Q.pop(); if (palindrome(now.now) == true) return now.cost; tmp1 = now.now; if (tmp1.size() > s.size()*2) continue; for (int i = 0;i < n;i++) { if (o[i].typ == 0) { for (int j = 0;j <= tmp1.size();j++) { tmp2 = tmp1.substr(0,j)+o[i].c1[0]+tmp1.substr(j,tmp1.size()-j); if (hash.find(tmp2) == hash.end()) { hash.insert(tmp2); Q.push(node(tmp2,now.cost+o[i].cost)); } } } else if (o[i].typ == 1) { for (int j = 0;j < tmp1.size();j++) if (tmp1[j] == o[i].c1[0]) { tmp2 = tmp1.substr(0,j)+tmp1.substr(j+1,tmp1.size()-j-1); if (hash.find(tmp2) == hash.end()) { hash.insert(tmp2); Q.push(node(tmp2,now.cost+o[i].cost)); } } } else if (o[i].typ == 2) { for (int j = 0;j < tmp1.size();j++) if (tmp1[j] == o[i].c1[0]) { tmp2 = tmp1; tmp2[j] = o[i].c2[0]; if (hash.find(tmp2) == hash.end()) { hash.insert(tmp2); Q.push(node(tmp2,now.cost+o[i].cost)); } } } } } return -1; }
/* ******************************************************************************************** */ void vd () { // Process the site and circle events while(!eventQueue.empty()) { // avl.draw(); getchar2(); // Check if it is a site event Event* event = eventQueue.top(); eventQueue.pop(); SiteEvent* siteEvent = dynamic_cast <SiteEvent*> (event); if(siteEvent != NULL) { printf("\n--- site --------------------------------------------------\n"); // Update the sweep line location sweepLine = siteEvent->point(1) - 0.0001; printf("sweepLine: %lf\n", sweepLine); printf("new site: (%lf, %lf)\n", siteEvent->point(0), siteEvent->point(1)); //avl.draw(); getchar2(); // Locate the existing arc information pair <bool, AVL<TreeNode*>::Node*> searchRes = avl.search_candidateLoc(new TreeNode(siteEvent->pi, -1, true)); // The tree is empty. Temporarily add the site information as a dummy node if(searchRes.second == NULL) { avl.insert(new TreeNode(siteEvent->pi, -1, true)); printf("Tree empty!\n"); continue; } // The tree still doesn't have a break point, but just a dummy site node information TreeNode* parentNode = searchRes.second->value; if(parentNode->dummy) { avl.remove(parentNode); avl.insert(new TreeNode(parentNode->p0i, siteEvent->pi)); avl.insert(new TreeNode(siteEvent->pi, parentNode->p0i)); printf("Tree dummy!\n"); continue; } // Determine the site by comparing it with the found node value int prevSiteIdx = 0; if(parentNode->value() < siteEvent->point(0)) prevSiteIdx = parentNode->p1i; else prevSiteIdx = parentNode->p0i; printf("Previous site idx: (%d)\n", prevSiteIdx); // Create the new break points TreeNode* newNode1 = new TreeNode(siteEvent->pi, prevSiteIdx); TreeNode* newNode2 = new TreeNode(prevSiteIdx, siteEvent->pi); avl.insert(newNode1); avl.insert(newNode2); // Check for "false alarms" for circle events set <pair<CircleEvent*, Vector2d>, Vector2dComp>::iterator it = allCircles.begin(); printf("# parent circles: %d\n", parentNode->circleEvents.size()); // for(size_t c_i = 0; c_i < parentNode->circleEvents.size(); c_i++) { for(; it != allCircles.end(); it++) { // CircleEvent* ce = parentNode->circleEvents[c_i]; CircleEvent* ce = it->first; printf("\tTriplet (%d,%d,%d)\n", ce->points(0), ce->points(1), ce->points(2)); if((ce->center - siteEvent->point).norm() < ce->radius) { printf("\tRemoving triplet: (%d,%d,%d)\n", ce->points(0),ce->points(1),ce->points(2)); ce->falseAlarm = true; } } // Get the leaf information to check for circles vector <pair<int, AVL<TreeNode*>::Node*> > leafParents; avl.traversal_leaves(leafParents); printf("Traversal: {"); vector <pair<int, TreeNode*> > sites; for(int i = 0; i < leafParents.size(); i++) { TreeNode* node = leafParents[i].second->value; int type = leafParents[i].first; if(type == 2) { printf("(%d,%d), ", node->p0i, node->p1i); sites.push_back(make_pair(node->p0i, node)); sites.push_back(make_pair(node->p1i, node)); } if(type == 0) { printf("%d, ", node->p0i); sites.push_back(make_pair(node->p0i, node)); } if(type == 1) { printf("%d, ", node->p1i); sites.push_back(make_pair(node->p1i, node)); } } printf("\b\b}\n"); // Check for circles in triplets for(int s_i = 0; s_i < sites.size()-2; s_i++) { // Skip newly generated centers int i0 = sites[s_i].first, i1 = sites[s_i+1].first, i2 = sites[s_i+2].first; if(i0 == i2) continue; // If the bottom point of the fit circle can be tangent to the sweep line, // add it to the queue Vector2d center = fitCircle(data[i0], data[i1], data[i2]); double radius = (data[i0]-center).norm(); double temp_y = center(1) - radius; printf("idx: %d, center: (%lf, %lf), temp_y: %lf\n", s_i, center(0), center(1), temp_y); printf("radius: %lf, sweepLine: %lf\n", radius, sweepLine); if(temp_y < sweepLine) { if (allCircles.find(make_pair((CircleEvent*) NULL, center)) != allCircles.end()) { printf("\tTriplet (%d,%d,%d), (%lf, %lf) already exists.\n", i0, i1, i2, center(0), center(1)); printf("all circles #: %lu\n", allCircles.size()); continue; } // Create the circle event CircleEvent* ce = new CircleEvent(); ce->point = Vector2d(center(0), temp_y); ce->points = Vector3i(i0,i1,i2); ce->center = center; ce->radius = radius; eventQueue.push(ce); allCircles.insert(make_pair(ce, ce->center)); printf("\tAdding triplet: (%d,%d,%d), (%lf, %lf)\n", i0, i1, i2, center(0), center(1)); // Register the circle event with the involved arcs sites[s_i].second->circleEvents.push_back(ce); sites[s_i+1].second->circleEvents.push_back(ce); sites[s_i+2].second->circleEvents.push_back(ce); } else printf("\tCircle already passed, not adding!\n"); } } else { printf("\n--- circle ------------------------------------------------\n"); // Update the sweepline CircleEvent* ce = dynamic_cast <CircleEvent*> (event); printf("circle event: point: (%lf, %lf), center:, (%lf, %lf), points: %d, %d, %d\n", ce->point(0), ce->point(1), ce->center(0), ce->center(1), ce->points(0), ce->points(1), ce->points(2)); sweepLine = ce->point(1) + 0.00001; printf("sweepLine: %lf\n", sweepLine); // avl.draw(); getchar2(); // Check if false alarm if(ce->falseAlarm || ce->falseAlarmCircle) { printf("\tFalse alarm!\n"); continue; } // Get the arc that is disappearing due to the circle pair <bool, AVL<TreeNode*>::Node*> searchRes = avl.search_candidateLoc(new TreeNode(ce->point, Vector2d(), true)); assert(searchRes.second != NULL && "Could not find the above arc"); TreeNode* node1 = searchRes.second->value; AVL<TreeNode*>::Node* searchNode = searchRes.second; printf("node1: (%d,%d)\n", node1->p0i, node1->p1i); // Fix node1 if next one is better AVL<TreeNode*>::Node* temp = avl.next(searchNode); AVL<TreeNode*>::Node* temp2 = avl.prev(searchNode); if(temp != NULL) printf("temp: '%s'\n", print(temp->value).c_str()); if(temp != NULL) printf("temp2: '%s'\n", print(temp2->value).c_str()); double diff1 = (node1->value() - ce->point(0)); double diff2 = (temp == NULL) ? 1000.0 : (temp->value->value() - ce->point(0)); double diff3 = (temp2 == NULL) ? 1000.0 : (temp2->value->value() - ce->point(0)); printf("\t%lf vs %lf\n", diff1, diff2); if(fabs(diff2) < fabs(diff1)) { node1 = temp->value; searchNode = temp; printf("\t\tupdating node1 with temp\n"); } printf("\t%lf vs %lf\n", diff1, diff3); if(fabs(diff3) < fabs(diff1)) { node1 = temp2->value; searchNode = temp2; printf("\t\tupdating node1 with temp2\n"); } printf("node1: (%d,%d)\n", node1->p0i, node1->p1i); // Skip if the node can't be found double diff = (node1->value() - ce->point(0)); if(fabs(diff) > 0.05) { printf("Skipping a circle event (node1) because it is behind the beach line\n"); continue; } // Determine the other node AVL<TreeNode*>::Node* opt1 = avl.next(searchNode); if(opt1 != NULL) printf("opt1: '%s'\n", print(opt1->value).c_str()); AVL<TreeNode*>::Node* opt2 = avl.prev(searchNode); if(opt2 != NULL) printf("opt2: '%s'\n", print(opt2->value).c_str()); TreeNode* node2; if(opt1 == NULL) node2 = opt2->value; else if(opt2 == NULL) node2 = opt1->value; else { double diff1 = (node1->value() - opt1->value->value()); double diff2 = (node1->value() - opt2->value->value()); printf("diff1: %lf, diff2: %lf\n", diff1, diff2); if(fabs(diff1) < fabs(diff2)) node2 = opt1->value; else node2 = opt2->value; } // Skip if the node can't be found diff = (node2->value() - ce->point(0)); if(fabs(diff) > 0.05) { printf("Skipping a circle event (node2) because it is behind the beach line\n"); continue; } printf("node1: (%d,%d)\n", node1->p0i, node1->p1i); printf("node2: (%d,%d)\n", node2->p0i, node2->p1i); // Remove any potential circles that were going to use one of the break points for // convergence that just got merged into a voronoi vertex. set <pair<CircleEvent*, Vector2d>, Vector2dComp>::iterator it = allCircles.begin(); int si0 = ce->points(0), si1 = ce->points(1), si2 = ce->points(2); for(; it != allCircles.end(); it++) { CircleEvent* ce = it->first; int i0 = ce->points(0), i1 = ce->points(1), i2 = ce->points(2); bool remove = false; if((i0 == si0 && i1 == si1) || (i1 == si0 && i2 == si1) || (i0 == si1 && i1 == si0) || (i1 == si1 && i2 == si0)) remove = true; if((i0 == si1 && i1 == si2) || (i1 == si1 && i2 == si2) || (i0 == si2 && i1 == si1) || (i1 == si2 && i2 == si1)) remove = true; if(remove) { printf("\tRemoving triplet: (%d,%d,%d)\n", i0, i1, i2); ce->falseAlarmCircle = true; } } // Remove the potential circle events from these nodes for(int ce_i = 0; ce_i < node1->circleEvents.size(); ce_i++) { CircleEvent* ce = node1->circleEvents[ce_i]; if(ce->points[0] == node1->p0i && ce->points[1] == node1->p1i) ce->falseAlarmCircle = true; if(ce->points[1] == node1->p0i && ce->points[2] == node1->p1i) ce->falseAlarmCircle = true; } for(int ce_i = 0; ce_i < node2->circleEvents.size(); ce_i++) { CircleEvent* ce = node2->circleEvents[ce_i]; if(ce->points[0] == node2->p0i && ce->points[1] == node2->p1i) ce->falseAlarmCircle = true; if(ce->points[1] == node2->p0i && ce->points[2] == node2->p1i) ce->falseAlarmCircle = true; } // Remove the arc from the tree printf("Before removes\n"); getchar2(); avl.remove(node1); // avl.draw(); printf("Drawn after remove 1\n"); getchar2(); avl.remove(node2); // avl.draw(); printf("Drawn after remove 2\n"); getchar2(); // Add the new break point TreeNode* newNode; if(node1->p0i == node2->p1i) newNode = new TreeNode(node2->p0i, node1->p1i); else if(node1->p1i == node2->p0i) newNode = new TreeNode(node1->p0i, node2->p1i); else assert(false && "Unknown new break point creation"); avl.insert(newNode); printf("Inserted new node: '%s'\n", print(newNode).c_str()); // Set the second points of the completed voronoi edges node1->edge1->p1 = ce->center; node1->edge2->p0 = ce->center; node2->edge1->p1 = ce->center; node2->edge2->p0 = ce->center; // Find angles around the cell center to place them ccw HalfEdge* e1 = node1->edge1, *e2 = node2->edge2; int site_idx = (node1->p0i == node2->p1i) ? node1->p0i : node1->p1i; Vector2d site = data[site_idx]; Vector2d v1 = (0.5 * (e1->p0 + e1->p1) - site).normalized(); Vector2d v2 = (0.5 * (e2->p0 + e2->p1) - site).normalized(); double angle1 = atan2(v1(1), v1(0)) + (v1(1) < 0 ? 2*M_PI : 0); double angle2 = atan2(v2(1), v2(0)) + (v2(1) < 0 ? 2*M_PI : 0); if((angle1 < angle2) && fabs(angle1-angle2) > M_PI) angle1 += 2*M_PI; else if((angle2 < angle1) && fabs(angle2-angle1) > M_PI) angle2 += 2*M_PI; if(angle1 > angle2) { e1->prev = e2; e2->next = e1; } else { e2->prev = e1; e1->next = e2; } // Get the leaf information to check for circles again vector <pair<int, AVL<TreeNode*>::Node*> > leafParents; avl.traversal_leaves(leafParents); printf("Traversal: {"); vector <pair<int, TreeNode*> > sites; for(int i = 0; i < leafParents.size(); i++) { TreeNode* node = leafParents[i].second->value; int type = leafParents[i].first; if(type == 2) { printf("(%d,%d), ", node->p0i, node->p1i); sites.push_back(make_pair(node->p0i, node)); sites.push_back(make_pair(node->p1i, node)); } if(type == 0) { printf("%d, ", node->p0i); sites.push_back(make_pair(node->p0i, node)); } if(type == 1) { printf("%d, ", node->p1i); sites.push_back(make_pair(node->p1i, node)); } } printf("\b\b}\n"); // Check for circles in triplets for(int s_i = 0; s_i < sites.size()-2; s_i++) { // Skip newly generated centers int i0 = sites[s_i].first, i1 = sites[s_i+1].first, i2 = sites[s_i+2].first; if(i0 == i2) continue; // If the bottom point of the fit circle can be tangent to the sweep line, // add it to the queue Vector2d center = fitCircle(data[i0], data[i1], data[i2]); double temp_y = center(1) - (data[i0]-center).norm(); printf("idx: %d, center: (%lf, %lf), temp_y: %lf\n", s_i, center(0), center(1), temp_y); if(temp_y < sweepLine) { // Check if it existed before set <pair<CircleEvent*, Vector2d>, Vector2dComp>::iterator it = allCircles.find(make_pair((CircleEvent*) NULL, center)); if(it != allCircles.end() && it->first->falseAlarmCircle){ printf("\tTurning on an old false alarm for triplet: %d, %d, %d.\n", it->first->points(0), it->first->points(1), it->first->points(2)); it->first->falseAlarmCircle = false; getchar2(); continue; } else if(it == allCircles.end()) { // Create the circle event CircleEvent* ce = new CircleEvent(); ce->point = Vector2d(center(0), temp_y); ce->points = Vector3i(i0,i1,i2); ce->center = center; eventQueue.push(ce); allCircles.insert(make_pair(ce, ce->center)); printf("\tAdding triplet: (%d, %d, %d)\n", i0, i1, i2); // Register the circle event with the involved arcs sites[s_i].second->circleEvents.push_back(ce); sites[s_i+1].second->circleEvents.push_back(ce); sites[s_i+2].second->circleEvents.push_back(ce); } } } getchar2(); } } }
void read_links(char * filename) { FILE * fptr = fopen(filename,"r"); if (fptr==NULL) { cerr << "failed to open file" << endl; exit(1); } char buffer[5000]; while (fgets(buffer,5000,fptr)) { if (buffer[0]=='#') { continue; } //chr1 59446789 + chr1 59446926 + 13 char chra[10]; int ichra=-1; char stranda; unsigned long coorda; char chrb[10]; int ichrb=-1; char strandb; unsigned long coordb; int support; int ret = sscanf(buffer,"%s\t%lu\t%c\t%s\t%lu\t%c\t%d",chra,&coorda,&stranda,chrb,&coordb,&strandb,&support); edge_info ei; ichra=to_chr(chra); ichrb=to_chr(chrb); if (ichra>24 || ichrb>24 || ichra==0 || ichrb==0) { cerr << " skipping link, chrM or chr?? " << endl; continue; } pos posa=pos(ichra,coorda); if (bps.find(posa)==bps.end()) { continue; } pos posb=pos(ichrb,coordb); if (bps.find(posb)==bps.end()) { continue; } //get the edge type int type=0; if (stranda=='+') { if (strandb=='+') { type=0; } else { //negative type=2; } } else { if (strandb=='+') { type=3; } else { type=1; } } //get the normal support if (bp_support.find(posa)==bp_support.end() ) { cerr << "failed to find posa in bp_support " << endl; } if (bp_support.find(posb)==bp_support.end() ) { cerr << "failed to find posb in bp_support " << endl; } int normal=(bp_support[posa]+bp_support[posb])/4; //the lambda , average of two sites (2 copies each) int tumor=support; edge e = edge(posa,posb,false); if (somatic_edges.find(e)!=somatic_edges.end() && somatic_edges[e].tumor>=ei.tumor) { //skip this already have a better one cerr << "SKipping edge " << buffer << endl; continue; } //set up the ei ei.length=0; ei.type=type; //cerr << posa.str() << " " << posb.str() << " " << normal << " " << tumor << endl; ei.normal=normal; ei.tumor=tumor; ei.poisson(); //put in the forward somatic_edges[e]=ei; //put in the reverse if (type<2) { type=1-type; } somatic_edges[e.reverse()]=ei; somatic_edges[e.reverse()].type=type; jump_edges[posa].insert(posb); jump_edges[posb].insert(posa); } }
inline void my_del(ll x, int index) { prt.erase(prt.find(PLI(x, index))); prt.erase(prt.find(PLI((x + g + r) % (g + r + g + r), index))); }
BSONForEach( k, _keyPattern ) { if ( orderFields.find( k.fieldName() ) != orderFields.end() ) return IndexDetails::HELPFUL; }