typename graph_traits<VertexListGraph>::size_type sequential_vertex_color_ting(const VertexListGraph& G, OrderPA order, ColorMap color) { using graph_traits; using boost::tie; typedef graph_traits<VertexListGraph> GraphTraits; typedef typename GraphTraits::vertex_descriptor Vertex; typedef typename GraphTraits::size_type size_type; size_type max_color = 0; const size_type V = num_vertices(G); // We need to keep track of which colors are used by // adjacent vertices. We do this by marking the colors // that are used. The mark array contains the mark // for each color. The length of mark is the // number of vertices since the maximum possible number of colors // is the number of vertices. std::vector<size_type> mark(V, numeric_limits_max(max_color)); //Initialize colors typename GraphTraits::vertex_iterator v, vend; for (tie(v, vend) = vertices(G); v != vend; ++v) put(color, *v, V-1); //Determine the color for every vertex one by one for ( size_type i = 0; i < V; i++) { Vertex current = get(order,i); typename GraphTraits::adjacency_iterator v, vend; //Mark the colors of vertices adjacent to current. //i can be the value for marking since i increases successively for (tie(v,vend) = adjacent_vertices(current, G); v != vend; ++v) mark[get(color,*v)] = i; //Next step is to assign the smallest un-marked color //to the current vertex. size_type j = 0; //Scan through all useable colors, find the smallest possible //color which is not used by neighbors. Note that if mark[j] //is equal to i, color j is used by one of the current vertex's //neighbors. while ( j < max_color && mark[j] == i ) ++j; if ( j == max_color ) //All colors are used up. Add one more color ++max_color; //At this point, j is the smallest possible color put(color, current, j); //Save the color of vertex current } return max_color; }
/** Return the most likely distance between two contigs and the number * of pairs that support that distance estimate. * @param len0 the length of the first contig in bp * @param len1 the length of the second contig in bp * @param rf whether the fragment library is oriented reverse-forward * @param[out] n the number of samples with a non-zero probability */ int maximumLikelihoodEstimate(unsigned l, int first, int last, const vector<int>& samples, const PMF& pmf, unsigned len0, unsigned len1, bool rf, unsigned& n) { assert(first < last); assert(!samples.empty()); // The aligner is unable to map reads to the ends of the sequence. // Correct for this lack of sensitivity by subtracting l-1 bp from // the length of each sequence, where the aligner requires a match // of at least l bp. When the fragment library is oriented // forward-reverse, subtract 2*(l-1) from each sample. assert(l > 0); assert(len0 >= l); assert(len1 >= l); len0 -= l - 1; len1 -= l - 1; if (len0 > len1) swap(len0, len1); if (rf) { // This library is oriented reverse-forward. Histogram h(samples.begin(), samples.end()); int d; tie(d, n) = maximumLikelihoodEstimate( first, last, h, pmf, len0, len1); return d; } else { // This library is oriented forward-reverse. // Subtract 2*(l-1) from each sample. Histogram h; typedef vector<int> Samples; for (Samples::const_iterator it = samples.begin(); it != samples.end(); ++it) { assert(*it > 2 * (int)(l - 1)); h.insert(*it - 2 * (l - 1)); } int d; tie(d, n) = maximumLikelihoodEstimate( first, last, h, pmf, len0, len1); return max(first, d - 2 * (int)(l - 1)); } }
void UniversalUpdates::PerformUniversalUpdates( bool resources_already_loaded, const QList< Resource* > &resources, const QHash< QString, QString > &updates ) { QHash< QString, QString > html_updates; QHash< QString, QString > css_updates; QHash< QString, QString > xml_updates; tie( html_updates, css_updates, xml_updates ) = SeparateHtmlCssXmlUpdates( updates ); QList< HTMLResource* > html_resources; QList< CSSResource* > css_resources; OPFResource *opf_resource = NULL; NCXResource *ncx_resource = NULL; int num_files = resources.count(); for ( int i = 0; i < num_files; ++i ) { Resource *resource = resources.at( i ); if ( resource->Type() == Resource::HTMLResourceType ) html_resources.append( qobject_cast< HTMLResource* >( resource ) ); else if ( resource->Type() == Resource::CSSResourceType ) css_resources.append( qobject_cast< CSSResource* >( resource ) ); else if ( resource->Type() == Resource::OPFResourceType ) opf_resource = qobject_cast< OPFResource* >( resource ); else if ( resource->Type() == Resource::NCXResourceType ) ncx_resource = qobject_cast< NCXResource* >( resource ); } QFutureSynchronizer<void> sync; if ( resources_already_loaded ) { sync.addFuture( QtConcurrent::map( html_resources, boost::bind( UpdateOneHTMLFile, _1, html_updates, css_updates ) ) ); sync.addFuture( QtConcurrent::map( css_resources, boost::bind( UpdateOneCSSFile, _1, css_updates ) ) ); } else { sync.addFuture( QtConcurrent::map( html_resources, boost::bind( LoadAndUpdateOneHTMLFile, _1, html_updates, css_updates ) ) ); sync.addFuture( QtConcurrent::map( css_resources, boost::bind( LoadAndUpdateOneCSSFile, _1, css_updates ) ) ); } // We can't schedule these with QtConcurrent because they // will (indirectly) call QTextDocument::setPlainText, and if // a tab is open for the ncx/opf, then an event needs to be sent // to the tab widget. Events can't cross threads, and we crash. UpdateNCXFile( ncx_resource, xml_updates ); UpdateOPFFile( opf_resource, xml_updates ); sync.waitForFinished(); }
tuple<int, int, bool> feed_bytes(http_parser& parser, char const* str) { tuple<int, int, bool> ret(0, 0, false); tuple<int, int, bool> prev(0, 0, false); for (int chunks = 1; chunks < 70; ++chunks) { ret = make_tuple(0, 0, false); parser.reset(); buffer::const_interval recv_buf(str, str); for (; *str;) { int chunk_size = (std::min)(chunks, int(strlen(recv_buf.end))); if (chunk_size == 0) break; recv_buf.end += chunk_size; int payload, protocol; bool error = false; tie(payload, protocol) = parser.incoming(recv_buf, error); ret.get<0>() += payload; ret.get<1>() += protocol; ret.get<2>() |= error; // std::cerr << payload << ", " << protocol << ", " << chunk_size << std::endl; TORRENT_ASSERT(payload + protocol == chunk_size || ret.get<2>()); } TEST_CHECK(prev == make_tuple(0, 0, false) || ret == prev || ret.get<2>()); if (!ret.get<2>()) { TEST_EQUAL(ret.get<0>() + ret.get<1>(), strlen(str)); } prev = ret; } return ret; }
void CellGraph::evolve() { CellIterator vi, vi_end; graph_t::adjacency_iterator ni, ni_end; unsigned long arg = 0; for (tie(vi,vi_end) = vertices(m_graph); vi != vi_end; ++vi) { int i = 0; for (tie(ni, ni_end) = adjacent_vertices(*vi, m_graph); ni != ni_end; ++ni) { arg |= m_graph[*ni].cellValue; arg <<= 1; ++i; } m_graph[*vi].cellValue = arg % 2; } }
GraphState CellGraph::getCurrentState() const { CellIterator vi, viend; GraphState state(getVertexCount()); int i = 0; for (tie(vi,viend) = vertices(m_graph); vi != viend; ++vi) state[i++] = m_graph[*vi].cellValue; return state; }
/** Return the most likely distance between two contigs and the number * of pairs that support that estimate. */ static pair<int, unsigned> maximumLikelihoodEstimate(int first, int last, const Histogram& samples, const PMF& pmf, unsigned len0, unsigned len1) { int filterSize = 2 * (int)(0.05 * pmf.mean()) + 3; // want an odd filter size first = max(first, (int)pmf.minValue() - samples.maximum()) - filterSize/2; last = min(last, (int)pmf.maxValue() - samples.minimum()) + filterSize/2 + 1; /* When randomly selecting fragments that span a given point, * longer fragments are more likely to be selected than * shorter fragments. */ WindowFunction window(len0, len1); unsigned nsamples = samples.size(); double bestLikelihood = -numeric_limits<double>::max(); int bestTheta = first; unsigned bestn = 0; vector<double> le; vector<unsigned> le_n; vector<int> le_theta; for (int theta = first; theta <= last; theta++) { // Calculate the normalizing constant of the PMF, f_theta(x). double c = 0; for (int i = pmf.minValue(); i <= (int)pmf.maxValue(); ++i) c += pmf[i] * window(i - theta); double likelihood; unsigned n; tie(likelihood, n) = computeLikelihood(theta, samples, pmf); likelihood -= nsamples * log(c); le.push_back(likelihood); le_n.push_back(n); le_theta.push_back(theta); } HannWindow filter(filterSize); for (int i = filterSize / 2; i < (int)le.size()-(filterSize / 2); i++) { double likelihood = 0; for (int j = -filterSize / 2; j <= filterSize / 2; j++) { assert((unsigned)(i + j) < le.size() && i + j >= 0); likelihood += filter(j) * le[i + j]; } if (le_n[i] > 0 && likelihood > bestLikelihood) { bestLikelihood = likelihood; bestTheta = le_theta[i]; bestn = le_n[i]; } } return make_pair(bestTheta, bestn); }
QString GuideSemantics::GetGuideName(GuideSemantics::GuideSemanticType type) { if (m_GuideTypeMapping.contains(type)) { QString abbrev; QString name; tie(abbrev, name) = m_GuideTypeMapping[type]; return name; } return ""; }
void file_pool::release(void* st) { boost::mutex::scoped_lock l(m_mutex); assert(st != 0); using boost::tie; typedef nth_index<file_set, 2>::type key_view; key_view& kt = get<2>(m_files); key_view::iterator start, end; tie(start, end) = kt.equal_range(st); kt.erase(start, end); }
static float getAlignmentIdentity(const Graph& g, vertex_descriptor t, vertex_descriptor v, It first, It last) { unsigned nbranches = distance(first, last); vector<int> inDists(nbranches); transform(first, last, inDists.begin(), bind(getDistance, boost::cref(g), t, _1)); vector<int> outDists(nbranches); transform(first, last, outDists.begin(), bind(getDistance, boost::cref(g), _1, v)); vector<int> insertLens(nbranches); transform(first, last, insertLens.begin(), bind(getDistance, boost::cref(g), t, _1) + bind(getLength, &g, _1) + bind(getDistance, boost::cref(g), _1, v)); int max_in_overlap = -(*min_element(inDists.begin(), inDists.end())); assert(max_in_overlap >= 0); int max_out_overlap = -(*min_element(outDists.begin(), outDists.end())); assert(max_out_overlap >= 0); int min_insert_len = *min_element(insertLens.begin(), insertLens.end()); int max_insert_len = *max_element(insertLens.begin(), insertLens.end()); float max_identity = (float)(min_insert_len + max_in_overlap + max_out_overlap) / (max_insert_len + max_in_overlap + max_out_overlap); if (min_insert_len <= 0 || max_identity < opt::identity) return max_identity; vector<string> seqs(nbranches); transform(first, last, seqs.begin(), bind(getSequence, &g, _1)); for (unsigned i = 0; i < seqs.size(); i++) { // Remove the overlapping sequence. int n = seqs[i].size(); int l = -inDists[i], r = -outDists[i]; assert(n > l + r); seqs[i] = seqs[i].substr(l, n - l - r); } unsigned matches, consensusSize; tie(matches, consensusSize) = align(seqs); return (float)(matches + max_in_overlap + max_out_overlap) / (consensusSize + max_in_overlap + max_out_overlap); }
// Cleans CSS; currently it removes the redundant CSS classes // that Tidy sometimes adds because it doesn't parse existing // CSS classes, it only adds new ones; this also merges smaller // style tags into larger ones QString CleanSource::CleanCSS(const QString &source, int old_num_styles) { QString newsource = source; QStringList css_style_tags = CSSStyleTags(newsource); // If Tidy added a new tag, we remove the redundant ones if (css_style_tags.count() > old_num_styles) { tie(newsource, css_style_tags) = RemoveRedundantClasses(newsource, css_style_tags); } css_style_tags = RemoveEmptyComments(css_style_tags); css_style_tags = MergeSmallerStyles(css_style_tags); newsource = WriteNewCSSStyleTags(newsource, css_style_tags); return newsource; }
/*! Generate the __init__ function. Generate Constuctor which creates the parameters as member variables */ void siml::PyProcessGenerator::genConstructor() { m_PyFile << format("%|4t|def __init__(self):") << '\n'; //call base class' constructor m_PyFile << format("%|8t|#call base class' constructor.\n"); m_PyFile << format("%|8t|SimulatorBase.__init__(self)\n\n"); //Map for converting variable names to indices or slices //necessary for convenient access to the simulation results from Python. //used by Python functions: get(...), graph(...) //loop produces: self._resultArrayMap = { 'reactor.S':1, 'reactor.X':0, 'reactor.mu':2, } m_PyFile << format("%|8t|#Map for converting variable names to indices or slices.\n"); m_PyFile << format("%|8t|self._resultArrayMap = {"); map<CmPath, string>::const_iterator itMa; for( itMa = m_ResultArrayMap.begin(); itMa != m_ResultArrayMap.end(); ++itMa ) { CmPath path; string simlName, index; tie(path, index) = *itMa; simlName = path.toString(); //the Python access function uses the Siml name m_PyFile << format(" '%1%':%2%,") % simlName % index; ///@todo the algo writes one comma too much (after the last element) } m_PyFile << " }\n\n"; //Set the solution parameters m_PyFile << format("%|8t|#Set the solution parameters.\n"); m_PyFile << format("%|8t|self.reportingInterval = float(%1%)\n") % m_FlatProcess.solutionParameters.reportingInterval; m_PyFile << format("%|8t|self.simulationTime = float(%1%)\n\n") % m_FlatProcess.solutionParameters.simulationTime; //Compute parameter values m_PyFile << format("%|8t|#Compute parameter values.\n"); m_PyFile << format("%|8t|self.setParameters()\n\n"); // //Compute the initial values // m_PyFile << format("%|8t|#Compute the initial values.\n"); // m_PyFile << format("%|8t|self.setInitialValues()\n"); //Easy access to number of state variables and total number of variables m_PyFile << format("%|8t|#Number of state variables and total number of variables.\n"); m_PyFile << format("%|8t|self._numStates = %1%\n") % m_StateVectorSize; m_PyFile << format("%|8t|self._numVariables = %1%\n") % m_ResultArrayColls; m_PyFile << '\n'; ///@todo initialize _resultArray with the right dimensions. Now get() dfails prior to a simulation run. }
CellGraph::CellGraph(size_t vertexCount): // m_graph(new graph_t(vertexCount)), m_graph(vertexCount), key(0x1234567890), constant(vertexCount - (blockSize/2 + keySize/2), 0x42123345643ul) { // TODO: add correct method to fill the cells CellIterator vi, viend; for (tie(vi,viend) = vertices(m_graph); vi != viend; ++vi) m_graph[*vi].cellValue = 0;//rand()%2; cout << "key: " << key << endl; cout << "round constant: "<< constant << endl; offset = 0; }
int main() { tuple<int, double> a, b, c; a = tuple<int, double>(); b = tuple<int, double>(1); c = tuple<int, double>(1, 3.14); a = make_tuple(1, 2.57); int i; double d; tie(i, d) = a; i = a.get<0>(); d = a.get<1>(); std::cout << "version=" << BOOST_VERSION/100000 << "." << ((BOOST_VERSION / 100) % 100) << "." << BOOST_VERSION % 100 << std::endl; return 0; }
/** Return the length of the longest path through the bubble. */ static int longestPath(const Graph& g, const Bubble& topo) { typedef graph_traits<Graph>::edge_descriptor E; typedef graph_traits<Graph>::out_edge_iterator Eit; typedef graph_traits<Graph>::vertex_descriptor V; EdgeWeightMap<Graph> weight(g); map<ContigNode, int> distance; distance[topo.front()] = 0; for (Bubble::const_iterator it = topo.begin(); it != topo.end(); ++it) { V u = *it; Eit eit, elast; for (tie(eit, elast) = out_edges(u, g); eit != elast; ++eit) { E e = *eit; V v = target(e, g); distance[v] = max(distance[v], distance[u] + weight[e]); } } V v = topo.back(); return distance[v] - g[v].length; }
/** Find an equivalent region of the two specified paths. * @param[out] orientation the orientation of the alignment * @return the consensus sequence */ static ContigPath align(const Lengths& lengths, const ContigPath& path1, const ContigPath& path2, ContigNode pivot, dir_type& orientation) { if (&path1 == &path2) { // Ignore the trivial alignment when aligning a path to // itself. } else if (path1 == path2) { // These two paths are identical. orientation = DIR_B; return path1; } else { ContigPath::const_iterator it = search(path1.begin(), path1.end(), path2.begin(), path2.end()); if (it != path1.end()) { // path2 is subsumed in path1. // Determine the orientation of the edge. orientation = it == path1.begin() ? DIR_R : it + path2.size() == path1.end() ? DIR_F : DIR_B; return path1; } } // Find a suitable pivot. if (find(path1.begin(), path1.end(), pivot) == path1.end() || find(path2.begin(), path2.end(), pivot) == path2.end()) { bool good; tie(pivot, good) = findPivot(path1, path2); if (!good) return ContigPath(); } assert(find(path1.begin(), path1.end(), pivot) != path1.end()); ContigPath::const_iterator it2 = find(path2.begin(), path2.end(), pivot); assert(it2 != path2.end()); if (&path1 != &path2) { // The seed must be unique in path2, unless we're aligning a // path to itself. assert(count(it2+1, path2.end(), pivot) == 0); } ContigPath consensus; for (ContigPath::const_iterator it1 = find_if( path1.begin(), path1.end(), bind2nd(equal_to<ContigNode>(), pivot)); it1 != path1.end(); it1 = find_if(it1+1, path1.end(), bind2nd(equal_to<ContigNode>(), pivot))) { if (&*it1 == &*it2) { // We are aligning a path to itself, and this is the // trivial alignment, which we'll ignore. continue; } consensus = align(lengths, path1, path2, it1, it2, orientation); if (!consensus.empty()) return consensus; } return consensus; }