int main(int argc, const char *argv[]) { Date d1; Date d2("February", 14, 1952); d1.printDayYear(); printf("\n"); d1.printShort(); printf("\n"); d1.printLong(); printf("\n\n"); d2.printDayYear(); printf("\n"); d2.printShort(); printf("\n"); d2.printLong(); std::cout << std::endl; return 0; }
bool SegmentationChangeIndexAutoTest(int width, int height, const FuncCI & f1, const FuncCI & f2) { bool result = true; TEST_LOG_SS(Info, "Test " << f1.description << " & " << f2.description << " for size [" << width << "," << height << "]."); const uint8_t oldIndex = 3, newIndex = 2; View s(width, height, View::Gray8, NULL, TEST_ALIGN(width)); View d1(width, height, View::Gray8, NULL, TEST_ALIGN(width)); View d2(width, height, View::Gray8, NULL, TEST_ALIGN(width)); FillRandomMask(s, oldIndex); TEST_EXECUTE_AT_LEAST_MIN_TIME(f1.Call(s, oldIndex, newIndex, d1)); TEST_EXECUTE_AT_LEAST_MIN_TIME(f2.Call(s, oldIndex, newIndex, d2)); result = result && Compare(d1, d2, 0, true, 64); return result; }
void SetContainerClass::setFunc() { std::cout << "before:\n\tstd::string string1[n] = { c b c d e f };\n"; std::string string1[n] = {"c","b","c","d","e","f"}; /* for(int i = 0; i < 6; i++) { if(i == 0) { string1[i] = i + 98; continue; } string1[i] = i + 97; } */ std::set<std::string, std::less<std::string> > d1; // old implementing std::set<std::string> d2(string1, string1 + n); // new implementing std::ostream_iterator<std::string, char> out(std::cout, " "); std::cout << "after:\n\tstd::string string1[n] = { "; copy(d2.begin(), d2.end(), out); std::cout << "};\n"; }
void FLDiskCache::clear() { QDir d(AQ_DISKCACHE_DIRPATH); if (d.exists()) { QStringList lst = d.entryList("*; *.*"); for (QStringList::Iterator it = lst.begin(); it != lst.end(); ++it) d.remove(AQ_DISKCACHE_DIRPATH + '/' + (*it)); } #ifndef QSDEBUGGER QTextCodec *codec = QTextCodec::codecForLocale(); QString localEncode(codec ? codec->mimeName() : ""); QString path(AQ_USRHOME + "/.eneboocache/" + localEncode); QDir d2(path); if (d2.exists()) { QStringList lst = d2.entryList("sys*"); for (QStringList::Iterator it = lst.begin(); it != lst.end(); ++it) d2.remove(path + '/' + (*it)); } #endif }
static void tst0() { std::cout << "--------------------------------\n"; imdd_manager m; imdd_ref d1(m), d2(m), d3(m), d4(m); d1 = m.mk_empty(1); d2 = m.mk_empty(1); m.insert_dupdt(d1, 10, 20); m.insert_dupdt(d1, 31, 50); m.insert_dupdt(d2, 1, 5); m.insert_dupdt(d2, 11, 13); m.mk_product(d1, d2, d4); m.mk_product(d4, d2, d4); m.mk_product_dupdt(d1, d2); std::cout << "d1:\n" << mk_ll_pp(d1, m) << "\n-------\n"; m.mk_product_dupdt(d1, d2); std::cout << "d4:\n" << mk_ll_pp(d4, m) << "\nd1:\n" << mk_ll_pp(d1, m) << "\nd2:\n" << mk_ll_pp(d2, m) << "\n"; std::cout << d1 << "\n" << d2 << "\n"; m.mk_product_dupdt(d1, d1); std::cout << "d1 X d1:\n" << mk_ll_pp(d1, m) << "\n"; }
bool ColorFilterAutoTest(View::Format format, int width, int height, const FuncC & f1, const FuncC & f2) { bool result = true; TEST_LOG_SS(Info, "Test " << f1.description << " & " << f2.description << " [" << width << ", " << height << "]."); View s(width, height, format, NULL, TEST_ALIGN(width)); FillRandom(s); View d1(width, height, format, NULL, TEST_ALIGN(width)); View d2(width, height, format, NULL, TEST_ALIGN(width)); TEST_EXECUTE_AT_LEAST_MIN_TIME(f1.Call(s, d1)); TEST_EXECUTE_AT_LEAST_MIN_TIME(f2.Call(s, d2)); result = result && Compare(d1, d2, 0, true, 32); return result; }
string Parser::getStringBetweenMatched(char cd1, char cd2) { string token = ""; int open_delims = 0; string d1(1, cd1); string d2(1, cd2); nextTokenMustBe(d1); while (infile.peek() != cd2 || open_delims != 0) { if (infile.peek() == EOF) throw DanglingDelimiterException(filename, line_num, line_pos, d2); line_pos++; if (infile.peek() == '\n' || infile.peek() == '\f') { line_num++; line_pos = 1; } else if (infile.peek() == cd1) open_delims++; else if (infile.peek() == cd2) open_delims--; token += infile.get(); } nextTokenMustBe(d2); return token; }
bool StretchGrayDataTest(bool create, int width, int height, const Func & f, int stretch) { bool result = true; Data data(f.description); std::cout << (create ? "Create" : "Verify") << " test " << f.description << " [" << width << ", " << height << "]." << std::endl; const int stretchedWidth = width*stretch; const int stretchedHeight = height*stretch; View s(width, height, View::Gray8, NULL, TEST_ALIGN(width)); View d1(stretchedWidth, stretchedHeight, View::Gray8, NULL, TEST_ALIGN(stretchedWidth)); View d2(stretchedWidth, stretchedHeight, View::Gray8, NULL, TEST_ALIGN(stretchedWidth)); if(create) { FillRandom(s); TEST_SAVE(s); f.Call(s, d1); TEST_SAVE(d1); } else { TEST_LOAD(s); TEST_LOAD(d1); f.Call(s, d2); TEST_SAVE(d2); result = result && Compare(d1, d2, 0, true, 64); } return result; }
unsigned int CDateTime::weekOfYear(int year, unsigned int month, unsigned int day) { if (!isValid(year, month, day)) { return 0; } CDateTime d1(year, month, day); int a = dayOfWeek(year, month, day); d1.addDays(4 - a); // Jeudi de cette semaine int y1 = d1.getYear(); CDateTime d2(y1, 1, 4); int b = dayOfWeek(y1, 1, 4); d2.addDays(1 - b); // Lundi de cette semaine int y2 = d2.getYear(); if (y1 < y2) { unsigned int a1 = (isLeapYear(y1) ? 366 : 365) - dayOfYear(y1, d1.getMonth(), d1.getDay()); unsigned int a2 = dayOfYear(y2, d2.getMonth(), d2.getDay()); return (1 + (a1 + a2) / 7); } else if (y1 > y2) { unsigned int a1 = dayOfYear(y1, d1.getMonth(), d1.getDay()); unsigned int a2 = (isLeapYear(y2) ? 366 : 365) - dayOfYear(y2, d2.getMonth(), d2.getDay()); return (1 + (a1 + a2) / 7); } else { unsigned int a1 = dayOfYear(y1, d1.getMonth(), d1.getDay()); unsigned int a2 = dayOfYear(y2, d2.getMonth(), d2.getDay()); return (1 + (a2 > a1 ? a2 - a1 : a1 - a2) / 7); } }
int main() { { using T0 = hana::tuple<double>; using T1 = hana::tuple<int>; T0 t0(2.5); T1 t1; t1 = t0; BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t1) == 2); } { using T0 = hana::tuple<double, char>; using T1 = hana::tuple<int, int>; T0 t0(2.5, 'a'); T1 t1; t1 = t0; BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t1) == 2); BOOST_HANA_RUNTIME_CHECK(hana::at_c<1>(t1) == int('a')); } { using T0 = hana::tuple<double, char, D>; using T1 = hana::tuple<int, int, B>; T0 t0(2.5, 'a', D(3)); T1 t1; t1 = t0; BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t1) == 2); BOOST_HANA_RUNTIME_CHECK(hana::at_c<1>(t1) == int('a')); BOOST_HANA_RUNTIME_CHECK(hana::at_c<2>(t1).id_ == 3); } { D d(3); D d2(2); using T0 = hana::tuple<double, char, D&>; using T1 = hana::tuple<int, int, B&>; T0 t0(2.5, 'a', d2); T1 t1(1.5, 'b', d); t1 = t0; BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t1) == 2); BOOST_HANA_RUNTIME_CHECK(hana::at_c<1>(t1) == int('a')); BOOST_HANA_RUNTIME_CHECK(hana::at_c<2>(t1).id_ == 2); } }
TEST(DictionaryEquality, SimpleValues) { AmfDictionary d0(true), d1(true), d2(false); d0.insert(AmfInteger(0), AmfString("foo")); d1.insert(AmfInteger(0), AmfString("foo")); d2.insert(AmfInteger(0), AmfString("foo")); EXPECT_EQ(d0, d1); EXPECT_NE(d0, d2); d0.insert(AmfString("qux"), AmfByteArray(v8 { 0x00 })); EXPECT_NE(d0, d1); d1.insert(AmfString("qux"), AmfByteArray(v8 { 0x00 })); EXPECT_EQ(d0, d1); d0.insert(AmfNull(), AmfUndefined()); d1.insert(AmfUndefined(), AmfNull()); EXPECT_NE(d0, d1); d0.insert(AmfUndefined(), AmfNull()); d1.insert(AmfNull(), AmfUndefined()); EXPECT_EQ(d0, d1); }
double BlackScholesPrice(const double stockPrice, const double strikePrice, const double expiry, const double volatility, const double interestRate, const double costOfCarry, const OptionType optionType) { double normalVal1 = NORMALDISTRIBUTIONS::N(d1(stockPrice, strikePrice, expiry, volatility, costOfCarry)); double normalVal2 = NORMALDISTRIBUTIONS::N(d2(stockPrice, strikePrice, expiry, volatility, costOfCarry)); switch (optionType) { case EUROPEANCALL: return (stockPrice*normalVal1*exp((costOfCarry - interestRate)*expiry) - strikePrice*normalVal2*exp(-interestRate*expiry)); break; case EUROPEANPUT: // N(-d1) = 1 - N(d1) and N(-d2) = 1 - N(d2) return (strikePrice*(1 - normalVal2)*exp(-interestRate*expiry) - stockPrice*(1 - normalVal1)*exp((costOfCarry - interestRate)*expiry)); break; default: throw EXCEPTIONS::InvalidOptionException(-1); break; } }
void testDoubleDerived() { DoubleDerivedVTBL d; d.x = 1; d.y = 2; d.z = 3; clang_analyzer_eval(getX(d) == 1); // expected-warning{{TRUE}} clang_analyzer_eval(getY(d) == 2); // expected-warning{{TRUE}} clang_analyzer_eval(getZ(d) == 3); // expected-warning{{TRUE}} Base b(d); clang_analyzer_eval(getX(b) == 1); // expected-warning{{TRUE}} DerivedVTBL d2(d); clang_analyzer_eval(getX(d2) == 1); // expected-warning{{TRUE}} clang_analyzer_eval(getY(d2) == 2); // expected-warning{{TRUE}} DoubleDerivedVTBL d3(d); clang_analyzer_eval(getX(d3) == 1); // expected-warning{{TRUE}} clang_analyzer_eval(getY(d3) == 2); // expected-warning{{TRUE}} clang_analyzer_eval(getZ(d3) == 3); // expected-warning{{TRUE}} }
int main() { Complex d1(5, 10); Complex d2(7, 10); Complex d4; cout << "d1(5,10) "<<"d2(7,10) "<<"d4(0,0)"<<endl; cout << "d4 = d1" << endl; d4 = d1; d4.Display(); cout << "d2 - d1" << endl; d4 = d2 - d1; d4.Display(); cout << "d2 + d1" << endl; d4 = d2 + d1; d4.Display(); cout << "d4 += d1" << endl; d4 += d1; d4.Display(); cout << "d4 -= d1" << endl; d4 -= d1; d4.Display(); cout << "d4++" << endl; d4++; d4.Display(); cout << "++d4" << endl; ++d4; d4.Display(); cout << "d4++" << endl; d4--; d4.Display(); cout << "--d4" << endl; --d4; cout << "d4 == d1" << endl; cout << (d4 == d1) << endl; system("pause"); return 0; }
main() { Punct x1(10, 10), x2(100, 200); Dreptunghi d1(x1, x2), d2(10, 20, 14, 50); clrscr(); d1.List(); getch(); cout<<'\n'; d2.List(); getch(); cout<<'\n'; if (d1 == d2) cout<<"d1 = d2"; else cout<<"d1 != d2"; getch(); cout<<'\n'; cout<<d1.Lung_lat1()<<' '<<d1.Lung_lat2(); getch(); cout<<'\n'; cout<<d2.Lung_lat1()<<' '<<d2.Lung_lat2(); getch(); cout<<'\n'; cout<<"Perimetrul d1: "<<d1.Perimetru(); getch(); cout<<'\n'; cout<<"Perimetrul d2: "<<d2.Perimetru(); getch(); cout<<'\n'; cout<<"d1, colt stanga sus : "<<d1.Colt_st_sus(); getch(); cout<<'\n'; cout<<"d1, colt dreapta jos : "<<d1.Colt_dr_jos(); getch(); cout<<'\n'; return 0; }
//------------------------------------------------------------------- // needs simplifyDP which is above static vector <ofPoint> ofSimplifyContour(vector <ofPoint> &V, float tol){ int n = V.size(); vector <ofPoint> sV; sV.assign(n, ofPoint()); int i, k, m, pv; // misc counters float tol2 = tol * tol; // tolerance squared ofPoint * vt = new ofPoint[n]; int * mk = new int[n]; memset(mk, 0, sizeof(int) * n ); // STAGE 1. Vertex Reduction within tolerance of prior vertex cluster vt[0] = V[0]; // start at the beginning for (i=k=1, pv=0; i<n; i++) { if (d2(V[i], V[pv]) < tol2) continue; vt[k++] = V[i]; pv = i; } if (pv < n-1) vt[k++] = V[n-1]; // finish at the end // STAGE 2. Douglas-Peucker polyline simplification mk[0] = mk[k-1] = 1; // mark the first and last vertices simplifyDP( tol, vt, 0, k-1, mk ); // copy marked vertices to the output simplified polyline for (i=m=0; i<k; i++) { if (mk[i]) sV[m++] = vt[i]; } //get rid of the unused points if( m < (int)sV.size() ) sV.erase( sV.begin()+m, sV.end() ); delete [] vt; delete [] mk; return sV; }
bool SegmentationChangeIndexDataTest(bool create, int width, int height, const FuncCI & f) { bool result = true; Data data(f.description); TEST_LOG_SS(Info, (create ? "Create" : "Verify") << " test " << f.description << " [" << width << ", " << height << "]."); View s(width, height, View::Gray8, NULL, TEST_ALIGN(width)); View d1(width, height, View::Gray8, NULL, TEST_ALIGN(width)); View d2(width, height, View::Gray8, NULL, TEST_ALIGN(width)); const uint8_t oldIndex = 3, newIndex = 2; if(create) { FillRandomMask(s, oldIndex); TEST_SAVE(s); f.Call(s, oldIndex, newIndex, d1); TEST_SAVE(d1); } else { TEST_LOAD(s); TEST_LOAD(d1); f.Call(s, oldIndex, newIndex, d2); TEST_SAVE(d2); result = result && Compare(d1, d2, 0, true, 64); } return result; }
void TestQueue( const Allocator& a ) { // A queue can be made out of deque or list typedef std::deque< typename Allocator::value_type, Allocator > Deque; typedef std::list< typename Allocator::value_type, Allocator > List; typedef std::queue< typename Allocator::value_type, Deque > DQueue; typedef std::queue< typename Allocator::value_type, List > LQueue; DQueue d1( Policy< Allocator >::template GetDefaultAdapter< DQueue, Deque >( a ) ); DQueue d2( Policy< Allocator >::template GetCopiedAdapter< DQueue, Deque >( a ) ); LQueue l1( Policy< Allocator >::template GetDefaultAdapter< LQueue, List >( a ) ); LQueue l2( Policy< Allocator >::template GetCopiedAdapter< LQueue, List >( a ) ); // Test deque queues TestQueue( a, d1 ); TestQueue( a, d2 ); // Test list queues TestQueue( a, l1 ); TestQueue( a, l2 ); }
result_type operator()(first_argument_type row, second_argument_type r) const { draw_north_wall d1; pair_int p1(0,*r); for (maze_row::walls::const_iterator cit = row->north_walls.begin(); cit != row->north_walls.end(); ++cit) { d1(*cit, &p1); } draw_east_wall d2; pair_int p2(0,*r); for (maze_row::walls::const_iterator cit = row->east_walls.begin(); cit != row->east_walls.end(); ++cit) { d2(*cit, &p2); } (*r)++; return (0); }
void TestPriorityQueue( const Allocator& a ) { // A priority queue can be made out of vector or deque typedef std::vector< typename Allocator::value_type, Allocator > Vector; typedef std::deque< typename Allocator::value_type, Allocator > Deque; typedef std::priority_queue< typename Allocator::value_type, Vector > VQueue; typedef std::priority_queue< typename Allocator::value_type, Deque > DQueue; VQueue v1( Policy< Allocator >::template GetDefaultPriorityQueue< VQueue, Vector >( a ) ); VQueue v2( Policy< Allocator >::template GetCopiedPriorityQueue< VQueue, Vector >( a ) ); DQueue d1( Policy< Allocator >::template GetDefaultPriorityQueue< DQueue, Deque >( a ) ); DQueue d2( Policy< Allocator >::template GetCopiedPriorityQueue< DQueue, Deque >( a ) ); // Test vector queues TestPriorityQueue( a, v1 ); TestPriorityQueue( a, v2 ); // Test deque queues TestPriorityQueue( a, d1 ); TestPriorityQueue( a, d2 ); }
void main() { RMB d1(1,60); RMB d2(2,50); RMB d3(0,0); /*RMB d4(20.16); d3=d2+d1; d3.display(); ++(++d3); d3.display(); d4.display(); d4=2.7+d3; d4.display();*/ //d1+=d2; //d1.display(); //d2+=3.8; d3=++d2; d2.display(); d3.display(); (d3=d1)++; d3.display(); }
bool ContourAnchorsAutoTest(int width, int height, const FuncA & f1, const FuncA & f2) { bool result = true; TEST_LOG_SS(Info, "Test " << f1.description << " & " << f2.description << " [" << width << ", " << height << "]."); View s(width, height, View::Int16, NULL, TEST_ALIGN(width)); FillRandom(s); View d1(width, height, View::Gray8, NULL, TEST_ALIGN(width)); View d2(width, height, View::Gray8, NULL, TEST_ALIGN(width)); Simd::Fill(d1, 0); Simd::Fill(d2, 0); TEST_EXECUTE_AT_LEAST_MIN_TIME(f1.Call(s, 3, 0, d1)); TEST_EXECUTE_AT_LEAST_MIN_TIME(f2.Call(s, 3, 0, d2)); result = result && Compare(d1, d2, 0, true, 64); return result; }
bool FindClosestPoint(const Vector3f & p1, const Vector3f & q1, const Vector3f & p2, const Vector3f & q2, Vector3f & point) { float s,t; const float epsUpper = 1+1e-2; const float epsLower = -1e-2; Vector3f d1(q1-p1); Vector3f d2(q2-p2); Vector3f r(p1-p2); float a = d1.dot(d1); float e = d2.dot(d2); float f = d2.dot(r); float c = d1.dot(r); float b = d1.dot(d2); float denom = a*e-b*b; if (denom != 0) s = (b*f - c*e)/denom; else s = 0; if (s < epsLower || s > epsUpper) return 0; t = (b*s + f)/e; if (t < epsLower) { return 0; //t = 0; //s = Clamp(-c/a, 0, 1.f); } else if (t > epsUpper) { return 0; //t = 1.f; //s = Clamp((b-c)/a, 0.f, 1.f); } point = p2 + d2*t; return 1; }
int main(void) { date d(2015, 6, 12); d.print(); date d1(2015, 8, 31); std::cout<<"before set!"<<std::endl; d1.print(); d1.add_date(1); std::cout<<"after set!"<<std::endl; d1.print(); date d2(2015, 1, 1); std::cout<<"before set!"<<std::endl; d2.print(); std::cout<<std::endl; std::cout<<"after set!"<<std::endl; d2.set_date(3000, 10, 10); d2.print(); return 0; }
bool Knowledge::CanKick(Position robotPos, Vector2D ballPos) { double distThreshold = _wm->var[0], degThreshold = _wm->var[1] / 10; AngleDeg d1((ballPos - robotPos.loc).dir()); AngleDeg d2(robotPos.dir * AngleDeg::RAD2DEG); if(fabs((d1 - d2).degree()) < degThreshold || (360.0 - fabs((d1 - d2).degree())) < degThreshold) { if(robotPos.loc.dist(ballPos) < distThreshold) { return true; } else { return false; } } else { return false; } }
/** \param[in] accum If not nullptr, use this object to accumulate partial first derivatives. \return Current score. */ double TALOSRestraint::unprotected_evaluate(DerivativeAccumulator *accum) const { core::XYZ d0(p_[0]); core::XYZ d1(p_[1]); core::XYZ d2(p_[2]); core::XYZ d3(p_[3]); Scale kappascale(kappa_); double kappaval = kappascale.get_scale(); // get angle algebra::VectorD<3> derv0, derv1, derv2, derv3; double angle; if (accum) { angle = core::internal::dihedral(d0, d1, d2, d3, &derv0, &derv1, &derv2, &derv3); } else { angle = core::internal::dihedral(d0, d1, d2, d3, nullptr, nullptr, nullptr, nullptr); } // score current angle mises_->set_x(angle); mises_->set_kappa(kappaval); double score = mises_->evaluate(); // store derivatives if necessary if (accum) { double deriv = mises_->evaluate_derivative_x(); d0.add_to_derivatives(derv0 * deriv, *accum); d1.add_to_derivatives(derv1 * deriv, *accum); d2.add_to_derivatives(derv2 * deriv, *accum); d3.add_to_derivatives(derv3 * deriv, *accum); kappascale.add_to_scale_derivative(mises_->evaluate_derivative_kappa(), *accum); } return score; }
bool HistoryPlugin::detectOldHistory() { KGlobal::config()->setGroup("History Plugin"); QString version=KGlobal::config()->readEntry( "Version" ,"0.6" ); if(version != "0.6") return false; QDir d( locateLocal( "data", QString::fromLatin1( "kopete/logs")) ); d.setFilter( QDir::Dirs ); if(d.count() >= 3) // '.' and '..' are included return false; //the new history already exists QDir d2( locateLocal( "data", QString::fromLatin1( "kopete")) ); d2.setFilter( QDir::Dirs ); const QFileInfoList_qt3 *list = d2.entryInfoList_qt3(); QFileInfoListIterator it( *list ); QFileInfo *fi; while ( (fi = it.current()) != 0 ) { if( dynamic_cast<Kopete::Protocol *>( Kopete::PluginManager::self()->plugin( fi->fileName() ) ) ) return true; if(fi->fileName() == "MSNProtocol" || fi->fileName() == "msn_logs" ) return true; else if(fi->fileName() == "ICQProtocol" || fi->fileName() == "icq_logs" ) return true; else if(fi->fileName() == "AIMProtocol" || fi->fileName() == "aim_logs" ) return true; else if(fi->fileName() == "OscarProtocol" ) return true; else if(fi->fileName() == "JabberProtocol" || fi->fileName() == "jabber_logs") return true; ++it; } return false; }
void test_transform_binary2(ExPolicy policy, IteratorTag) { static_assert( hpx::parallel::is_execution_policy<ExPolicy>::value, "hpx::parallel::is_execution_policy<ExPolicy>::value"); typedef std::vector<int>::iterator base_iterator; typedef test::test_iterator<base_iterator, IteratorTag> iterator; std::vector<int> c1(10007); std::vector<int> c2(c1.size()); std::vector<int> d1(c1.size()); //-V656 std::iota(boost::begin(c1), boost::end(c1), std::rand()); std::iota(boost::begin(c2), boost::end(c2), std::rand()); auto result = hpx::parallel::transform(policy, iterator(boost::begin(c1)), iterator(boost::end(c1)), boost::begin(c2), boost::end(c2), boost::begin(d1), add()); HPX_TEST(hpx::util::get<0>(result) == iterator(boost::end(c1))); HPX_TEST(hpx::util::get<1>(result) == boost::end(c2)); HPX_TEST(hpx::util::get<2>(result) == boost::end(d1)); // verify values std::vector<int> d2(c1.size()); std::transform(boost::begin(c1), boost::end(c1), boost::begin(c2), boost::begin(d2), add()); std::size_t count = 0; HPX_TEST(std::equal(boost::begin(d1), boost::end(d1), boost::begin(d2), [&count](int v1, int v2) -> bool { HPX_TEST_EQ(v1, v2); ++count; return v1 == v2; })); HPX_TEST_EQ(count, d2.size()); }
int main() { { typedef std::tuple<> T; T t0; T t = std::move(t0); ((void)t); // Prevent unused warning } { typedef std::tuple<MoveOnly> T; T t0(MoveOnly(0)); T t = std::move(t0); assert(std::get<0>(t) == 0); } { typedef std::tuple<MoveOnly, MoveOnly> T; T t0(MoveOnly(0), MoveOnly(1)); T t = std::move(t0); assert(std::get<0>(t) == 0); assert(std::get<1>(t) == 1); } { typedef std::tuple<MoveOnly, MoveOnly, MoveOnly> T; T t0(MoveOnly(0), MoveOnly(1), MoveOnly(2)); T t = std::move(t0); assert(std::get<0>(t) == 0); assert(std::get<1>(t) == 1); assert(std::get<2>(t) == 2); } // A bug in tuple caused __tuple_leaf to use its explicit converting constructor // as its move constructor. This tests that ConstructsWithTupleLeaf is not called // (w/ __tuple_leaf) { typedef std::tuple<ConstructsWithTupleLeaf> d_t; d_t d((ConstructsWithTupleLeaf())); d_t d2(static_cast<d_t &&>(d)); } }
void main() { printf("请输入a,b,c的值:\n"); scanf_s("%f%f%f", &a, &b, &c); printf("方程为:%.2fx^2+%.2fx+%.2f\n"); d = b*b - 4 * a*c; if (d > 0){ d1(a,b); printf("x1=%,x2=%f\n", x, y); } else{ if (d = 0) { d2(a,b); printf("x=%f\n"); } else { d3(a,b); printf("x1=%f+%fi,x2=%f-%fi\n", x, y); } } }