TEST(GameState, make_step) { EXPECT_TRUE(make_step("Rb1n").is_motion()); EXPECT_TRUE(make_step("rb1n").is_motion()); EXPECT_TRUE(make_step("eb8").is_placement()); EXPECT_TRUE(make_step("dc3x").is_capture()); EXPECT_FALSE(make_step("qc5x").is_valid()); }
void bs(int n, int height, int i, int fd, int sem_id){ if (n == 2){ make_step(3, height, 1, fd, sem_id); }else if (n >= 4){ make_step(2, height, i, fd, sem_id); bs(n/2, height, i*2, fd, sem_id); }else{ printf("Error bs!\n"); exit(0); } }
int line_step_tick(void) { // Make step double len = make_step(); // Check if we have reached the end if (len <= 0) { current_state.is_moving = 0; def.line_finished(); return -1; } // Check for endstops if (current_plan->check_break && current_plan->check_break(current_plan->s, current_plan->check_break_data)) { current_state.is_moving = 0; def.line_error(); return -1; } /* Calculating delay */ int step_delay = feed2delay(current_state.acc.feed, current_plan->len / current_plan->steps); acceleration_process(¤t_state.acc, step_delay); return step_delay; }
static VALUE rb_gsl_odeiv_step_new(int argc, VALUE *argv, VALUE klass) { VALUE obj; gsl_odeiv_step *s = NULL; switch (argc) { case 1: CHECK_FIXNUM(argv[0]); s = make_step(INT2FIX(GSL_ODEIV_STEP_RKF45), argv[0]); break; case 2: CHECK_FIXNUM(argv[1]); s = make_step(argv[0], argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } obj = Data_Wrap_Struct(klass, 0, gsl_odeiv_step_free, s); return obj; }
static void wildcard_name(parser_context *context) { enter_state(context, ST_WILDCARD_NAME_TEST); step *current = make_step(context->current_step_kind, WILDCARD_TEST); if(NULL == current) { context->result.code = ERR_PARSER_OUT_OF_MEMORY; return; } push_step(context, current); consume_char(context); context->result.code = JSONPATH_SUCCESS; }
static void name_test(parser_context *context) { enter_state(context, ST_NAME_TEST); if('*' == get_char(context)) { wildcard_name(context); return; } step *current = make_step(context->current_step_kind, NAME_TEST); if(NULL == current) { context->result.code = ERR_PARSER_OUT_OF_MEMORY; return; } push_step(context, current); context->result.code = JSONPATH_SUCCESS; name(context, current); }
static void node_type_test(parser_context *context) { enter_state(context, ST_NODE_TYPE_TEST); step *current = make_step(context->current_step_kind, TYPE_TEST); if(NULL == current) { context->result.code = ERR_PARSER_OUT_OF_MEMORY; return; } push_step(context, current); size_t offset = context->cursor; while(offset < context->length) { if('(' == context->input[offset]) { break; } offset++; } size_t length = offset - context->cursor; if(0 == length) { context->result.code = ERR_EXPECTED_NODE_TYPE_TEST; return; } int32_t kind = node_type_test_value(context, length); if(-1 == kind) { context->result.code = ERR_EXPECTED_NODE_TYPE_TEST; return; } current->test.type = (enum type_test_kind)kind; consume_chars(context, length); context->result.code = JSONPATH_SUCCESS; }
static VALUE rb_gsl_odeiv_solver_new(int argc, VALUE *argv, VALUE klass) { gsl_odeiv_solver *gos = NULL; VALUE epsabs, epsrel, ay, adydt; VALUE dim; if (argc < 4) rb_raise(rb_eArgError, "too few arguments"); Check_Type(argv[1], T_ARRAY); CHECK_PROC(argv[2]); if (rb_obj_is_kind_of(argv[3], rb_cProc) || NIL_P(argv[3])) { dim = argv[4]; } else { dim = argv[3]; } gos = ALLOC(gsl_odeiv_solver); gos->s = make_step(argv[0], dim); // switch (RARRAY(argv[1])->len) { switch (RARRAY_LEN(argv[1])) { case 2: epsabs = rb_ary_entry(argv[1], 0); epsrel = rb_ary_entry(argv[1], 1); gos->c = make_control_y(epsabs, epsrel); break; case 4: epsabs = rb_ary_entry(argv[1], 0); epsrel = rb_ary_entry(argv[1], 1); ay = rb_ary_entry(argv[1], 2); adydt = rb_ary_entry(argv[1], 3); gos->c = make_control_standard(epsabs, epsrel, ay, adydt); break; default: rb_raise(rb_eArgError, "size of the argument 1 must be 2 or 4"); break; } gos->sys = make_sys(argc - 2, argv + 2); gos->e = make_evolve(dim); return Data_Wrap_Struct(klass, gsl_odeiv_solver_mark, rb_gsl_odeiv_solver_free, gos); // return Data_Wrap_Struct(klass, 0, rb_gsl_odeiv_solver_free, gos); }
static sllv_t* mapper_step_process(lrec_t* pinrec, context_t* pctx, void* pvstate) { mapper_step_state_t* pstate = pvstate; if (pinrec == NULL) return sllv_single(NULL); // ["s", "t"] slls_t* pvalue_field_values = mlr_selected_values_from_record(pinrec, pstate->pvalue_field_names); slls_t* pgroup_by_field_values = mlr_selected_values_from_record(pinrec, pstate->pgroup_by_field_names); if (pgroup_by_field_values->length != pstate->pgroup_by_field_names->length) { lrec_free(pinrec); return NULL; } lhmsv_t* group_to_acc_field = lhmslv_get(pstate->groups, pgroup_by_field_values); if (group_to_acc_field == NULL) { group_to_acc_field = lhmsv_alloc(); lhmslv_put(pstate->groups, slls_copy(pgroup_by_field_values), group_to_acc_field); } sllse_t* pa = pstate->pvalue_field_names->phead; sllse_t* pb = pvalue_field_values->phead; // for x=1 and y=2 for ( ; pa != NULL && pb != NULL; pa = pa->pnext, pb = pb->pnext) { char* value_field_name = pa->value; char* value_field_sval = pb->value; int have_dval = FALSE; double value_field_dval = -999.0; lhmsv_t* acc_field_to_acc_state = lhmsv_get(group_to_acc_field, value_field_name); if (acc_field_to_acc_state == NULL) { acc_field_to_acc_state = lhmsv_alloc(); lhmsv_put(group_to_acc_field, value_field_name, acc_field_to_acc_state); } // for "delta", "rsum" sllse_t* pc = pstate->pstepper_names->phead; for ( ; pc != NULL; pc = pc->pnext) { char* step_name = pc->value; step_t* pstep = lhmsv_get(acc_field_to_acc_state, step_name); if (pstep == NULL) { pstep = make_step(step_name, value_field_name); if (pstep == NULL) { fprintf(stderr, "mlr step: stepper \"%s\" not found.\n", step_name); exit(1); } lhmsv_put(acc_field_to_acc_state, step_name, pstep); } if (pstep->psprocess_func != NULL) { pstep->psprocess_func(pstep->pvstate, value_field_sval, pinrec); } if (pstep->pdprocess_func != NULL) { if (!have_dval) { value_field_dval = mlr_double_from_string_or_die(value_field_sval); have_dval = TRUE; } pstep->pdprocess_func(pstep->pvstate, value_field_dval, pinrec); } } } return sllv_single(pinrec); }
static int ipm_main(struct csa *csa) { int m = csa->m; int n = csa->n; int i, j, status; double temp; /* choose initial point using Mehrotra's heuristic */ if (csa->parm->msg_lev >= GLP_MSG_ALL) xprintf("Guessing initial point...\n"); initial_point(csa); /* main loop starts here */ if (csa->parm->msg_lev >= GLP_MSG_ALL) xprintf("Optimization begins...\n"); for (;;) { /* perform basic computations at the current point */ basic_info(csa); /* save initial value of rmu */ if (csa->iter == 0) csa->rmu0 = csa->rmu; /* accumulate values of min(phi[k]) and save the best point */ xassert(csa->iter <= ITER_MAX); if (csa->iter == 0 || csa->phi_min[csa->iter-1] > csa->phi) { csa->phi_min[csa->iter] = csa->phi; csa->best_iter = csa->iter; for (j = 1; j <= n; j++) csa->best_x[j] = csa->x[j]; for (i = 1; i <= m; i++) csa->best_y[i] = csa->y[i]; for (j = 1; j <= n; j++) csa->best_z[j] = csa->z[j]; csa->best_obj = csa->obj; } else csa->phi_min[csa->iter] = csa->phi_min[csa->iter-1]; /* display information at the current point */ if (csa->parm->msg_lev >= GLP_MSG_ON) xprintf("%3d: obj = %17.9e; rpi = %8.1e; rdi = %8.1e; gap =" " %8.1e\n", csa->iter, csa->obj, csa->rpi, csa->rdi, csa->gap); /* check if the current point is optimal */ if (csa->rpi < 1e-8 && csa->rdi < 1e-8 && csa->gap < 1e-8) { if (csa->parm->msg_lev >= GLP_MSG_ALL) xprintf("OPTIMAL SOLUTION FOUND\n"); status = 0; break; } /* check if the problem has no feasible solution */ temp = 1e5 * csa->phi_min[csa->iter]; if (temp < 1e-8) temp = 1e-8; if (csa->phi >= temp) { if (csa->parm->msg_lev >= GLP_MSG_ALL) xprintf("PROBLEM HAS NO FEASIBLE PRIMAL/DUAL SOLUTION\n") ; status = 1; break; } /* check for very slow convergence or divergence */ if (((csa->rpi >= 1e-8 || csa->rdi >= 1e-8) && csa->rmu / csa->rmu0 >= 1e6) || (csa->iter >= 30 && csa->phi_min[csa->iter] >= 0.5 * csa->phi_min[csa->iter - 30])) { if (csa->parm->msg_lev >= GLP_MSG_ALL) xprintf("NO CONVERGENCE; SEARCH TERMINATED\n"); status = 2; break; } /* check for maximal number of iterations */ if (csa->iter == ITER_MAX) { if (csa->parm->msg_lev >= GLP_MSG_ALL) xprintf("ITERATION LIMIT EXCEEDED; SEARCH TERMINATED\n"); status = 3; break; } /* start the next iteration */ csa->iter++; /* factorize normal equation system */ for (j = 1; j <= n; j++) csa->D[j] = csa->x[j] / csa->z[j]; decomp_NE(csa); /* compute the next point using Mehrotra's predictor-corrector technique */ if (make_step(csa)) { if (csa->parm->msg_lev >= GLP_MSG_ALL) xprintf("NUMERIC INSTABILITY; SEARCH TERMINATED\n"); status = 4; break; } } /* restore the best point */ if (status != 0) { for (j = 1; j <= n; j++) csa->x[j] = csa->best_x[j]; for (i = 1; i <= m; i++) csa->y[i] = csa->best_y[i]; for (j = 1; j <= n; j++) csa->z[j] = csa->best_z[j]; if (csa->parm->msg_lev >= GLP_MSG_ALL) xprintf("Best point %17.9e was reached on iteration %d\n", csa->best_obj, csa->best_iter); } /* return to the calling program */ return status; }
static step *make_root_step(void) { return make_step(ROOT, NAME_TEST); }