int ns_format_ttl(u_long src, char *dst, size_t dstlen) { char *odst = dst; int secs, mins, hours, days, weeks, x; char *p; secs = (int)(src % 60); src /= 60; mins = (int)(src % 60); src /= 60; hours = (int)(src % 24); src /= 24; days = (int)(src % 7); src /= 7; weeks = (int)src; src = 0; x = 0; if (weeks) { T(fmt1(weeks, 'W', &dst, &dstlen)); x++; } if (days) { T(fmt1(days, 'D', &dst, &dstlen)); x++; } if (hours) { T(fmt1(hours, 'H', &dst, &dstlen)); x++; } if (mins) { T(fmt1(mins, 'M', &dst, &dstlen)); x++; } if (secs || !(weeks || days || hours || mins)) { T(fmt1(secs, 'S', &dst, &dstlen)); x++; } if (x > 1) { int ch; for (p = odst; (ch = *p) != '\0'; p++) if (isascii(ch) && isupper(ch)) *p = tolower(ch); } assert(INT_MIN <= (dst - odst) && (dst - odst) <= INT_MAX); return (int)(dst - odst); }
// print test parameters for current delay time void Responder::print_formatted_delay_line(const uint64_t simulate_duration, const uint64_t old_simulate_duration, const STATS& statsPrev, const double delay, const double simulate_frequency) { if(_y_delay_pos < 0 || _x_delay_pos < 0){ // make sure it gets printed to the same position everytime getyx(_window, _y_delay_pos, _x_delay_pos); } double score = 0.0; if (statsPrev.detected > 0) score = 100.0 * (double)(statsPrev.detected - statsPrev.missed) / (double)statsPrev.detected; std::string form; boost::format fmt0("Delay now: %.6f (previous delay %.6f scored %.1f%% [%ld / %ld])"); fmt0 % delay % statsPrev.delay % score % (statsPrev.detected - statsPrev.missed) % statsPrev.detected; form += fmt0.str(); if (old_simulate_duration != simulate_duration) { boost::format fmt1(" [Simulation rate now: %.1f Hz (%ld samples)]"); fmt1 % simulate_frequency % simulate_duration; form = form + fmt1.str(); } move(_y_delay_pos, _x_delay_pos); print_msg(form); }
int main( int argc, char * argv[] ) { Libnucnet *p_my_nucnet; Libnucnet__NetView * p_net_view, * p_cluster_view; std::pair<double,double> flows; double d_min; //============================================================================ // Check input. //============================================================================ if ( argc < 4 || argc > 6 ) { fprintf( stderr, "\nUsage: %s xml_filename zone_xpath cluster_xpath min_flow reac_xpath\n\n", argv[0] ); fprintf( stderr, " xml_filename = input xml filename\n\n" ); fprintf( stderr, " zone_xpath = XPath to select zones for flows\n\n" ); fprintf( stderr, " cluster_xpath = XPath to select cluster\n\n" ); fprintf( stderr, " min_flow = minimum net flow for printout (optional--default=0)\n\n" ); fprintf( stderr, " reac_xpath = reaction xpath (optional)\n\n" ); return EXIT_FAILURE; } //============================================================================ // Read file and exit if not present. //============================================================================ p_my_nucnet = Libnucnet__new_from_xml( argv[1], NULL, NULL, argv[2] ); if( !p_my_nucnet ) { fprintf( stderr, "Input data not read!\n" ); return EXIT_FAILURE; } //============================================================================ // Register rate functions. //============================================================================ user::register_my_rate_functions( Libnucnet__Net__getReac( Libnucnet__getNet( p_my_nucnet ) ) ); //============================================================================ // Get the minimum net flow for printout. //============================================================================ if( argc > 4 ) d_min = atof( argv[4] ); else d_min = 0.; //============================================================================ // Get printout formats. //============================================================================ boost::format fmt1( "time(s) = %9.4e t9 = %6.4f rho(g/cc) = %9.4e Ye = %6.4f" ); boost::format fmt2( "time(s) = %9.4e t9 = %6.4f rho(g/cc) = %9.4e" ); boost::format fmt3( "%-55s%12.3e%12.3e%12.3e" ); //============================================================================ // Get valid net view. //============================================================================ if( argc != 6 ) p_net_view = Libnucnet__NetView__new( Libnucnet__getNet( p_my_nucnet ), "", "" ); else p_net_view = Libnucnet__NetView__new( Libnucnet__getNet( p_my_nucnet ), "", argv[5] ); //============================================================================ // Set compare function. //============================================================================ Libnucnet__Reac__setReactionCompareFunction( Libnucnet__Net__getReac( Libnucnet__NetView__getNet( p_net_view ) ), (Libnucnet__Reaction__compare_function) nnt::compare_reactions_by_string ); //============================================================================ // Get the reactions. //============================================================================ nnt::reaction_list_t reaction_list = nnt::make_reaction_list( Libnucnet__Net__getReac( Libnucnet__NetView__getNet( p_net_view ) ) ); //============================================================================ // Get the cluster view. //============================================================================ p_cluster_view = Libnucnet__NetView__new( Libnucnet__getNet( p_my_nucnet ), argv[3], "" ); //============================================================================ // Iterate the zones. //============================================================================ Libnucnet__setZoneCompareFunction( p_my_nucnet, (Libnucnet__Zone__compare_function) nnt::zone_compare_by_first_label ); BOOST_FOREACH( nnt::Zone zone, nnt::make_zone_list( p_my_nucnet ) ) { Libnucnet__Zone__updateNetView( zone.getNucnetZone(), argv[3], "", NULL, Libnucnet__NetView__copy( p_cluster_view ) ); user::update_my_rate_functions_data( zone ); //========================================================================== // Print conditions. //========================================================================== if( zone.hasProperty( nnt::s_TIME ) ) { fmt1 % boost::lexical_cast<double>( zone.getProperty( nnt::s_TIME ) ) % boost::lexical_cast<double>( zone.getProperty( nnt::s_T9 ) ) % boost::lexical_cast<double>( zone.getProperty( nnt::s_RHO ) ) % Libnucnet__Zone__computeZMoment( zone.getNucnetZone(), 1 ); std::cout << fmt1.str() << std::endl; } else { fmt1 % boost::lexical_cast<double>( zone.getProperty( nnt::s_TIME ) ) % boost::lexical_cast<double>( zone.getProperty( nnt::s_T9 ) ) % boost::lexical_cast<double>( zone.getProperty( nnt::s_RHO ) ); std::cout << fmt2.str() << std::endl; } //========================================================================== // Print flows. //========================================================================== double d_forward_in = 0.; double d_forward_out = 0.; double d_reverse_in = 0.; double d_reverse_out = 0.; std::vector< boost::tuple<std::string,double,double> > reactions; BOOST_FOREACH( nnt::Reaction reaction, reaction_list ) { int i_nuc = 0; nnt::reaction_element_list_t reactant_list = nnt::make_reaction_nuclide_reactant_list( reaction.getNucnetReaction() ); BOOST_FOREACH( nnt::ReactionElement reactant, reactant_list ) { if( Libnucnet__Nuc__getSpeciesByName( Libnucnet__Net__getNuc( Libnucnet__NetView__getNet( p_cluster_view ) ), Libnucnet__Reaction__Element__getName( reactant.getNucnetReactionElement() ) ) ) i_nuc--; } nnt::reaction_element_list_t product_list = nnt::make_reaction_nuclide_product_list( reaction.getNucnetReaction() ); BOOST_FOREACH( nnt::ReactionElement product, product_list ) { if( Libnucnet__Nuc__getSpeciesByName( Libnucnet__Net__getNuc( Libnucnet__NetView__getNet( p_cluster_view ) ), Libnucnet__Reaction__Element__getName( product.getNucnetReactionElement() ) ) ) i_nuc++; } if( i_nuc != 0 ) { flows = user::compute_flows_for_reaction( zone, reaction.getNucnetReaction() ); reactions.push_back( boost::make_tuple( Libnucnet__Reaction__getString( reaction.getNucnetReaction() ), flows.first, flows.second ) ); if( i_nuc > 0 ) { d_forward_in += flows.first; d_reverse_out += flows.second; } else { d_forward_out += flows.first; d_reverse_in += flows.second; } } }
/** * Test new closure API */ void TestChoiceFormat::TestClosures(void) { // Construct open, half-open, half-open (the other way), and closed // intervals. Do this both using arrays and using a pattern. // 'fmt1' is created using arrays UBool T = TRUE, F = FALSE; // 0: ,1) // 1: [1,2] // 2: (2,3] // 3: (3,4) // 4: [4,5) // 5: [5, double limits[] = { 0, 1, 2, 3, 4, 5 }; UBool closures[] = { F, F, T, T, F, F }; UnicodeString fmts[] = { ",1)", "[1,2]", "(2,3]", "(3,4)", "[4,5)", "[5," }; ChoiceFormat fmt1(limits, closures, fmts, 6); // 'fmt2' is created using a pattern; it should be equivalent UErrorCode status = U_ZERO_ERROR; const char* PAT = "0#,1)|1#[1,2]|2<(2,3]|3<(3,4)|4#[4,5)|5#[5,"; ChoiceFormat fmt2(PAT, status); if (U_FAILURE(status)) { errln("FAIL: ChoiceFormat constructor failed"); return; } // Check the patterns UnicodeString str; fmt1.toPattern(str); if (str == PAT) { logln("Ok: " + str); } else { errln("FAIL: " + str + ", expected " + PAT); } str.truncate(0); // Check equality if (fmt1 != fmt2) { errln("FAIL: fmt1 != fmt2"); } #if 0 // ICU 4.8 deprecates and disables the ChoiceFormat getters. int32_t i; int32_t count2 = 0; const double *limits2 = fmt2.getLimits(count2); const UBool *closures2 = fmt2.getClosures(count2); if((count2 != 6) || !limits2 || !closures2) { errln("FAIL: couldn't get limits or closures"); } else { for(i=0;i<count2;i++) { logln("#%d/%d: limit %g closed %s\n", i, count2, limits2[i], closures2[i] ?"T":"F"); if(limits2[i] != limits[i]) { errln("FAIL: limit #%d = %g, should be %g\n", i, limits2[i], limits[i]); } if((closures2[i]!=0) != (closures[i]!=0)) { errln("FAIL: closure #%d = %s, should be %s\n", i, closures2[i]?"T":"F", closures[i]?"T":"F"); } } } #endif // Now test both format objects UnicodeString exp[] = { /*-0.5 => */ ",1)", /* 0.0 => */ ",1)", /* 0.5 => */ ",1)", /* 1.0 => */ "[1,2]", /* 1.5 => */ "[1,2]", /* 2.0 => */ "[1,2]", /* 2.5 => */ "(2,3]", /* 3.0 => */ "(2,3]", /* 3.5 => */ "(3,4)", /* 4.0 => */ "[4,5)", /* 4.5 => */ "[4,5)", /* 5.0 => */ "[5,", /* 5.5 => */ "[5," }; // Each format object should behave exactly the same ChoiceFormat* FMT[] = { &fmt1, &fmt2 }; for (int32_t pass=0; pass<2; ++pass) { int32_t j=0; for (int32_t ix=-5; ix<=55; ix+=5) { double x = ix / 10.0; // -0.5 to 5.5 step +0.5 FMT[pass]->format(x, str); if (str == exp[j]) { logln((UnicodeString)"Ok: " + x + " => " + str); } else { errln((UnicodeString)"FAIL: " + x + " => " + str + ", expected " + exp[j]); } str.truncate(0); ++j; } } }
void summarizeLibraryTypeCounts(boost::filesystem::path& opath){ LibraryFormat fmt1(ReadType::SINGLE_END, ReadOrientation::NONE, ReadStrandedness::U); LibraryFormat fmt2(ReadType::SINGLE_END, ReadOrientation::NONE, ReadStrandedness::U); std::ofstream ofile(opath.string()); fmt::MemoryWriter errstr; auto log = spdlog::get("jointLog"); uint64_t numFmt1{0}; uint64_t numFmt2{0}; uint64_t numAgree{0}; uint64_t numDisagree{0}; for (auto& rl : readLibraries_) { auto fmt = rl.format(); auto& counts = rl.libTypeCounts(); // If the format is un-stranded, check that // we have a similar number of mappings in both // directions and then aggregate the forward and // reverse counts. if (fmt.strandedness == ReadStrandedness::U) { std::vector<ReadStrandedness> strands; switch (fmt.orientation) { case ReadOrientation::SAME: case ReadOrientation::NONE: strands.push_back(ReadStrandedness::S); strands.push_back(ReadStrandedness::A); break; case ReadOrientation::AWAY: case ReadOrientation::TOWARD: strands.push_back(ReadStrandedness::AS); strands.push_back(ReadStrandedness::SA); break; } fmt1.type = fmt.type; fmt1.orientation = fmt.orientation; fmt1.strandedness = strands[0]; fmt2.type = fmt.type; fmt2.orientation = fmt.orientation; fmt2.strandedness = strands[1]; numFmt1 = 0; numFmt2 = 0; numAgree = 0; numDisagree = 0; for (size_t i = 0; i < counts.size(); ++i) { if (i == fmt1.formatID()) { numFmt1 = counts[i]; } else if (i == fmt2.formatID()) { numFmt2 = counts[i]; } else { numDisagree += counts[i]; } } numAgree = numFmt1 + numFmt2; double ratio = static_cast<double>(numFmt1) / (numFmt1 + numFmt2); if ( std::abs(ratio - 0.5) > 0.01) { errstr << "NOTE: Read Lib [" << rl.readFilesAsString() << "] :\n"; errstr << "\nDetected a strand bias > 1\% in an unstranded protocol " << "check the file: " << opath.string() << " for details\n"; log->warn() << errstr.str(); errstr.clear(); } ofile << "========\n" << "Read library consisting of files: " << rl.readFilesAsString() << "\n\n" << "Expected format: " << rl.format() << "\n\n" << "# of consistent alignments: " << numAgree << "\n" << "# of inconsistent alignments: " << numDisagree << "\n" << "strand bias = " << ratio << " (0.5 is unbiased)\n" << "# alignments with format " << fmt1 << ": " << numFmt1 << "\n" << "# alignments with format " << fmt2 << ": " << numFmt2 << "\n" << "\n========\n"; } else { numAgree = 0; numDisagree = 0; for (size_t i = 0; i < counts.size(); ++i) { if (i == fmt.formatID()) { numAgree = counts[i]; } else { numDisagree += counts[i]; } } // end for ofile << "========\n" << "Read library consisting of files: " << rl.readFilesAsString() << "\n\n" << "Expected format: " << rl.format() << "\n\n" << "# of consistent alignments: " << numAgree << "\n" << "# of inconsistent alignments: " << numDisagree << "\n" << "\n========\n"; } //end else double disagreeRatio = static_cast<double>(numDisagree) / (numAgree + numDisagree); if (disagreeRatio > 0.05) { errstr << "NOTE: Read Lib [" << rl.readFilesAsString() << "] :\n"; errstr << "\nGreater than 5\% of the alignments (but not, necessarily reads) " << "disagreed with the provided library type; " << "check the file: " << opath.string() << " for details\n"; log->warn() << errstr.str(); errstr.clear(); } ofile << "---- counts for each format type ---\n"; for (size_t i = 0; i < counts.size(); ++i) { ofile << LibraryFormat::formatFromID(i) << " : " << counts[i] << "\n"; } ofile << "------------------------------------\n\n"; } ofile.close(); }
// ============================================================================ void DataOnDemandSvc::dump ( const MSG::Level level , const bool mode ) const { if ( m_algs.empty() && m_nodes.empty() ) { return ; } typedef std::pair<std::string,std::string> Pair ; typedef std::map<std::string,Pair> PMap ; PMap _m ; for ( AlgMap::const_iterator alg = m_algs.begin() ; m_algs.end() != alg ; ++alg ) { PMap::const_iterator check = _m.find(alg->first) ; if ( _m.end() != check ) { stream() << MSG::WARNING << " The data item is activated for '" << check->first << "' as '" << check->second.first << "'" << endmsg ; } const Leaf& l = alg->second ; std::string nam = ( l.name == l.type ? l.type : (l.type+"/"+l.name) ) ; // if ( !mode && 0 == l.num ) { continue ; } // std::string val ; if ( mode ) { val = ( 0 == l.algorithm ) ? "F" : "T" ; } else { val = boost::lexical_cast<std::string>( l.num ) ; } // _m[ no_prefix ( alg->first , m_prefix ) ] = std::make_pair ( nam , val ) ; } // nodes: for ( NodeMap::const_iterator node = m_nodes.begin() ; m_nodes.end() != node ; ++node ) { PMap::const_iterator check = _m.find(node->first) ; if ( _m.end() != check ) { stream() << MSG::WARNING << " The data item is already activated for '" << check->first << "' as '" << check->second.first << "'" << endmsg ; } const Node& n = node->second ; std::string nam = "'" + n.name + "'" ; // std::string val ; if ( !mode && 0 == n.num ) { continue ; } if ( mode ) { val = ( 0 == n.clazz ) ? "F" : "T" ; } else { val = boost::lexical_cast<std::string>( n.num ) ; } // _m[ no_prefix ( node->first , m_prefix ) ] = std::make_pair ( nam , val ) ; } // if ( _m.empty() ) { return ; } // find the correct formats size_t n1 = 0 ; size_t n2 = 0 ; size_t n3 = 0 ; for ( PMap::const_iterator it = _m.begin() ; _m.end() != it ; ++it ) { n1 = std::max ( n1 , it->first.size() ) ; n2 = std::max ( n2 , it->second.first.size() ) ; n3 = std::max ( n3 , it->second.second.size() ) ; } if ( 10 > n1 ) { n1 = 10 ; } if ( 10 > n2 ) { n2 = 10 ; } if ( 60 < n1 ) { n1 = 60 ; } if ( 60 < n2 ) { n2 = 60 ; } // const std::string _f = " | %%1$-%1%.%1%s | %%2$-%2%.%2%s | %%3$%3%.%3%s |" ; boost::format _ff ( _f ) ; _ff % n1 % n2 % n3 ; const std::string _format = _ff.str() ; MsgStream& msg = stream() << level ; if ( mode ) { msg << "Data-On-Demand Actions enabled for:" ; } else { msg << "Data-On-Demand Actions has been used for:" ; } boost::format fmt1( _format) ; fmt1 % "Address" % "Creator" % ( mode ? "S" : "#" ) ; // const std::string header = fmt1.str() ; std::string line = std::string( header.size() , '-' ) ; line[0] = ' ' ; msg << std::endl << line << std::endl << header << std::endl << line ; // make the actual printout: for ( PMap::const_iterator item = _m.begin() ; _m.end() != item ; ++item ) { boost::format fmt( _format) ; msg << std::endl << ( fmt % item->first % item->second.first % item->second.second ) ; } msg << std::endl << line << endmsg ; }