void function(void) { key_diy(); switch(key_status) { case 1: function1(); break; case 2: function2(); break; case 3: function3(); break; case 4: function4(); break; case 5: function5(); break; case 6: function6(); break; case 7: function7(); break; default: function0(); break; } }
double call_function(int function,double arg){ if(function==1){return function1(arg);} if(function==2){return function2(arg);} if(function==3){return function3(arg,0.5);}//using 0.5 for the elliptic modulous //should never get here printf("Unsupported function number: %d\n",function); exit(2); }
int main(int argc, char *argv[]) { // Call the functions function1(); printf("Function 2: %d\n", function2()); printf("Function 3: %d\n", function3(2, 3)); return 0; }
MyuFunctions make_myu_functions(const Concrete::CData&cdata,const ivector&numbers,const MinMax&minmax) { const int x_length=minmax.max_x.size(); Function*y_function=function3(coord(minmax.min_y,0), coord((minmax.max_y+minmax.min_y)/2.0,1.0), coord(minmax.max_y,0)); MyuFunctions result={fvector(0),y_function}; for(int i=0;i<numbers.size();++i){ for(int j=0;j<x_length;++j){ Function*max_f=function3(coord(minmax.min_x[i],0),coord(cdata[numbers[i]]->at(j),1.0), coord(minmax.max_x[i],0)); result.x_funcs.push_back(max_f); } } return result; }
int main() { int a; float b; function1('c', 1); a=function2(1, 1); b=function3('c', 'c'); return 0; }
int main(){ int num[10]={0}; int next_number[10] = {0}; int temp; int user_num, range; int i,remainder; int number; printf("Hi,Enter any number you want : "); scanf("%d",&user_num); //whole number is separated temp = user_num; i = 9; while(temp != 0){ remainder = temp % 10; temp = temp/10; num[i] = remainder; i--; } /* range = i; //printf("%d",range); for(i = 0; i < range ; i++) { next_number[i] = num[(range-1)-i]; } */ //printing in words for(i = 0 ; i < 10; i++) { if(i == 0 || i == 2 || i == 3 || i == 5) { printf("%s ",function1(i)); } else if(i == 1){ printf("%s",function3(i)); } else if(i== 2|| i == 4 || i == 6) { printf("%s",function2(i)); } } return 0; }
static void function4 (struct _file_ * port, char const * units, unsigned wait) { signed value; for (value = 0; value < 128; value++) { function2 (port, units, wait, (value << 8) | (value << 1) | 1); function3 (port, units, wait); SLEEP (wait); } return; }
int main(){ #pragma omp sections { #pragma omp section function1(); #pragma omp section function2(); #pragma omp section function3(); } return 0; }
int main(void){ rod sample; //Sample to type rod float diameter = 2; // diameter as float intialized to value =2 for function 1 float P; // Load "P" as float for function 1 float Force; // Force as float to catch return value of function 2 float Pressure; // Pressure as float to catch return value of function 3 float depth = 30; // depth as float for function 3 int distance; // distance for function 2 while(diameter <=10) //Loop till diameter is smaller than or equals to 10 & starts from diameter = 2 { for(P = 50000; P <= 200000 ; P = P+25000) //Loop till Load "p" <=200000 with increment of 25000 and starts from P = 50000 { sample = function1(diameter,P); // function1 called and returned value catched in sample printf(" %f,%f\t",sample.stress,sample.strain); // STRESS and STRAIN printed } printf("\n"); diameter = diameter + 0.5; //diameter incremeted by 0.5 } for(distance = 10; distance <= 100 ; distance = distance+10) // Loop from distance =10 till distance smaller than or equals to 100 with increment of 10 { Force = function2(distance); // function2 called and return value stored in Force printf("\n\t %f",Force); // Force printed } printf("\n\n"); do{ // Loop from depth =30 til depth smaller than or equals to 150 Pressure = function3(depth); //function3 called and returned value stored in Pressure printf("%f\n", Pressure); depth = depth + 10; // loop incremented by 10 }while(depth <= 150); return 0; }
int main() { int sel = -1; char buffer[INPUT_LENGTH]; int isInputValid = INPUT_INVALID; Num Num1; Num Num2; Num NumResult[5]; for(;;) { display_menu(); fflush(stdin); while(1) { isInputValid = getTwoInput(&Num1, &Num2); if(isInputValid == INPUT_INVALID) { printf("Please input again...\n"); } else { break; } } function1(&Num1, &Num2, &(NumResult[0])); function2(&Num1, &Num2, &(NumResult[1])); function3(&Num1, &Num2, &(NumResult[2])); function4(&Num1, &Num2, &(NumResult[3])); function5(&Num1, &Num2, &(NumResult[4])); printResult(&Num1, &Num2, NumResult); } printf("종료합니다.\n"); getchar(); return 0; }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::thread_pool pool; std::experimental::dispatch(std::experimental::wrap(pool, function1), handler1); std::experimental::dispatch(std::experimental::wrap(pool, function1), &handler1); std::experimental::dispatch(std::experimental::wrap(pool, function1), handler2()); std::experimental::dispatch(std::experimental::wrap(pool, function1), h2); std::experimental::dispatch(std::experimental::wrap(pool, function1), ch2); std::experimental::dispatch(std::experimental::wrap(pool, function1), handler3()); std::experimental::dispatch(std::experimental::wrap(pool, function1), std::move(h3)); std::future<void> fut1 = std::experimental::dispatch(std::experimental::wrap(pool, function1), std::experimental::use_future); fut1.get(); std::experimental::dispatch(std::experimental::wrap(pool, &function1), handler1); std::experimental::dispatch(std::experimental::wrap(pool, &function1), &handler1); std::experimental::dispatch(std::experimental::wrap(pool, &function1), handler2()); std::experimental::dispatch(std::experimental::wrap(pool, &function1), h2); std::experimental::dispatch(std::experimental::wrap(pool, &function1), ch2); std::experimental::dispatch(std::experimental::wrap(pool, &function1), handler3()); std::experimental::dispatch(std::experimental::wrap(pool, &function1), std::move(h3)); std::future<void> fut2 = std::experimental::dispatch(std::experimental::wrap(pool, &function1), std::experimental::use_future); fut2.get(); std::experimental::dispatch(std::experimental::wrap(pool, function2()), handler1); std::experimental::dispatch(std::experimental::wrap(pool, function2()), &handler1); std::experimental::dispatch(std::experimental::wrap(pool, function2()), handler2()); std::experimental::dispatch(std::experimental::wrap(pool, function2()), h2); std::experimental::dispatch(std::experimental::wrap(pool, function2()), ch2); std::experimental::dispatch(std::experimental::wrap(pool, function2()), handler3()); std::experimental::dispatch(std::experimental::wrap(pool, function2()), std::move(h3)); std::future<void> fut3 = std::experimental::dispatch(std::experimental::wrap(pool, function2()), std::experimental::use_future); fut3.get(); std::experimental::dispatch(std::experimental::wrap(pool, f2), handler1); std::experimental::dispatch(std::experimental::wrap(pool, f2), &handler1); std::experimental::dispatch(std::experimental::wrap(pool, f2), handler2()); std::experimental::dispatch(std::experimental::wrap(pool, f2), h2); std::experimental::dispatch(std::experimental::wrap(pool, f2), ch2); std::experimental::dispatch(std::experimental::wrap(pool, f2), handler3()); std::experimental::dispatch(std::experimental::wrap(pool, f2), std::move(h3)); std::future<void> fut4 = std::experimental::dispatch(std::experimental::wrap(pool, f2), std::experimental::use_future); fut4.get(); std::experimental::dispatch(std::experimental::wrap(pool, cf2), handler1); std::experimental::dispatch(std::experimental::wrap(pool, cf2), &handler1); std::experimental::dispatch(std::experimental::wrap(pool, cf2), handler2()); std::experimental::dispatch(std::experimental::wrap(pool, cf2), h2); std::experimental::dispatch(std::experimental::wrap(pool, cf2), ch2); std::experimental::dispatch(std::experimental::wrap(pool, cf2), handler3()); std::experimental::dispatch(std::experimental::wrap(pool, cf2), std::move(h3)); std::future<void> fut5 = std::experimental::dispatch(std::experimental::wrap(pool, cf2), std::experimental::use_future); fut5.get(); std::experimental::dispatch(std::experimental::wrap(pool, function3()), handler1); std::experimental::dispatch(std::experimental::wrap(pool, function3()), &handler1); std::experimental::dispatch(std::experimental::wrap(pool, function3()), handler2()); std::experimental::dispatch(std::experimental::wrap(pool, function3()), h2); std::experimental::dispatch(std::experimental::wrap(pool, function3()), ch2); std::experimental::dispatch(std::experimental::wrap(pool, function3()), handler3()); std::experimental::dispatch(std::experimental::wrap(pool, function3()), std::move(h3)); std::future<void> fut6 = std::experimental::dispatch(std::experimental::wrap(pool, function3()), std::experimental::use_future); fut6.get(); std::experimental::dispatch(std::experimental::wrap(pool, std::move(f3)), handler1); std::experimental::dispatch(std::experimental::wrap(pool, std::move(f3)), &handler1); std::experimental::dispatch(std::experimental::wrap(pool, std::move(f3)), handler2()); std::experimental::dispatch(std::experimental::wrap(pool, std::move(f3)), h2); std::experimental::dispatch(std::experimental::wrap(pool, std::move(f3)), ch2); std::experimental::dispatch(std::experimental::wrap(pool, std::move(f3)), handler3()); std::experimental::dispatch(std::experimental::wrap(pool, std::move(f3)), std::move(h3)); std::future<void> fut7 = std::experimental::dispatch(std::experimental::wrap(pool, std::move(f3)), std::experimental::use_future); fut7.get(); pool.join(); assert(function_count == 56); assert(handler_count == 49); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::system_executor ex; std::experimental::dispatch(ex.wrap(function1), handler1); std::experimental::dispatch(ex.wrap(function1), &handler1); std::experimental::dispatch(ex.wrap(function1), handler2()); std::experimental::dispatch(ex.wrap(function1), h2); std::experimental::dispatch(ex.wrap(function1), ch2); std::experimental::dispatch(ex.wrap(function1), handler3()); std::experimental::dispatch(ex.wrap(function1), std::move(h3)); std::future<void> fut1 = std::experimental::dispatch(ex.wrap(function1), std::experimental::use_future); fut1.get(); std::experimental::dispatch(ex.wrap(&function1), handler1); std::experimental::dispatch(ex.wrap(&function1), &handler1); std::experimental::dispatch(ex.wrap(&function1), handler2()); std::experimental::dispatch(ex.wrap(&function1), h2); std::experimental::dispatch(ex.wrap(&function1), ch2); std::experimental::dispatch(ex.wrap(&function1), handler3()); std::experimental::dispatch(ex.wrap(&function1), std::move(h3)); std::future<void> fut2 = std::experimental::dispatch(ex.wrap(&function1), std::experimental::use_future); fut2.get(); std::experimental::dispatch(ex.wrap(function2()), handler1); std::experimental::dispatch(ex.wrap(function2()), &handler1); std::experimental::dispatch(ex.wrap(function2()), handler2()); std::experimental::dispatch(ex.wrap(function2()), h2); std::experimental::dispatch(ex.wrap(function2()), ch2); std::experimental::dispatch(ex.wrap(function2()), handler3()); std::experimental::dispatch(ex.wrap(function2()), std::move(h3)); std::future<void> fut3 = std::experimental::dispatch(ex.wrap(function2()), std::experimental::use_future); fut3.get(); std::experimental::dispatch(ex.wrap(f2), handler1); std::experimental::dispatch(ex.wrap(f2), &handler1); std::experimental::dispatch(ex.wrap(f2), handler2()); std::experimental::dispatch(ex.wrap(f2), h2); std::experimental::dispatch(ex.wrap(f2), ch2); std::experimental::dispatch(ex.wrap(f2), handler3()); std::experimental::dispatch(ex.wrap(f2), std::move(h3)); std::future<void> fut4 = std::experimental::dispatch(ex.wrap(f2), std::experimental::use_future); fut4.get(); std::experimental::dispatch(ex.wrap(cf2), handler1); std::experimental::dispatch(ex.wrap(cf2), &handler1); std::experimental::dispatch(ex.wrap(cf2), handler2()); std::experimental::dispatch(ex.wrap(cf2), h2); std::experimental::dispatch(ex.wrap(cf2), ch2); std::experimental::dispatch(ex.wrap(cf2), handler3()); std::experimental::dispatch(ex.wrap(cf2), std::move(h3)); std::future<void> fut5 = std::experimental::dispatch(ex.wrap(cf2), std::experimental::use_future); fut5.get(); std::experimental::dispatch(ex.wrap(function3()), handler1); std::experimental::dispatch(ex.wrap(function3()), &handler1); std::experimental::dispatch(ex.wrap(function3()), handler2()); std::experimental::dispatch(ex.wrap(function3()), h2); std::experimental::dispatch(ex.wrap(function3()), ch2); std::experimental::dispatch(ex.wrap(function3()), handler3()); std::experimental::dispatch(ex.wrap(function3()), std::move(h3)); std::future<void> fut6 = std::experimental::dispatch(ex.wrap(function3()), std::experimental::use_future); fut6.get(); std::experimental::dispatch(ex.wrap(std::move(f3)), handler1); std::experimental::dispatch(ex.wrap(std::move(f3)), &handler1); std::experimental::dispatch(ex.wrap(std::move(f3)), handler2()); std::experimental::dispatch(ex.wrap(std::move(f3)), h2); std::experimental::dispatch(ex.wrap(std::move(f3)), ch2); std::experimental::dispatch(ex.wrap(std::move(f3)), handler3()); std::experimental::dispatch(ex.wrap(std::move(f3)), std::move(h3)); std::future<void> fut7 = std::experimental::dispatch(ex.wrap(std::move(f3)), std::experimental::use_future); fut7.get(); assert(function_count == 56); assert(handler_count == 49); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; invoke(std::experimental::chain(function1)); invoke(std::experimental::chain(function1, handler1)); invoke(std::experimental::chain(function1, &handler1)); invoke(std::experimental::chain(function1, handler2())); invoke(std::experimental::chain(function1, h2)); invoke(std::experimental::chain(function1, ch2)); invoke(std::experimental::chain(function1, handler3())); invoke(std::experimental::chain(function1, std::move(h3))); invoke(std::experimental::chain(&function1)); invoke(std::experimental::chain(&function1, handler1)); invoke(std::experimental::chain(&function1, &handler1)); invoke(std::experimental::chain(&function1, handler2())); invoke(std::experimental::chain(&function1, h2)); invoke(std::experimental::chain(&function1, ch2)); invoke(std::experimental::chain(&function1, handler3())); invoke(std::experimental::chain(&function1, std::move(h3))); invoke(std::experimental::chain(function2())); invoke(std::experimental::chain(function2(), handler1)); invoke(std::experimental::chain(function2(), &handler1)); invoke(std::experimental::chain(function2(), handler2())); invoke(std::experimental::chain(function2(), h2)); invoke(std::experimental::chain(function2(), ch2)); invoke(std::experimental::chain(function2(), handler3())); invoke(std::experimental::chain(function2(), std::move(h3))); invoke(std::experimental::chain(f2)); invoke(std::experimental::chain(f2, handler1)); invoke(std::experimental::chain(f2, &handler1)); invoke(std::experimental::chain(f2, handler2())); invoke(std::experimental::chain(f2, h2)); invoke(std::experimental::chain(f2, ch2)); invoke(std::experimental::chain(f2, handler3())); invoke(std::experimental::chain(f2, std::move(h3))); invoke(std::experimental::chain(cf2)); invoke(std::experimental::chain(cf2, handler1)); invoke(std::experimental::chain(cf2, &handler1)); invoke(std::experimental::chain(cf2, handler2())); invoke(std::experimental::chain(cf2, h2)); invoke(std::experimental::chain(cf2, ch2)); invoke(std::experimental::chain(cf2, handler3())); invoke(std::experimental::chain(cf2, std::move(h3))); invoke(std::experimental::chain(function3())); invoke(std::experimental::chain(function3(), handler1)); invoke(std::experimental::chain(function3(), &handler1)); invoke(std::experimental::chain(function3(), handler2())); invoke(std::experimental::chain(function3(), h2)); invoke(std::experimental::chain(function3(), ch2)); invoke(std::experimental::chain(function3(), handler3())); invoke(std::experimental::chain(function3(), std::move(h3))); invoke(std::experimental::chain(std::move(f3))); invoke(std::experimental::chain(std::move(f3), handler1)); invoke(std::experimental::chain(std::move(f3), &handler1)); invoke(std::experimental::chain(std::move(f3), handler2())); invoke(std::experimental::chain(std::move(f3), h2)); invoke(std::experimental::chain(std::move(f3), ch2)); invoke(std::experimental::chain(std::move(f3), handler3())); invoke(std::experimental::chain(std::move(f3), std::move(h3))); assert(function_count == 56); assert(handler_count == 49); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::loop_scheduler scheduler; auto ex = scheduler.get_executor(); std::experimental::executor_work<decltype(ex)> w(ex); std::thread t([&](){ scheduler.run(); }); std::experimental::dispatch(ex.wrap(function1), handler1); std::experimental::dispatch(ex.wrap(function1), &handler1); std::experimental::dispatch(ex.wrap(function1), handler2()); std::experimental::dispatch(ex.wrap(function1), h2); std::experimental::dispatch(ex.wrap(function1), ch2); std::experimental::dispatch(ex.wrap(function1), handler3()); std::experimental::dispatch(ex.wrap(function1), std::move(h3)); std::future<void> fut1 = std::experimental::dispatch(ex.wrap(function1), std::experimental::use_future); fut1.get(); std::experimental::dispatch(ex.wrap(&function1), handler1); std::experimental::dispatch(ex.wrap(&function1), &handler1); std::experimental::dispatch(ex.wrap(&function1), handler2()); std::experimental::dispatch(ex.wrap(&function1), h2); std::experimental::dispatch(ex.wrap(&function1), ch2); std::experimental::dispatch(ex.wrap(&function1), handler3()); std::experimental::dispatch(ex.wrap(&function1), std::move(h3)); std::future<void> fut2 = std::experimental::dispatch(ex.wrap(&function1), std::experimental::use_future); fut2.get(); std::experimental::dispatch(ex.wrap(function2()), handler1); std::experimental::dispatch(ex.wrap(function2()), &handler1); std::experimental::dispatch(ex.wrap(function2()), handler2()); std::experimental::dispatch(ex.wrap(function2()), h2); std::experimental::dispatch(ex.wrap(function2()), ch2); std::experimental::dispatch(ex.wrap(function2()), handler3()); std::experimental::dispatch(ex.wrap(function2()), std::move(h3)); std::future<void> fut3 = std::experimental::dispatch(ex.wrap(function2()), std::experimental::use_future); fut3.get(); std::experimental::dispatch(ex.wrap(f2), handler1); std::experimental::dispatch(ex.wrap(f2), &handler1); std::experimental::dispatch(ex.wrap(f2), handler2()); std::experimental::dispatch(ex.wrap(f2), h2); std::experimental::dispatch(ex.wrap(f2), ch2); std::experimental::dispatch(ex.wrap(f2), handler3()); std::experimental::dispatch(ex.wrap(f2), std::move(h3)); std::future<void> fut4 = std::experimental::dispatch(ex.wrap(f2), std::experimental::use_future); fut4.get(); std::experimental::dispatch(ex.wrap(cf2), handler1); std::experimental::dispatch(ex.wrap(cf2), &handler1); std::experimental::dispatch(ex.wrap(cf2), handler2()); std::experimental::dispatch(ex.wrap(cf2), h2); std::experimental::dispatch(ex.wrap(cf2), ch2); std::experimental::dispatch(ex.wrap(cf2), handler3()); std::experimental::dispatch(ex.wrap(cf2), std::move(h3)); std::future<void> fut5 = std::experimental::dispatch(ex.wrap(cf2), std::experimental::use_future); fut5.get(); std::experimental::dispatch(ex.wrap(function3()), handler1); std::experimental::dispatch(ex.wrap(function3()), &handler1); std::experimental::dispatch(ex.wrap(function3()), handler2()); std::experimental::dispatch(ex.wrap(function3()), h2); std::experimental::dispatch(ex.wrap(function3()), ch2); std::experimental::dispatch(ex.wrap(function3()), handler3()); std::experimental::dispatch(ex.wrap(function3()), std::move(h3)); std::future<void> fut6 = std::experimental::dispatch(ex.wrap(function3()), std::experimental::use_future); fut6.get(); std::experimental::dispatch(ex.wrap(std::move(f3)), handler1); std::experimental::dispatch(ex.wrap(std::move(f3)), &handler1); std::experimental::dispatch(ex.wrap(std::move(f3)), handler2()); std::experimental::dispatch(ex.wrap(std::move(f3)), h2); std::experimental::dispatch(ex.wrap(std::move(f3)), ch2); std::experimental::dispatch(ex.wrap(std::move(f3)), handler3()); std::experimental::dispatch(ex.wrap(std::move(f3)), std::move(h3)); std::future<void> fut7 = std::experimental::dispatch(ex.wrap(std::move(f3)), std::experimental::use_future); fut7.get(); w.reset(); t.join(); assert(function_count == 56); assert(handler_count == 49); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::loop_scheduler scheduler; std::experimental::executor ex = make_executor(scheduler); ex = std::experimental::system_executor(); assert(&ex.context() == &std::experimental::system_executor().context()); std::experimental::post(ex.wrap(function1), handler1); std::experimental::post(ex.wrap(function1), &handler1); std::experimental::post(ex.wrap(function1), handler2()); std::experimental::post(ex.wrap(function1), h2); std::experimental::post(ex.wrap(function1), ch2); std::experimental::post(ex.wrap(function1), handler3()); std::experimental::post(ex.wrap(function1), std::move(h3)); std::future<void> fut1 = std::experimental::post(ex.wrap(function1), std::experimental::use_future); fut1.get(); std::experimental::post(ex.wrap(&function1), handler1); std::experimental::post(ex.wrap(&function1), &handler1); std::experimental::post(ex.wrap(&function1), handler2()); std::experimental::post(ex.wrap(&function1), h2); std::experimental::post(ex.wrap(&function1), ch2); std::experimental::post(ex.wrap(&function1), handler3()); std::experimental::post(ex.wrap(&function1), std::move(h3)); std::future<void> fut2 = std::experimental::post(ex.wrap(&function1), std::experimental::use_future); fut2.get(); std::experimental::post(ex.wrap(function2()), handler1); std::experimental::post(ex.wrap(function2()), &handler1); std::experimental::post(ex.wrap(function2()), handler2()); std::experimental::post(ex.wrap(function2()), h2); std::experimental::post(ex.wrap(function2()), ch2); std::experimental::post(ex.wrap(function2()), handler3()); std::experimental::post(ex.wrap(function2()), std::move(h3)); std::future<void> fut3 = std::experimental::post(ex.wrap(function2()), std::experimental::use_future); fut3.get(); std::experimental::post(ex.wrap(f2), handler1); std::experimental::post(ex.wrap(f2), &handler1); std::experimental::post(ex.wrap(f2), handler2()); std::experimental::post(ex.wrap(f2), h2); std::experimental::post(ex.wrap(f2), ch2); std::experimental::post(ex.wrap(f2), handler3()); std::experimental::post(ex.wrap(f2), std::move(h3)); std::future<void> fut4 = std::experimental::post(ex.wrap(f2), std::experimental::use_future); fut4.get(); std::experimental::post(ex.wrap(cf2), handler1); std::experimental::post(ex.wrap(cf2), &handler1); std::experimental::post(ex.wrap(cf2), handler2()); std::experimental::post(ex.wrap(cf2), h2); std::experimental::post(ex.wrap(cf2), ch2); std::experimental::post(ex.wrap(cf2), handler3()); std::experimental::post(ex.wrap(cf2), std::move(h3)); std::future<void> fut5 = std::experimental::post(ex.wrap(cf2), std::experimental::use_future); fut5.get(); std::experimental::post(ex.wrap(function3()), handler1); std::experimental::post(ex.wrap(function3()), &handler1); std::experimental::post(ex.wrap(function3()), handler2()); std::experimental::post(ex.wrap(function3()), h2); std::experimental::post(ex.wrap(function3()), ch2); std::experimental::post(ex.wrap(function3()), handler3()); std::experimental::post(ex.wrap(function3()), std::move(h3)); std::future<void> fut6 = std::experimental::post(ex.wrap(function3()), std::experimental::use_future); fut6.get(); std::experimental::post(ex.wrap(std::move(f3)), handler1); std::experimental::post(ex.wrap(std::move(f3)), &handler1); std::experimental::post(ex.wrap(std::move(f3)), handler2()); std::experimental::post(ex.wrap(std::move(f3)), h2); std::experimental::post(ex.wrap(std::move(f3)), ch2); std::experimental::post(ex.wrap(std::move(f3)), handler3()); std::experimental::post(ex.wrap(std::move(f3)), std::move(h3)); std::future<void> fut7 = std::experimental::post(ex.wrap(std::move(f3)), std::experimental::use_future); fut7.get(); std::this_thread::sleep_for(std::chrono::seconds(1)); assert(function_count == 56); assert(handler_count == 49); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::thread_pool pool; auto ex = make_executor(pool); std::experimental::dispatch(ex, function1, handler1); std::experimental::dispatch(ex, function1, &handler1); std::experimental::dispatch(ex, function1, handler2()); std::experimental::dispatch(ex, function1, h2); std::experimental::dispatch(ex, function1, ch2); std::experimental::dispatch(ex, function1, handler3()); std::experimental::dispatch(ex, function1, std::move(h3)); std::future<int> fut1 = std::experimental::dispatch(ex, function1, std::experimental::use_future); fut1.get(); std::experimental::dispatch(ex, &function1, handler1); std::experimental::dispatch(ex, &function1, &handler1); std::experimental::dispatch(ex, &function1, handler2()); std::experimental::dispatch(ex, &function1, h2); std::experimental::dispatch(ex, &function1, ch2); std::experimental::dispatch(ex, &function1, handler3()); std::experimental::dispatch(ex, &function1, std::move(h3)); std::future<int> fut2 = std::experimental::dispatch(ex, &function1, std::experimental::use_future); fut2.get(); std::experimental::dispatch(ex, function2(), handler1); std::experimental::dispatch(ex, function2(), &handler1); std::experimental::dispatch(ex, function2(), handler2()); std::experimental::dispatch(ex, function2(), h2); std::experimental::dispatch(ex, function2(), ch2); std::experimental::dispatch(ex, function2(), handler3()); std::experimental::dispatch(ex, function2(), std::move(h3)); std::future<int> fut3 = std::experimental::dispatch(ex, function2(), std::experimental::use_future); fut3.get(); std::experimental::dispatch(ex, f2, handler1); std::experimental::dispatch(ex, f2, &handler1); std::experimental::dispatch(ex, f2, handler2()); std::experimental::dispatch(ex, f2, h2); std::experimental::dispatch(ex, f2, ch2); std::experimental::dispatch(ex, f2, handler3()); std::experimental::dispatch(ex, f2, std::move(h3)); std::future<int> fut4 = std::experimental::dispatch(ex, f2, std::experimental::use_future); fut4.get(); std::experimental::dispatch(ex, cf2, handler1); std::experimental::dispatch(ex, cf2, &handler1); std::experimental::dispatch(ex, cf2, handler2()); std::experimental::dispatch(ex, cf2, h2); std::experimental::dispatch(ex, cf2, ch2); std::experimental::dispatch(ex, cf2, handler3()); std::experimental::dispatch(ex, cf2, std::move(h3)); std::future<int> fut5 = std::experimental::dispatch(ex, cf2, std::experimental::use_future); fut5.get(); std::experimental::dispatch(ex, function3(), handler1); std::experimental::dispatch(ex, function3(), &handler1); std::experimental::dispatch(ex, function3(), handler2()); std::experimental::dispatch(ex, function3(), h2); std::experimental::dispatch(ex, function3(), ch2); std::experimental::dispatch(ex, function3(), handler3()); std::experimental::dispatch(ex, function3(), std::move(h3)); std::future<int> fut6 = std::experimental::dispatch(ex, function3(), std::experimental::use_future); fut6.get(); std::experimental::dispatch(ex, std::move(f3), handler1); std::experimental::dispatch(ex, std::move(f3), &handler1); std::experimental::dispatch(ex, std::move(f3), handler2()); std::experimental::dispatch(ex, std::move(f3), h2); std::experimental::dispatch(ex, std::move(f3), ch2); std::experimental::dispatch(ex, std::move(f3), handler3()); std::experimental::dispatch(ex, std::move(f3), std::move(h3)); std::future<int> fut7 = std::experimental::dispatch(ex, std::move(f3), std::experimental::use_future); fut7.get(); pool.join(); assert(function_count == 56); assert(handler_count == 49); }
int main (int argc, char const * argv []) { static char const * optv [] = { "e:m:o:p:iqrvw:", "", "Weeder Solid State Relay Module Controller", "e n\techo is (n) [" LITERAL (WEEDER_ECHO) "]", "m n\tmode is (n) [" LITERAL (WEEDER_MODE) "]", "o s\tunit order is (s) [" WEEDER_UNITS "]", "p f\tport is (f) [" WEEDER_PORT "]", "q\tquiet mode", "r\tread attenuator value", "v\tverbose mode", "w n\twait (n) millseconds [" LITERAL (WEEDER_WAIT) "]", (char const *) (0) }; struct _file_ port = { -1, WEEDER_PORT }; #if defined (WIN32) HANDLE hSerial; DCB dcbSerial = { 0 }; #else struct termios termios; #endif char const * units = WEEDER_UNITS; unsigned wait = WEEDER_WAIT; unsigned echo = WEEDER_ECHO; unsigned mode = WEEDER_MODE; unsigned data = 0; flag_t flags = (flag_t)(0); signed c; optind = 1; if (getenv ("WEEDER")) { port.name = strdup (getenv ("WEEDER")); } while ((c = getoptv (argc, argv, optv)) != -1) { switch (c) { case 'e': echo = (unsigned)(uintspec (synonym (optarg, modes, SIZEOF (modes)), 0, 1)); break; case 'm': mode = (unsigned)(uintspec (synonym (optarg, modes, SIZEOF (modes)), 0, 1)); break; case 'n': _setbits (flags, WEEDER_NEWLINE); break; case 'o': units = optarg; break; case 'p': port.name = optarg; break; case 'w': wait = (unsigned)(uintspec (optarg, 5, 100)); break; case 'q': _setbits (flags, WEEDER_SILENCE); break; case 'r': _setbits (flags, WEEDER_DISPLAY); break; case 'v': _setbits (flags, WEEDER_VERBOSE); break; default: break; } } argc -= optind; argv += optind; if ((argc) && (* argv)) { data = (unsigned)(uintspec (* argv, 0, 0x7F)); } #if defined (WIN32) hSerial = CreateFile (port.name, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if (hSerial == INVALID_HANDLE_VALUE) { error (1, errno, FILE_CANTOPEN, port.name); } dcbSerial.DCBlength = sizeof (dcbSerial); if (!GetCommState (hSerial, &dcbSerial)) { error (1, 0, FILE_CANTREAD " state", port.name); } dcbSerial.BaudRate = CBR_9600; dcbSerial.ByteSize = 8; dcbSerial.StopBits = ONESTOPBIT; dcbSerial.Parity = NOPARITY; if (!SetCommState (hSerial, &dcbSerial)) { error (1, 0, FILE_CANTSAVE, port.name); } CloseHandle (hSerial); if ((port.file = open (port.name, O_BINARY | O_RDWR)) == -1) { error (1, errno, FILE_CANTOPEN " state", port.name); } #else if ((port.file = open (port.name, O_RDWR|O_NOCTTY|O_NDELAY)) == -1) { error (1, 0, FILE_CANTOPEN, port.name); } tcgetattr (port.file, &termios); termios.c_cflag = CS8; cfsetospeed (&termios, B9600); tcsetattr (port.file, TCSANOW, &termios); #endif function1 (&port, units, wait, echo); if ((argc) && (* argv)) { function2 (&port, units, wait, mode, data); } if (_anyset (flags, WEEDER_DISPLAY)) { function3 (&port, units, wait); } close (port.file); exit (0); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::loop_scheduler scheduler; auto ex = make_strand(scheduler.get_executor()); std::experimental::executor_work<decltype(ex)> w(ex); std::thread t([&](){ scheduler.run(); }); std::experimental::post(ex, function1, handler1); std::experimental::post(ex, function1, &handler1); std::experimental::post(ex, function1, handler2()); std::experimental::post(ex, function1, h2); std::experimental::post(ex, function1, ch2); std::experimental::post(ex, function1, handler3()); std::experimental::post(ex, function1, std::move(h3)); std::future<int> fut1 = std::experimental::post(ex, function1, std::experimental::use_future); fut1.get(); std::experimental::post(ex, &function1, handler1); std::experimental::post(ex, &function1, &handler1); std::experimental::post(ex, &function1, handler2()); std::experimental::post(ex, &function1, h2); std::experimental::post(ex, &function1, ch2); std::experimental::post(ex, &function1, handler3()); std::experimental::post(ex, &function1, std::move(h3)); std::future<int> fut2 = std::experimental::post(ex, &function1, std::experimental::use_future); fut2.get(); std::experimental::post(ex, function2(), handler1); std::experimental::post(ex, function2(), &handler1); std::experimental::post(ex, function2(), handler2()); std::experimental::post(ex, function2(), h2); std::experimental::post(ex, function2(), ch2); std::experimental::post(ex, function2(), handler3()); std::experimental::post(ex, function2(), std::move(h3)); std::future<int> fut3 = std::experimental::post(ex, function2(), std::experimental::use_future); fut3.get(); std::experimental::post(ex, f2, handler1); std::experimental::post(ex, f2, &handler1); std::experimental::post(ex, f2, handler2()); std::experimental::post(ex, f2, h2); std::experimental::post(ex, f2, ch2); std::experimental::post(ex, f2, handler3()); std::experimental::post(ex, f2, std::move(h3)); std::future<int> fut4 = std::experimental::post(ex, f2, std::experimental::use_future); fut4.get(); std::experimental::post(ex, cf2, handler1); std::experimental::post(ex, cf2, &handler1); std::experimental::post(ex, cf2, handler2()); std::experimental::post(ex, cf2, h2); std::experimental::post(ex, cf2, ch2); std::experimental::post(ex, cf2, handler3()); std::experimental::post(ex, cf2, std::move(h3)); std::future<int> fut5 = std::experimental::post(ex, cf2, std::experimental::use_future); fut5.get(); std::experimental::post(ex, function3(), handler1); std::experimental::post(ex, function3(), &handler1); std::experimental::post(ex, function3(), handler2()); std::experimental::post(ex, function3(), h2); std::experimental::post(ex, function3(), ch2); std::experimental::post(ex, function3(), handler3()); std::experimental::post(ex, function3(), std::move(h3)); std::future<int> fut6 = std::experimental::post(ex, function3(), std::experimental::use_future); fut6.get(); std::experimental::post(ex, std::move(f3), handler1); std::experimental::post(ex, std::move(f3), &handler1); std::experimental::post(ex, std::move(f3), handler2()); std::experimental::post(ex, std::move(f3), h2); std::experimental::post(ex, std::move(f3), ch2); std::experimental::post(ex, std::move(f3), handler3()); std::experimental::post(ex, std::move(f3), std::move(h3)); std::future<int> fut7 = std::experimental::post(ex, std::move(f3), std::experimental::use_future); fut7.get(); w.reset(); t.join(); assert(function_count == 56); assert(handler_count == 49); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::thread_pool pool; auto ex = make_executor(pool); std::experimental::post(ex.wrap(function1), handler1); std::experimental::post(ex.wrap(function1), &handler1); std::experimental::post(ex.wrap(function1), handler2()); std::experimental::post(ex.wrap(function1), h2); std::experimental::post(ex.wrap(function1), ch2); std::experimental::post(ex.wrap(function1), handler3()); std::experimental::post(ex.wrap(function1), std::move(h3)); std::future<void> fut1 = std::experimental::post(ex.wrap(function1), std::experimental::use_future); fut1.get(); std::experimental::post(ex.wrap(&function1), handler1); std::experimental::post(ex.wrap(&function1), &handler1); std::experimental::post(ex.wrap(&function1), handler2()); std::experimental::post(ex.wrap(&function1), h2); std::experimental::post(ex.wrap(&function1), ch2); std::experimental::post(ex.wrap(&function1), handler3()); std::experimental::post(ex.wrap(&function1), std::move(h3)); std::future<void> fut2 = std::experimental::post(ex.wrap(&function1), std::experimental::use_future); fut2.get(); std::experimental::post(ex.wrap(function2()), handler1); std::experimental::post(ex.wrap(function2()), &handler1); std::experimental::post(ex.wrap(function2()), handler2()); std::experimental::post(ex.wrap(function2()), h2); std::experimental::post(ex.wrap(function2()), ch2); std::experimental::post(ex.wrap(function2()), handler3()); std::experimental::post(ex.wrap(function2()), std::move(h3)); std::future<void> fut3 = std::experimental::post(ex.wrap(function2()), std::experimental::use_future); fut3.get(); std::experimental::post(ex.wrap(f2), handler1); std::experimental::post(ex.wrap(f2), &handler1); std::experimental::post(ex.wrap(f2), handler2()); std::experimental::post(ex.wrap(f2), h2); std::experimental::post(ex.wrap(f2), ch2); std::experimental::post(ex.wrap(f2), handler3()); std::experimental::post(ex.wrap(f2), std::move(h3)); std::future<void> fut4 = std::experimental::post(ex.wrap(f2), std::experimental::use_future); fut4.get(); std::experimental::post(ex.wrap(cf2), handler1); std::experimental::post(ex.wrap(cf2), &handler1); std::experimental::post(ex.wrap(cf2), handler2()); std::experimental::post(ex.wrap(cf2), h2); std::experimental::post(ex.wrap(cf2), ch2); std::experimental::post(ex.wrap(cf2), handler3()); std::experimental::post(ex.wrap(cf2), std::move(h3)); std::future<void> fut5 = std::experimental::post(ex.wrap(cf2), std::experimental::use_future); fut5.get(); std::experimental::post(ex.wrap(function3()), handler1); std::experimental::post(ex.wrap(function3()), &handler1); std::experimental::post(ex.wrap(function3()), handler2()); std::experimental::post(ex.wrap(function3()), h2); std::experimental::post(ex.wrap(function3()), ch2); std::experimental::post(ex.wrap(function3()), handler3()); std::experimental::post(ex.wrap(function3()), std::move(h3)); std::future<void> fut6 = std::experimental::post(ex.wrap(function3()), std::experimental::use_future); fut6.get(); std::experimental::post(ex.wrap(std::move(f3)), handler1); std::experimental::post(ex.wrap(std::move(f3)), &handler1); std::experimental::post(ex.wrap(std::move(f3)), handler2()); std::experimental::post(ex.wrap(std::move(f3)), h2); std::experimental::post(ex.wrap(std::move(f3)), ch2); std::experimental::post(ex.wrap(std::move(f3)), handler3()); std::experimental::post(ex.wrap(std::move(f3)), std::move(h3)); std::future<void> fut7 = std::experimental::post(ex.wrap(std::move(f3)), std::experimental::use_future); fut7.get(); pool.join(); assert(function_count == 56); assert(handler_count == 49); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::loop_scheduler scheduler; std::experimental::executor ex = scheduler.get_executor(); ex = std::experimental::system_executor(); assert(&ex.context() == &std::experimental::system_executor().context()); auto rel_time = std::chrono::milliseconds(100); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function1), handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function1), &handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function1), handler2()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function1), h2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function1), ch2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function1), handler3()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function1), std::move(h3)); std::future<void> fut1 = std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function1), std::experimental::use_future); fut1.get(); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, &function1), handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, &function1), &handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, &function1), handler2()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, &function1), h2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, &function1), ch2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, &function1), handler3()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, &function1), std::move(h3)); std::future<void> fut2 = std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, &function1), std::experimental::use_future); fut2.get(); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function2()), handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function2()), &handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function2()), handler2()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function2()), h2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function2()), ch2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function2()), handler3()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function2()), std::move(h3)); std::future<void> fut3 = std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function2()), std::experimental::use_future); fut3.get(); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, f2), handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, f2), &handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, f2), handler2()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, f2), h2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, f2), ch2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, f2), handler3()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, f2), std::move(h3)); std::future<void> fut4 = std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, f2), std::experimental::use_future); fut4.get(); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, cf2), handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, cf2), &handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, cf2), handler2()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, cf2), h2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, cf2), ch2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, cf2), handler3()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, cf2), std::move(h3)); std::future<void> fut5 = std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, cf2), std::experimental::use_future); fut5.get(); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function3()), handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function3()), &handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function3()), handler2()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function3()), h2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function3()), ch2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function3()), handler3()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function3()), std::move(h3)); std::future<void> fut6 = std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, function3()), std::experimental::use_future); fut6.get(); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, std::move(f3)), handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, std::move(f3)), &handler1); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, std::move(f3)), handler2()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, std::move(f3)), h2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, std::move(f3)), ch2); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, std::move(f3)), handler3()); std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, std::move(f3)), std::move(h3)); std::future<void> fut7 = std::experimental::dispatch_after(rel_time, std::experimental::wrap(ex, std::move(f3)), std::experimental::use_future); fut7.get(); std::this_thread::sleep_for(std::chrono::seconds(1)); assert(function_count == 56); assert(handler_count == 49); }
int main(int argc, char **argv) { //SCENARIO 0 //Passing a primitive by value. arg0 should NOT be put on the heap. int arg0 = 32; arg0 = function2(arg0); //SCENARIO 1 //Passing a local via address. arg1 should be put on the heap. int arg1 = 7; function1(&arg1); //SCENARIO 2 //Passing a pointer to a local variable. arg2 should be put on the heap. arg3 should NOT. int arg2 = 4; int *arg3 = &arg2; function1(arg3); //SCENARIO 3 //Passing a pointer to a heap address. arg4 should NOT be put on the heap. int * arg4 = (int *) malloc(sizeof(int)); (*arg4) = 3; function1(arg4); //SCENARIO 4 //Passing a pointer to a heap address that turns into a local address. arg6 should be put on the heap. //arg5 should NOT. int * arg5 = (int *) malloc(sizeof(int)); (*arg5) = 56; int arg6 = 5; arg5 = &arg6; function1(arg5); //SCENARIO 5 //Passing a pointer by address that points to dynamically allocated memory. arg7 should be put on the heap. int * arg7 = (int *) malloc(sizeof(int)); function3(&arg7); //SCENARIO 6 //Passing a pointer that points to a pointer to a pointer. //arg9 and 8 should be put on the heap. arg10 should NOT. int arg8 = 34; int * arg9 = &arg8; int ** arg10 = &arg9; function3(arg10); //SCENARIO 7 //Passing a pointer that points to a pointer to a malloc. //arg11 should be placed on the heap. int * arg11 = (int *) malloc(sizeof(int)); int ** arg12 = &arg11; function3(arg12); //SCENARIO 8 //Passing a pointer that points to a value onto the heap. //arg13 and arg14 should be placed on the heap. int arg13 = 35; int * arg14 = &arg13; function3(&arg14); //SCENARIO 9 //Passing a pointer to the address of a local stored in an intermediate value. //Only arg15 should be put on the heap. int arg15 = 34; int * arg16 = &arg15; int ** arg17 = (int **) malloc(sizeof(int*)); (*arg17) = arg16; function3(arg17); int arg18 = 34; //PHI: Simple conditional. //arg18 should be placed in the heap. if (arg15 > 10) { function1(&arg18); } else { arg18 *= 2; } int count = 0; for (count = 0; count < arg18; count++) { int blahblah = 34; blahblah *= arg15; printf("%d\n", blahblah); arg15 += 34; } return 0; }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::post(function1); std::experimental::post(function1, handler1); std::experimental::post(function1, &handler1); std::experimental::post(function1, handler2()); std::experimental::post(function1, h2); std::experimental::post(function1, ch2); std::experimental::post(function1, handler3()); std::experimental::post(function1, std::move(h3)); std::future<int> fut1 = std::experimental::post(function1, std::experimental::use_future); fut1.get(); std::experimental::post(&function1); std::experimental::post(&function1, handler1); std::experimental::post(&function1, &handler1); std::experimental::post(&function1, handler2()); std::experimental::post(&function1, h2); std::experimental::post(&function1, ch2); std::experimental::post(&function1, handler3()); std::experimental::post(&function1, std::move(h3)); std::future<int> fut2 = std::experimental::post(&function1, std::experimental::use_future); fut2.get(); std::experimental::post(function2()); std::experimental::post(function2(), handler1); std::experimental::post(function2(), &handler1); std::experimental::post(function2(), handler2()); std::experimental::post(function2(), h2); std::experimental::post(function2(), ch2); std::experimental::post(function2(), handler3()); std::experimental::post(function2(), std::move(h3)); std::future<int> fut3 = std::experimental::post(function2(), std::experimental::use_future); fut3.get(); std::experimental::post(f2); std::experimental::post(f2, handler1); std::experimental::post(f2, &handler1); std::experimental::post(f2, handler2()); std::experimental::post(f2, h2); std::experimental::post(f2, ch2); std::experimental::post(f2, handler3()); std::experimental::post(f2, std::move(h3)); std::future<int> fut4 = std::experimental::post(f2, std::experimental::use_future); fut4.get(); std::experimental::post(cf2); std::experimental::post(cf2, handler1); std::experimental::post(cf2, &handler1); std::experimental::post(cf2, handler2()); std::experimental::post(cf2, h2); std::experimental::post(cf2, ch2); std::experimental::post(cf2, handler3()); std::experimental::post(cf2, std::move(h3)); std::future<int> fut5 = std::experimental::post(cf2, std::experimental::use_future); fut5.get(); std::experimental::post(function3()); std::experimental::post(function3(), handler1); std::experimental::post(function3(), &handler1); std::experimental::post(function3(), handler2()); std::experimental::post(function3(), h2); std::experimental::post(function3(), ch2); std::experimental::post(function3(), handler3()); std::experimental::post(function3(), std::move(h3)); std::future<int> fut6 = std::experimental::post(function3(), std::experimental::use_future); fut6.get(); std::experimental::post(std::move(f3)); std::experimental::post(std::move(f3), handler1); std::experimental::post(std::move(f3), &handler1); std::experimental::post(std::move(f3), handler2()); std::experimental::post(std::move(f3), h2); std::experimental::post(std::move(f3), ch2); std::experimental::post(std::move(f3), handler3()); std::experimental::post(std::move(f3), std::move(h3)); std::future<int> fut7 = std::experimental::post(std::move(f3), std::experimental::use_future); fut7.get(); std::this_thread::sleep_for(std::chrono::seconds(1)); assert(function_count == 63); assert(handler_count == 49); std::future<int> fut8 = std::experimental::post(function_throw, std::experimental::use_future); try { fut8.get(); assert(0); } catch (std::exception& e) { assert(e.what() == std::string("oops")); } std::future<int> fut9 = std::experimental::post(std::experimental::package(function_throw)); try { fut9.get(); assert(0); } catch (std::exception& e) { assert(e.what() == std::string("oops")); } }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::loop_scheduler scheduler; auto ex = make_executor(scheduler); std::experimental::executor::work w = ex.make_work(); std::thread t([&](){ scheduler.run(); }); std::experimental::post(ex, function1, handler1); std::experimental::post(ex, function1, &handler1); std::experimental::post(ex, function1, handler2()); std::experimental::post(ex, function1, h2); std::experimental::post(ex, function1, ch2); std::experimental::post(ex, function1, handler3()); std::experimental::post(ex, function1, std::move(h3)); std::future<void> fut1 = std::experimental::post(ex, function1, std::experimental::use_future); fut1.get(); std::experimental::post(ex, &function1, handler1); std::experimental::post(ex, &function1, &handler1); std::experimental::post(ex, &function1, handler2()); std::experimental::post(ex, &function1, h2); std::experimental::post(ex, &function1, ch2); std::experimental::post(ex, &function1, handler3()); std::experimental::post(ex, &function1, std::move(h3)); std::future<void> fut2 = std::experimental::post(ex, &function1, std::experimental::use_future); fut2.get(); std::experimental::post(ex, function2(), handler1); std::experimental::post(ex, function2(), &handler1); std::experimental::post(ex, function2(), handler2()); std::experimental::post(ex, function2(), h2); std::experimental::post(ex, function2(), ch2); std::experimental::post(ex, function2(), handler3()); std::experimental::post(ex, function2(), std::move(h3)); std::future<void> fut3 = std::experimental::post(ex, function2(), std::experimental::use_future); fut3.get(); std::experimental::post(ex, f2, handler1); std::experimental::post(ex, f2, &handler1); std::experimental::post(ex, f2, handler2()); std::experimental::post(ex, f2, h2); std::experimental::post(ex, f2, ch2); std::experimental::post(ex, f2, handler3()); std::experimental::post(ex, f2, std::move(h3)); std::future<void> fut4 = std::experimental::post(ex, f2, std::experimental::use_future); fut4.get(); std::experimental::post(ex, cf2, handler1); std::experimental::post(ex, cf2, &handler1); std::experimental::post(ex, cf2, handler2()); std::experimental::post(ex, cf2, h2); std::experimental::post(ex, cf2, ch2); std::experimental::post(ex, cf2, handler3()); std::experimental::post(ex, cf2, std::move(h3)); std::future<void> fut5 = std::experimental::post(ex, cf2, std::experimental::use_future); fut5.get(); std::experimental::post(ex, function3(), handler1); std::experimental::post(ex, function3(), &handler1); std::experimental::post(ex, function3(), handler2()); std::experimental::post(ex, function3(), h2); std::experimental::post(ex, function3(), ch2); std::experimental::post(ex, function3(), handler3()); std::experimental::post(ex, function3(), std::move(h3)); std::future<void> fut6 = std::experimental::post(ex, function3(), std::experimental::use_future); fut6.get(); std::experimental::post(ex, std::move(f3), handler1); std::experimental::post(ex, std::move(f3), &handler1); std::experimental::post(ex, std::move(f3), handler2()); std::experimental::post(ex, std::move(f3), h2); std::experimental::post(ex, std::move(f3), ch2); std::experimental::post(ex, std::move(f3), handler3()); std::experimental::post(ex, std::move(f3), std::move(h3)); std::future<void> fut7 = std::experimental::post(ex, std::move(f3), std::experimental::use_future); fut7.get(); w = nullptr; assert(!w); assert(w == nullptr); assert(nullptr == w); assert(!(w != nullptr)); assert(!(nullptr != w)); t.join(); assert(function_count == 56); assert(handler_count == 49); }
int main(int argc,char *argv[]) { float x0,y0,x00,y00,t0,d1,d2,d3,o1,o2,o3,k11,k21,k31,k41,k12,k22,k32,k42; float kxi,gamma,omega,phi;/*parameter define*/ int i,j,k,n1,n2,n3,sn1,pow1,pow2; double h; float *inpsg,*xt,*xt1,*re; sf_complex *out1; sf_file in, out, restor=NULL; bool verb,cosine; sf_init (argc, argv); in = sf_input("in"); out = sf_output("out"); if (NULL != sf_getstring ("restor")) { restor = sf_input("restor"); } else { restor = NULL; sn1=1; } sf_setformat(out,"native_complex"); if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input"); if (!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input"); if (!sf_histfloat(in,"o1",&o1)) sf_error("No o1= in input"); if (!sf_histint(in,"n2",&n2)) n2=1; if (!sf_histfloat(in,"d2",&d2)) d2=1; if (!sf_histfloat(in,"o2",&o2)) o2=1; if (!sf_histint(in,"n3",&n3)) n3=1; if (!sf_histfloat(in,"d3",&d3)) d3=1; if (!sf_histfloat(in,"o3",&o3)) o3=1; if(!sf_getfloat("gamma",&gamma)) gamma=0.75; /*strength of external force*/ if(!sf_getfloat("omega",&omega)) omega=1; /*angular frequence of external force*/ if(!sf_getfloat("kxi",&kxi)) kxi=1; /*adjustment for input signal*/ if(!sf_getfloat("x0",&x0)) x0=0; /*initial value of x0*/ if(!sf_getfloat("y0",&y0)) y0=0; /*initial value of y0*/ if(!sf_getint("pow1",&pow1)) pow1=1; /*power of first non-linear restitution term*/ if(!sf_getint("pow2",&pow2)) pow2=3; /*power of second non-linear restitution term*/ if(!sf_getfloat("phi",&phi)) phi=0.; /*phase of cosine signal unit=pi*/ if(!sf_getbool("verb",&verb)) verb = false; /* verbosity flag */ if(!sf_getbool("cosine",&cosine)) cosine = true; /* if n need extenal input for periodic restoring force */ if (NULL != restor){ if (!sf_histint(restor,"n1",&sn1)) sf_error("No n1= in s"); if (n1>sn1) sf_error("insufficient lenth of external force"); } h=d1; /*step lenth of R-K4*/ re = sf_floatalloc(sn1); inpsg = sf_floatalloc(n1*n2); xt = sf_floatalloc(n1*n2); xt1 = sf_floatalloc(n1*n2); out1 = sf_complexalloc(n1*n2); if (NULL != restor) { sf_floatread(re,sn1,restor); }else { for (i=0;i<sn1; i++) re[i] = 0; } if(cosine) { for(k = 0; k < n3 ; k++) { sf_floatread(inpsg,n1*n2,in); x00=x0,y00=y0; t0=0; if(verb) sf_warning("step %d of %d;",k,n3); for(j = 0;j < n2;j++) { x00=x0,y00=y0; t0=0; for(i = 0;i < n1;i++){ k11 = function1(t0,x00,y00,omega); k12 = function2(t0,x00,y00,inpsg[i+j*n1],kxi, gamma,omega,pow1,pow2,phi); k21 = function1(t0+h/2,x00+k11*h/2,y00+k12*h/2,omega); k22 = function2(t0+h/2,x00+k11*h/2, y00+k12*h/2,inpsg[i+j*n1],kxi, gamma,omega,pow1,pow2,phi); k31 = function1(t0+h/2,x00+k21*h/2,y00+k22*h/2,omega); k32 = function2(t0+h/2,x00+k21*h/2, y00+k22*h/2,inpsg[i+j*n1],kxi, gamma,omega,pow1,pow2,phi); k41 = function1(t0+h,x00+k31*h,y00+k32*h,omega); k42 = function2(t0+h,x00+k31*h,y00+k32*h,inpsg[i+j*n1], kxi,gamma,omega,pow1,pow2,phi); x00+= h*(k11+2*k21+2*k31+k41)/6; y00+= h*(k12+2*k22+2*k32+k42)/6; t0+= h; xt[i+j*n1]=x00,xt1[i+j*n1]=y00; } } for(i=0;i < n1*n2;i++) { out1[i] = sf_cmplx(xt[i],xt1[i]); } sf_complexwrite(out1,n1*n2,out); } }else { for(k = 0; k < n3 ; k++) { sf_floatread(inpsg,n1*n2,in); x00=x0,y00=y0; t0=0; if(verb) sf_warning("step %d of %d;",k,n3); for(j = 0;j < n2;j++) { x00=x0,y00=y0; t0=0; for(i = 0;i < n1;i++) { k11 = function1(t0,x00,y00,omega); k12 = function3(t0,x00,y00,inpsg[i+j*n1],kxi, gamma,omega,pow1,pow2,re[i]); k21 = function1(t0+h/2,x00+k11*h/2,y00+k12*h/2,omega); k22 = function3(t0+h/2,x00+k11*h/2, y00+k12*h/2,inpsg[i+j*n1],kxi, gamma,omega,pow1,pow2,re[i]); k31 = function1(t0+h/2,x00+k21*h/2,y00+k22*h/2,omega); k32 = function3(t0+h/2,x00+k21*h/2, y00+k22*h/2,inpsg[i+j*n1],kxi, gamma,omega,pow1,pow2,re[i]); k41 = function1(t0+h,x00+k31*h,y00+k32*h,omega); k42 = function3(t0+h,x00+k31*h,y00+k32*h,inpsg[i+j*n1], kxi,gamma,omega,pow1,pow2,re[i]); x00+= h*(k11+2*k21+2*k31+k41)/6; y00+= h*(k12+2*k22+2*k32+k42)/6; t0+= h; xt[i+j*n1]=x00,xt1[i+j*n1]=y00; } } for(i=0;i < n1*n2;i++) { out1[i] = sf_cmplx(xt[i],xt1[i]); } sf_complexwrite(out1,n1*n2,out); } } exit(0); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::loop_scheduler scheduler; std::experimental::executor ex = scheduler.get_executor(); ex = std::experimental::system_executor(); assert(&ex.context() == &std::experimental::system_executor().context()); auto abs_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100); std::experimental::dispatch_at(abs_time, ex, function1, handler1); std::experimental::dispatch_at(abs_time, ex, function1, &handler1); std::experimental::dispatch_at(abs_time, ex, function1, handler2()); std::experimental::dispatch_at(abs_time, ex, function1, h2); std::experimental::dispatch_at(abs_time, ex, function1, ch2); std::experimental::dispatch_at(abs_time, ex, function1, handler3()); std::experimental::dispatch_at(abs_time, ex, function1, std::move(h3)); std::future<void> fut1 = std::experimental::dispatch_at(abs_time, ex, function1, std::experimental::use_future); fut1.get(); std::experimental::dispatch_at(abs_time, ex, &function1, handler1); std::experimental::dispatch_at(abs_time, ex, &function1, &handler1); std::experimental::dispatch_at(abs_time, ex, &function1, handler2()); std::experimental::dispatch_at(abs_time, ex, &function1, h2); std::experimental::dispatch_at(abs_time, ex, &function1, ch2); std::experimental::dispatch_at(abs_time, ex, &function1, handler3()); std::experimental::dispatch_at(abs_time, ex, &function1, std::move(h3)); std::future<void> fut2 = std::experimental::dispatch_at(abs_time, ex, &function1, std::experimental::use_future); fut2.get(); std::experimental::dispatch_at(abs_time, ex, function2(), handler1); std::experimental::dispatch_at(abs_time, ex, function2(), &handler1); std::experimental::dispatch_at(abs_time, ex, function2(), handler2()); std::experimental::dispatch_at(abs_time, ex, function2(), h2); std::experimental::dispatch_at(abs_time, ex, function2(), ch2); std::experimental::dispatch_at(abs_time, ex, function2(), handler3()); std::experimental::dispatch_at(abs_time, ex, function2(), std::move(h3)); std::future<void> fut3 = std::experimental::dispatch_at(abs_time, ex, function2(), std::experimental::use_future); fut3.get(); std::experimental::dispatch_at(abs_time, ex, f2, handler1); std::experimental::dispatch_at(abs_time, ex, f2, &handler1); std::experimental::dispatch_at(abs_time, ex, f2, handler2()); std::experimental::dispatch_at(abs_time, ex, f2, h2); std::experimental::dispatch_at(abs_time, ex, f2, ch2); std::experimental::dispatch_at(abs_time, ex, f2, handler3()); std::experimental::dispatch_at(abs_time, ex, f2, std::move(h3)); std::future<void> fut4 = std::experimental::dispatch_at(abs_time, ex, f2, std::experimental::use_future); fut4.get(); std::experimental::dispatch_at(abs_time, ex, cf2, handler1); std::experimental::dispatch_at(abs_time, ex, cf2, &handler1); std::experimental::dispatch_at(abs_time, ex, cf2, handler2()); std::experimental::dispatch_at(abs_time, ex, cf2, h2); std::experimental::dispatch_at(abs_time, ex, cf2, ch2); std::experimental::dispatch_at(abs_time, ex, cf2, handler3()); std::experimental::dispatch_at(abs_time, ex, cf2, std::move(h3)); std::future<void> fut5 = std::experimental::dispatch_at(abs_time, ex, cf2, std::experimental::use_future); fut5.get(); std::experimental::dispatch_at(abs_time, ex, function3(), handler1); std::experimental::dispatch_at(abs_time, ex, function3(), &handler1); std::experimental::dispatch_at(abs_time, ex, function3(), handler2()); std::experimental::dispatch_at(abs_time, ex, function3(), h2); std::experimental::dispatch_at(abs_time, ex, function3(), ch2); std::experimental::dispatch_at(abs_time, ex, function3(), handler3()); std::experimental::dispatch_at(abs_time, ex, function3(), std::move(h3)); std::future<void> fut6 = std::experimental::dispatch_at(abs_time, ex, function3(), std::experimental::use_future); fut6.get(); std::experimental::dispatch_at(abs_time, ex, std::move(f3), handler1); std::experimental::dispatch_at(abs_time, ex, std::move(f3), &handler1); std::experimental::dispatch_at(abs_time, ex, std::move(f3), handler2()); std::experimental::dispatch_at(abs_time, ex, std::move(f3), h2); std::experimental::dispatch_at(abs_time, ex, std::move(f3), ch2); std::experimental::dispatch_at(abs_time, ex, std::move(f3), handler3()); std::experimental::dispatch_at(abs_time, ex, std::move(f3), std::move(h3)); std::future<void> fut7 = std::experimental::dispatch_at(abs_time, ex, std::move(f3), std::experimental::use_future); fut7.get(); std::this_thread::sleep_for(std::chrono::seconds(1)); assert(function_count == 56); assert(handler_count == 49); std::future<void> fut8 = std::experimental::dispatch_at(abs_time, ex, function_throw, std::experimental::use_future); try { fut8.get(); assert(0); } catch (std::exception& e) { assert(e.what() == std::string("oops")); } std::future<void> fut9 = std::experimental::dispatch_at(abs_time, ex, std::experimental::package(function_throw)); try { fut9.get(); assert(0); } catch (std::exception& e) { assert(e.what() == std::string("oops")); } }
void main(void) { u8 x,y[104],y1; extern u8 save_y[104]; u32 count=0; extern u8 flag_dma,pulse; extern unsigned char stop,send,save; extern signed char y_shift; int a,b,c,d,f,i,j,save_a,save_b; extern volatile unsigned short ADCConvertedValue[104]; unsigned char e; u16 V0_value,V0_flag=0,s=0,V0_temp[104],Vmax,Vmin,Vpp,Vmax1,Vmin1,Vpp1;; extern unsigned char AD_dis_buffer[],dis_x_y_buffer[],AD_dis_save[]; //目标板初化, Target_Init(); init12864lcd(); Clean_12864_GDRAM(); draw_side(); dis_AD_dis_buffer(dis_x_y_buffer); write_12864com(0x30); Vmin=62; Vmax=0; y_shift=0; pulse=1; while(1) { if(flag_dma) { if(i<104) { i++; } else { //TIM_Cmd(TIM2, DISABLE); pulse=0; for(i=0;i<104;) { if(stop==1); else{ V0_value=ADCConvertedValue[i++]; c=(int)(V0_value*3.3/4096)%10; d=(int)(V0_value*3.3/4096*10)%10; y[i]=(u8)(31-(c*10+d)*2*4/5+26+y_shift); y1=(u8)(31-(c*10+d)*2*4/5+26+y_shift); if(Vmin1>=V0_value) { Vmin1=V0_value; } if(Vmax1<=V0_value){ Vmax1=V0_value; } if(Vmin>=y[i]) { Vmin=y[i]; } if(Vmax<=y[i]){ Vmax=y[i]; } Vpp=(Vmax-Vmin)*90/100; Vpp1=(Vmax1-Vmin1)*60/100; b=(int)((Vpp)*5/4)%10; a=(int)((Vpp)*5/4)/10; f=(int)((Vpp1*3.3/4096)*100)%10; dis_define_dot(y1,x++); if(x==104)x=0; } } Vmax=0; Vmin=62; if(GPIO_ReadInputDataBit(GPIOF,KEY7)==0){ delay_nus(50000); count++; } if(count%2==0){ dis_AD(); delay_nus(10000); write_12864com(0x30); locate16(1, 1); write_12864dat('V'); write_12864dat('='); if(GPIO_ReadInputDataBit(SW_GRP,SW1)==0){ e=(unsigned char)a+0x30; write_12864dat(e); write_12864dat('.'); e=(unsigned char)b+0x30; write_12864dat(e); e=(unsigned char)f+0x30; write_12864dat(e); } else if(GPIO_ReadInputDataBit(SW_GRP,SW2)==0){ write_12864dat('0'); write_12864dat('.'); e=(unsigned char)a+0x30; write_12864dat(e); e=(unsigned char)b+0x30; write_12864dat(e); } else if(GPIO_ReadInputDataBit(SW_GRP,SW3)==0){ e=(unsigned char)a+0x30; write_12864dat(e); e=(unsigned char)b+0x30; write_12864dat(e); write_12864dat('m'); write_12864dat('v'); } //e=(unsigned char)f+0x30; //write_12864dat(e); } if(save==1){ save_a=a; save_b=b; for(i=0;i<992;i++) { AD_dis_save[i]=AD_dis_buffer[i]; } for(i=0;i<104;i++){ save_y[i]=y[i]; } save=0; } if(count%2==1){ dis_AD_dis_buffer(AD_dis_save); //delay_nus(10000); write_12864com(0x30); locate16(1, 1); write_12864dat('V'); write_12864dat('='); e=(unsigned char)save_a+0x30; write_12864dat(e); write_12864dat('.'); e=(unsigned char)save_b+0x30; write_12864dat(e); } if(send==1){ function3(); } for(i=0;i<992;i++) { AD_dis_buffer[i]=0x00; } pulse=1; //TIM_Cmd(TIM2, ENABLE); } DMAReConfig(); flag_dma=0; } } }
int main (int argc, char const * argv []) { static char const * optv [] = { "f:g:n:p:iqrvw:z", "", "PTS Module Controller", "f f\tport is (f) [" PTSCTL_PORT "]", "g n\tline ground attenuation is (n) [" LITERAL (PTSCTL_GRND_ATTN) "]", "n n\tline neutral attenuation is (n) [" LITERAL (PTSCTL_LINE_ATTN) "]", "p n\tpower is (n) [" LITERAL (PTSCTL_MODE) "]", "q\tquiet mode", "r\tread and display attenuator settings", "v\tverbose mode", "w n\twait (n) millseconds [" LITERAL (PTSCTL_WAIT) "]", (char const *) (0) }; struct _file_ port = { -1, PTSCTL_PORT }; #if defined (WIN32) HANDLE hSerial; DCB dcbSerial = { 0 }; #else struct termios termios; #endif char const * units = PTSCTL_UNITS; unsigned wait = PTSCTL_WAIT; unsigned mode = PTSCTL_MODE; unsigned echo = PTSCTL_ECHO; unsigned line = PTSCTL_LINE_ATTN; unsigned grnd = PTSCTL_GRND_ATTN; unsigned data = 0; flag_t flags = (flag_t)(0); signed c; optind = 1; if (getenv ("PTSCTL")) { port.name = strdup (getenv ("PTSCTL")); } while ((c = getoptv (argc, argv, optv)) != -1) { switch (c) { case 'f': port.name = optarg; break; case 'g': _setbits (flags, PTSCTL_CHANGE); grnd = (unsigned)(uintspec (optarg, 0, 0x7F)); break; case 'n': _setbits (flags, PTSCTL_CHANGE); line = (unsigned)(uintspec (optarg, 0, 0x7F)); break; case 'p': _setbits (flags, PTSCTL_CHANGE); mode = (unsigned)(uintspec (synonym (optarg, modes, SIZEOF (modes)), 0, 1)); break; case 'w': wait = (unsigned)(uintspec (optarg, 5, 100)); break; case 'q': _setbits (flags, PTSCTL_SILENCE); break; case 'r': _setbits (flags, PTSCTL_DISPLAY); break; case 'v': _setbits (flags, PTSCTL_VERBOSE); break; case 'z': _setbits (flags, PTSCTL_ITERATE); break; default: break; } } argc -= optind; argv += optind; if (argc) { error (1, ENOTSUP, ERROR_TOOMANY); } #if defined (WIN32) hSerial = CreateFile (port.name, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if (hSerial == INVALID_HANDLE_VALUE) { error (1, errno, FILE_CANTOPEN, port.name); } dcbSerial.DCBlength = sizeof (dcbSerial); if (!GetCommState (hSerial, &dcbSerial)) { error (1, 0, FILE_CANTREAD " state", port.name); } dcbSerial.BaudRate = CBR_9600; dcbSerial.ByteSize = 8; dcbSerial.StopBits = ONESTOPBIT; dcbSerial.Parity = NOPARITY; if (!SetCommState (hSerial, &dcbSerial)) { error (1, 0, FILE_CANTSAVE " state", port.name); } CloseHandle (hSerial); if ((port.file = open (port.name, O_BINARY | O_RDWR)) == -1) { error (1, errno, FILE_CANTOPEN, port.name); } #else if ((port.file = open (port.name, O_RDWR|O_NOCTTY|O_NDELAY)) == -1) { error (1, 0, FILE_CANTOPEN, port.name); } tcgetattr (port.file, &termios); termios.c_cflag = CS8; cfsetospeed (&termios, B9600); tcsetattr (port.file, TCSANOW, &termios); #endif function1 (&port, units, wait, echo); if (_anyset (flags, PTSCTL_CHANGE)) { data = line << 8 | grnd << 1 | mode; function2 (&port, units, wait, data); } if (_anyset (flags, PTSCTL_DISPLAY)) { function3 (&port, units, wait); } if (_anyset (flags, PTSCTL_ITERATE)) { function4 (&port, units, wait); } close (port.file); return (0); }
int main() { function2 f2; const function2 cf2; function3 f3; handler2 h2; const handler2 ch2; handler3 h3; std::experimental::loop_scheduler scheduler; std::experimental::executor ex = scheduler.get_executor(); ex = std::experimental::system_executor(); assert(&ex.context() == &std::experimental::system_executor().context()); invoke(std::experimental::chain(ex.wrap(function1))); invoke(std::experimental::chain(ex.wrap(function1), handler1)); invoke(std::experimental::chain(ex.wrap(function1), &handler1)); invoke(std::experimental::chain(ex.wrap(function1), handler2())); invoke(std::experimental::chain(ex.wrap(function1), h2)); invoke(std::experimental::chain(ex.wrap(function1), ch2)); invoke(std::experimental::chain(ex.wrap(function1), handler3())); invoke(std::experimental::chain(ex.wrap(function1), std::move(h3))); invoke(std::experimental::chain(ex.wrap(&function1))); invoke(std::experimental::chain(ex.wrap(&function1), handler1)); invoke(std::experimental::chain(ex.wrap(&function1), &handler1)); invoke(std::experimental::chain(ex.wrap(&function1), handler2())); invoke(std::experimental::chain(ex.wrap(&function1), h2)); invoke(std::experimental::chain(ex.wrap(&function1), ch2)); invoke(std::experimental::chain(ex.wrap(&function1), handler3())); invoke(std::experimental::chain(ex.wrap(&function1), std::move(h3))); invoke(std::experimental::chain(ex.wrap(function2()))); invoke(std::experimental::chain(ex.wrap(function2()), handler1)); invoke(std::experimental::chain(ex.wrap(function2()), &handler1)); invoke(std::experimental::chain(ex.wrap(function2()), handler2())); invoke(std::experimental::chain(ex.wrap(function2()), h2)); invoke(std::experimental::chain(ex.wrap(function2()), ch2)); invoke(std::experimental::chain(ex.wrap(function2()), handler3())); invoke(std::experimental::chain(ex.wrap(function2()), std::move(h3))); invoke(std::experimental::chain(ex.wrap(f2))); invoke(std::experimental::chain(ex.wrap(f2), handler1)); invoke(std::experimental::chain(ex.wrap(f2), &handler1)); invoke(std::experimental::chain(ex.wrap(f2), handler2())); invoke(std::experimental::chain(ex.wrap(f2), h2)); invoke(std::experimental::chain(ex.wrap(f2), ch2)); invoke(std::experimental::chain(ex.wrap(f2), handler3())); invoke(std::experimental::chain(ex.wrap(f2), std::move(h3))); invoke(std::experimental::chain(ex.wrap(cf2))); invoke(std::experimental::chain(ex.wrap(cf2), handler1)); invoke(std::experimental::chain(ex.wrap(cf2), &handler1)); invoke(std::experimental::chain(ex.wrap(cf2), handler2())); invoke(std::experimental::chain(ex.wrap(cf2), h2)); invoke(std::experimental::chain(ex.wrap(cf2), ch2)); invoke(std::experimental::chain(ex.wrap(cf2), handler3())); invoke(std::experimental::chain(ex.wrap(cf2), std::move(h3))); invoke(std::experimental::chain(ex.wrap(function3()))); invoke(std::experimental::chain(ex.wrap(function3()), handler1)); invoke(std::experimental::chain(ex.wrap(function3()), &handler1)); invoke(std::experimental::chain(ex.wrap(function3()), handler2())); invoke(std::experimental::chain(ex.wrap(function3()), h2)); invoke(std::experimental::chain(ex.wrap(function3()), ch2)); invoke(std::experimental::chain(ex.wrap(function3()), handler3())); invoke(std::experimental::chain(ex.wrap(function3()), std::move(h3))); invoke(std::experimental::chain(ex.wrap(std::move(f3)))); invoke(std::experimental::chain(ex.wrap(std::move(f3)), handler1)); invoke(std::experimental::chain(ex.wrap(std::move(f3)), &handler1)); invoke(std::experimental::chain(ex.wrap(std::move(f3)), handler2())); invoke(std::experimental::chain(ex.wrap(std::move(f3)), h2)); invoke(std::experimental::chain(ex.wrap(std::move(f3)), ch2)); invoke(std::experimental::chain(ex.wrap(std::move(f3)), handler3())); invoke(std::experimental::chain(ex.wrap(std::move(f3)), std::move(h3))); assert(function_count == 56); assert(handler_count == 49); }
void *print_functions (void *args) { int i = (int) args; int j; if (i % 4 == 0) { for(j = 0; j < 3; j++) { function1(); } for(j = 0; j < 3; j++) { function2(); } for(j = 0; j < 3; j++) { function3(); } for(j = 0; j < 3; j++) { function4(); } } if (i % 4 == 1) { for(j = 0; j < 3; j++) { function2(); } for(j = 0; j < 3; j++) { function3(); } for(j = 0; j < 3; j++) { function4(); } for(j = 0; j < 3; j++) { function1(); } } if (i % 4 == 2) { for(j = 0; j < 3; j++) { function3(); } for(j = 0; j < 3; j++) { function4(); } for(j = 0; j < 3; j++) { function1(); } for(j = 0; j < 3; j++) { function2(); } } if (i % 4 == 3) { for(j = 0; j < 3; j++) { function4(); } for(j = 0; j < 3; j++) { function1(); } for(j = 0; j < 3; j++) { function2(); } for(j = 0; j < 3; j++) { function3(); } } return 0; }
/** Cache J2000 rotation over existing cached time range using polynomials * * This method will reload an internal cache with matrices * formed from rotation angles fit to polynomials over a time * range. * * @param function1 The first polynomial function used to * find the rotation angles * @param function2 The second polynomial function used to * find the rotation angles * @param function3 The third polynomial function used to * find the rotation angles */ void LineScanCameraRotation::ReloadCache() { NaifStatus::CheckErrors(); // Make sure caches are already loaded if(!p_cachesLoaded) { QString msg = "A LineScanCameraRotation cache has not been loaded yet"; throw IException(IException::Programmer, msg, _FILEINFO_); } // Clear existing matrices from cache p_cache.clear(); // Create polynomials fit to angles & use to reload cache Isis::PolynomialUnivariate function1(p_degree); Isis::PolynomialUnivariate function2(p_degree); Isis::PolynomialUnivariate function3(p_degree); // Get the coefficients of the polynomials already fit to the angles of rotation defining [CI] std::vector<double> coeffAng1; std::vector<double> coeffAng2; std::vector<double> coeffAng3; GetPolynomial(coeffAng1, coeffAng2, coeffAng3); // Reset linear term to center around zero -- what works best is either roll-avg & pitchavg+ or pitchavg+ & yawavg- // coeffAng1[1] -= 0.0000158661225; // coeffAng2[1] = 0.0000308433; // coeffAng3[0] = -0.001517547; if(p_pitchRate) coeffAng2[1] = p_pitchRate; if(p_yaw) coeffAng3[0] = p_yaw; // Load the functions with the coefficients function1.SetCoefficients(coeffAng1); function2.SetCoefficients(coeffAng2); function3.SetCoefficients(coeffAng3); double CI[3][3]; double IJ[3][3]; std::vector<double> rtime; SpiceRotation *prot = p_spi->bodyRotation(); std::vector<double> CJ; CJ.resize(9); for(std::vector<double>::size_type pos = 0; pos < p_cacheTime.size(); pos++) { double et = p_cacheTime.at(pos); rtime.push_back((et - GetBaseTime()) / GetTimeScale()); double angle1 = function1.Evaluate(rtime); double angle2 = function2.Evaluate(rtime); double angle3 = function3.Evaluate(rtime); rtime.clear(); // Get the first angle back into the range Naif expects [180.,180.] if(angle1 < -1 * pi_c()) { angle1 += twopi_c(); } else if(angle1 > pi_c()) { angle1 -= twopi_c(); } eul2m_c((SpiceDouble) angle3, (SpiceDouble) angle2, (SpiceDouble) angle1, p_axis3, p_axis2, p_axis1, CI); mxm_c((SpiceDouble( *)[3]) & (p_jitter->SetEphemerisTimeHPF(et))[0], CI, CI); prot->SetEphemerisTime(et); mxm_c((SpiceDouble( *)[3]) & (p_cacheIB.at(pos))[0], (SpiceDouble( *)[3]) & (prot->Matrix())[0], IJ); mxm_c(CI, IJ, (SpiceDouble( *)[3]) &CJ[0]); p_cache.push_back(CJ); // J2000 to constant frame } // Set source to cache to get updated values SetSource(SpiceRotation::Memcache); // Make sure SetEphemerisTime updates the matrix by resetting it twice (in case the first one // matches the current et. p_et is private and not available from the child class NaifStatus::CheckErrors(); SetEphemerisTime(p_cacheTime[0]); SetEphemerisTime(p_cacheTime[1]); NaifStatus::CheckErrors(); }