/* :nodoc: */ static VALUE generator_initialize(int argc, VALUE *argv, VALUE obj) { VALUE proc; if (argc == 0) { rb_need_block(); proc = rb_block_proc(); } else { rb_scan_args(argc, argv, "1", &proc); if (!rb_obj_is_proc(proc)) rb_raise(rb_eTypeError, "wrong argument type %s (expected Proc)", rb_obj_classname(proc)); if (rb_block_given_p()) { rb_warn("given block not used"); } } return generator_init(obj, proc); }
/* * call-seq: * Enumerator.new(size = nil) { |yielder| ... } * Enumerator.new(obj, method = :each, *args) * * Creates a new Enumerator object, which can be used as an * Enumerable. * * In the first form, iteration is defined by the given block, in * which a "yielder" object, given as block parameter, can be used to * yield a value by calling the +yield+ method (aliased as +<<+): * * fib = Enumerator.new do |y| * a = b = 1 * loop do * y << a * a, b = b, a + b * end * end * * p fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] * * The optional parameter can be used to specify how to calculate the size * in a lazy fashion (see Enumerator#size). It can either be a value or * a callable object. * * In the second, deprecated, form, a generated Enumerator iterates over the * given object using the given method with the given arguments passed. * * Use of this form is discouraged. Use Kernel#enum_for or Kernel#to_enum * instead. * * e = Enumerator.new(ObjectSpace, :each_object) * #-> ObjectSpace.enum_for(:each_object) * * e.select { |obj| obj.is_a?(Class) } #=> array of all classes * */ static VALUE enumerator_initialize(int argc, VALUE *argv, VALUE obj) { VALUE recv, meth = sym_each; VALUE size = Qnil; if (rb_block_given_p()) { rb_check_arity(argc, 0, 1); recv = generator_init(generator_allocate(rb_cGenerator), rb_block_proc()); if (argc) { if (NIL_P(argv[0]) || rb_obj_is_proc(argv[0]) || (RB_TYPE_P(argv[0], T_FLOAT) && RFLOAT_VALUE(argv[0]) == INFINITY)) { size = argv[0]; } else { size = rb_to_int(argv[0]); } argc = 0; } } else { rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); rb_warn("Enumerator.new without a block is deprecated; use Object#to_enum"); recv = *argv++; if (--argc) { meth = *argv++; --argc; } } return enumerator_init(obj, recv, meth, argc, argv, 0, size); }
int main(void) { e_iap_status iap_status; /* Fill the flash with payload and hash data */ iap_status = (e_iap_status) generator_init(); if (iap_status != CMD_SUCCESS) while (1) ; // Error !!! Details d; initButton(); initDMA(); initDetails(&d, getNumberOfChunks(), getSizeOfChunk()); while (buttonIterrupt) { } int res = mainFunction(&d, 32); if(res==0) { blinkLed(1000000); } else { blinkLed(100); } return 0; }
int main(int argc, char* argv[]) { int option, option_idx; int worker_id = 0; int datacenter_id = 0; int port = 7954; while ((option = getopt_long(argc, argv, "w:d:p:", options, &option_idx)) != -1) { switch (option) { case 'w': worker_id = atoi(optarg); break; case 'd': datacenter_id = atoi(optarg); break; case 'p': port = atoi(optarg); break; case 'h': case '?': printf(help); exit(EXIT_FAILURE); break; } } Context ctx = generator_init(worker_id, datacenter_id); server_serve(ctx, port); return 0; }
int RSECC_encode(int data_length, int ecc_length, const unsigned char *data, unsigned char *ecc) { int i, j; unsigned char feedback; unsigned char *gen; if(!initialized) { RSECC_init(); } if(ecc_length > max_length) return -1; memset(ecc, 0, ecc_length); if(!generatorInitialized[ecc_length - min_length]) generator_init(ecc_length); gen = generator[ecc_length - min_length]; for(i = 0; i < data_length; i++) { feedback = aindex[data[i] ^ ecc[0]]; if(feedback != symbols) { for(j = 1; j < ecc_length; j++) { ecc[j] ^= alpha[(feedback + gen[ecc_length - j]) % symbols]; } } memmove(&ecc[0], &ecc[1], ecc_length - 1); if(feedback != symbols) { ecc[ecc_length - 1] = alpha[(feedback + gen[0]) % symbols]; } else { ecc[ecc_length - 1] = 0; } } return 0; }
void generator_writer_c_init(generator_writer_c_t *self, const symbols_t *symbols) { generator_init(&self->super, symbols); self->super.on_document_begin = on_document_begin; self->super.on_document_end = on_document_end; self->super.on_definition = on_definition; }
/* * statext_ndistinct_build * Compute ndistinct coefficient for the combination of attributes. * * This computes the ndistinct estimate using the same estimator used * in analyze.c and then computes the coefficient. */ MVNDistinct * statext_ndistinct_build(double totalrows, int numrows, HeapTuple *rows, Bitmapset *attrs, VacAttrStats **stats) { MVNDistinct *result; int k; int itemcnt; int numattrs = bms_num_members(attrs); int numcombs = num_combinations(numattrs); result = palloc(offsetof(MVNDistinct, items) + numcombs * sizeof(MVNDistinctItem)); result->magic = STATS_NDISTINCT_MAGIC; result->type = STATS_NDISTINCT_TYPE_BASIC; result->nitems = numcombs; itemcnt = 0; for (k = 2; k <= numattrs; k++) { int *combination; CombinationGenerator *generator; /* generate combinations of K out of N elements */ generator = generator_init(numattrs, k); while ((combination = generator_next(generator))) { MVNDistinctItem *item = &result->items[itemcnt]; int j; item->attrs = NULL; for (j = 0; j < k; j++) item->attrs = bms_add_member(item->attrs, stats[combination[j]]->attr->attnum); item->ndistinct = ndistinct_for_combination(totalrows, numrows, rows, stats, k, combination); itemcnt++; Assert(itemcnt <= result->nitems); } generator_free(generator); } /* must consume exactly the whole output array */ Assert(itemcnt == result->nitems); return result; }
int cmd_parse_expr(FILE *file, const char *filename, const char *cmd) { log_set_unit(basename(filename)); lexer_init(file); parser_init(); generator_init(); struct node* node = NULL; symtable_t symtable = NULL; code_t code = NULL; if (strcmp(cmd, "parse_expr") == 0) { parser_flags_set(0); node = parser_parse_expr(); print_node(node, 0, 0); } else if (strcmp(cmd, "parse_stmt") == 0) { parser_flags_set(0); node = parser_parse_statement(); print_node(node, 0, 0); } else if (strcmp(cmd, "parse") == 0) { parser_flags_set(PF_RESOLVE_NAMES); symtable = parser_parse(); print_symtable(symtable, 0); } else if (strcmp(cmd, "compile") == 0) { symtable = parser_parse(); if (symtable != NULL) { code = generator_process(symtable); optimizer_optimize(code); generator_print_code(code); } else { print_symtable(symtable, 0); } } parser_free_node(node); symtable_destroy(symtable, 1); generator_free_code(code); generator_destroy(); parser_destroy(); lexer_destroy(); log_close(); return EXIT_SUCCESS; }
/* * call-seq: * Enumerator.new(obj, method = :each, *args) * Enumerator.new { |y| ... } * * Creates a new Enumerator object, which is to be used as an * Enumerable object iterating in a given way. * * In the first form, a generated Enumerator iterates over the given * object using the given method with the given arguments passed. * Use of this form is discouraged. Use Kernel#enum_for(), alias * to_enum, instead. * * e = Enumerator.new(ObjectSpace, :each_object) * #-> ObjectSpace.enum_for(:each_object) * * e.select { |obj| obj.is_a?(Class) } #=> array of all classes * * In the second form, iteration is defined by the given block, in * which a "yielder" object given as block parameter can be used to * yield a value by calling the +yield+ method, alias +<<+. * * fib = Enumerator.new { |y| * a = b = 1 * loop { * y << a * a, b = b, a + b * } * } * * p fib.take(10) #=> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] */ static VALUE enumerator_initialize(int argc, VALUE *argv, VALUE obj) { VALUE recv, meth = sym_each; if (argc == 0) { if (!rb_block_given_p()) rb_raise(rb_eArgError, "wrong number of argument (0 for 1+)"); recv = generator_init(generator_allocate(rb_cGenerator), rb_block_proc()); } else { recv = *argv++; if (--argc) { meth = *argv++; --argc; } } return enumerator_init(obj, recv, meth, argc, argv); }
/* * call-seq: * Enumerator.new { |yielder| ... } * Enumerator.new(obj, method = :each, *args) * * Creates a new Enumerator object, which can be used as an * Enumerable. * * In the first form, iteration is defined by the given block, in * which a "yielder" object, given as block parameter, can be used to * yield a value by calling the +yield+ method (aliased as +<<+): * * fib = Enumerator.new do |y| * a = b = 1 * loop do * y << a * a, b = b, a + b * end * end * * p fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] * * The block form can be used to create a lazy enumeration that only processes * elements as-needed. The generic pattern for this is: * * Enumerator.new do |yielder| * source.each do |source_item| * # process source_item and append the yielder * end * end * * This can be used with infinite streams to support multiple chains: * * class Fib * def initialize(a = 1, b = 1) * @a, @b = a, b * end * * def each * a, b = @a, @b * yield a * while true * yield b * a, b = b, a+b * end * end * end * * def lazy_select enum * Enumerator.new do |y| * enum.each do |e| * y << e if yield e * end * end * end * * def lazy_map enum * Enumerator.new do |y| * enum.each do |e| * y << yield(e) * end * end * end * * even_fibs = lazy_select(Fibs.new) { |x| x % 2 == 0 } * string_fibs = lazy_map(even_fibs) { |x| "<#{x}>" } * string_fibs.each_with_index do |fib, i| * puts "#{i}: #{fib}" * break if i >= 3 * end * * This allows output even though the Fib produces an infinite sequence of * Fibonacci numbers: * * 0: <2> * 1: <8> * 2: <34> * 3: <144> * * In the second, deprecated, form, a generated Enumerator iterates over the * given object using the given method with the given arguments passed. * * Use of this form is discouraged. Use Kernel#enum_for or Kernel#to_enum * instead. * * e = Enumerator.new(ObjectSpace, :each_object) * #-> ObjectSpace.enum_for(:each_object) * * e.select { |obj| obj.is_a?(Class) } #=> array of all classes * */ static VALUE enumerator_initialize(int argc, VALUE *argv, VALUE obj) { VALUE recv, meth = sym_each; if (argc == 0) { if (!rb_block_given_p()) rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); recv = generator_init(generator_allocate(rb_cGenerator), rb_block_proc()); } else { recv = *argv++; if (--argc) { meth = *argv++; --argc; } } return enumerator_init(obj, recv, meth, argc, argv); }
void init_all() { // Field Initialisation: Kfield_init(); // Curve Initialisation: curve_init(); // Generator Initalisation: generator_init(); // Order of the subgroup: mpz_init_set_str(p, "53919893334301279666889509884200806281039951735555151719046432375393",10); size_of_p = mpz_sizeinbase(p,2); // Initialisation of global dummys: int i; for(i = 0; i < NUMBER_OF_DUMMYELTS; i++) { Kinit(&(dummyelts[i])); } }
/* * call-seq: * Enumerator.new(obj, method = :each, *args) * Enumerator.new { |y| ... } * * Creates a new Enumerator object, which is to be used as an * Enumerable object iterating in a given way. * * In the first form, a generated Enumerator iterates over the given * object using the given method with the given arguments passed. * Use of this form is discouraged. Use Kernel#enum_for(), alias * to_enum, instead. * * e = Enumerator.new(ObjectSpace, :each_object) * #-> ObjectSpace.enum_for(:each_object) * * e.select { |obj| obj.is_a?(Class) } #=> array of all classes * * In the second form, iteration is defined by the given block, in * which a "yielder" object given as block parameter can be used to * yield a value by calling the +yield+ method, alias +<<+. * * fib = Enumerator.new { |y| * a = b = 1 * loop { * y << a * a, b = b, a + b * } * } * * p fib.take(10) #=> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] */ static VALUE enumerator_initialize(VALUE obj, SEL sel, int argc, VALUE *argv) { VALUE recv, meth = sym_each; if (argc == 0) { if (!rb_block_given_p()) rb_raise(rb_eArgError, "wrong number of argument (0 for 1+)"); recv = generator_init(generator_allocate(rb_cGenerator, 0), rb_block_proc()); } else { recv = *argv++; if (--argc) { meth = *argv++; --argc; } } ID meth_id = rb_to_id(meth); SEL meth_sel = rb_vm_id_to_sel(meth_id, argc); return enumerator_init(obj, recv, meth_sel, argc, argv); }
int main(void) { uint32_t x = 0; uint32_t y = 0; RCC_DeInit(); RCC_HSEConfig(RCC_HSE_ON); if(RCC_WaitForHSEStartUp() == SUCCESS) { RCC_HCLKConfig(RCC_SYSCLK_Div1); RCC_PCLKConfig(RCC_HCLK_Div1); RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_8); RCC_PLLCmd(ENABLE); while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET); RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); while(RCC_GetSYSCLKSource() != 0x08); } generator_init(); generator_start(); delay_init(); lcd_init(); lcd_clear(); lcd_dma_start(); for (x=0;x<50;x++) { while (lcd_is_busy()); lcd_noise(); lcd_dma_start(); } while (lcd_is_busy()); for (x=0;x<patternWidthPages*patternHeightPixels;x++) lcd_buf[x] = patternBitmaps[x]; print(1,0,"PLEASE",6); print(0,7,"STAND_BY",8); while (lcd_is_busy()); lcd_dma_start(); delay_ms(20000); for (x=0;x<patternWidthPages*patternHeightPixels;x++) lcd_buf[x] = patternBitmaps[x]; for (x=9;x>0;x--) { putchar_big(3,3,'0'+x); while (lcd_is_busy()); lcd_dma_start(); delay_ms(3000); } lcd_clear(); print(1,1,"URGENT",6); print(0,6,"MESSAGE!",8); while (lcd_is_busy()); lcd_dma_start(); delay_ms(3000); scroll_text(MESSAGE); delay_ms(3000); lcd_clear(); print(1,1,"THAT'S",6); print(3,3,"ALL",3); print(1,5,"FOLKS!",6); while (lcd_is_busy()); lcd_dma_start(); delay_ms(100000); for (x=0;x<10000;x++) { while (lcd_is_busy()); lcd_noise(); lcd_dma_start(); } lcd_clear(); while (lcd_is_busy()); lcd_dma_start(); scroll_text(SECRET_MESSAGE); while(1) //Infinite loop! { while (lcd_is_busy()); lcd_noise(); lcd_dma_start(); } }
int main (void){ cli(); // debug DDRB |= (1<<DEBUG_LED_PIN); debug_init(); // push button DDRD |= (1<<BUTTON_PWR_PIN); PORTD |= (1<<BUTTON_PWR_PIN); DDRD &= ~(1<<BUTTON_PIN); PORTD |= (1<<BUTTON_PIN); uint8_t button_press_counter; // init sequence_init(); generator_init(); sequence_update(0); sequence_runmode = SEQ_RUNMODE_SEQUENTIAL; generator_update(); uint16_t frame_counter; uint8_t seed=0; _delay_ms(10); // Global interrupt enable. sei(); while(1) { srand(seed++); // the refresh rate depends on the driver rate if(pwm_packet_counter>20){ pwm_packet_counter = 0; generator_run(); DEBUG_LED_PIN_TOGGLE(); if((frame_counter++ > 0x3FF)&&(sequence_runmode==SEQ_RUNMODE_TOGGLE)){ sequence_skip(); generator_update(); frame_counter = 0; } } // serial cmd received if(debug_char != 0xFF){ sequence_update(debug_char); generator_update(); debug_char = 0xFF; } // push button if((PIND&(1<<BUTTON_PIN)) == 0){ button_press_counter = 0; // measure the button press duration while((PIND&(1<<BUTTON_PIN)) == 0){ _delay_ms(100); button_press_counter++; } // short press => next sequence if (button_press_counter < 10){ frame_counter = 0; sequence_skip(); generator_update(); // debug_putc('d'); // skip sequence } // long press => switch between normal and sequential mode else{ frame_counter = 0; sequence_runmode ^= SEQ_RUNMODE_TOGGLE; // debug_putc('c'); // switch normal(current sequence)<->sequential } } } }