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);
}
