static struct demangle_component * unqualified_name_from_comp (struct demangle_component *comp) { struct demangle_component *ret_comp = comp, *last_template; int done; done = 0; last_template = NULL; while (!done) switch (ret_comp->type) { case DEMANGLE_COMPONENT_QUAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME: ret_comp = d_right (ret_comp); break; case DEMANGLE_COMPONENT_TYPED_NAME: ret_comp = d_left (ret_comp); break; case DEMANGLE_COMPONENT_TEMPLATE: gdb_assert (last_template == NULL); last_template = ret_comp; ret_comp = d_left (ret_comp); break; case DEMANGLE_COMPONENT_CONST: case DEMANGLE_COMPONENT_RESTRICT: case DEMANGLE_COMPONENT_VOLATILE: case DEMANGLE_COMPONENT_CONST_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS: case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: ret_comp = d_left (ret_comp); break; case DEMANGLE_COMPONENT_NAME: case DEMANGLE_COMPONENT_CTOR: case DEMANGLE_COMPONENT_DTOR: case DEMANGLE_COMPONENT_OPERATOR: case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: done = 1; break; default: return NULL; break; } if (last_template) { d_left (last_template) = ret_comp; return last_template; } return ret_comp; }
int main(int argc, char **argv) { FILE *fp = fopen("new.dat", "r"); int xmax, ymax; int **data; load_max(fp, &xmax, &ymax); data = (int**) malloc(xmax * sizeof(int*)); for (int x = 0; x < xmax; x++) { data[x] = calloc(ymax, sizeof(int)); } load_data(fp, xmax, ymax, data); int max = 0; for (int x = 0; x < xmax; x++) { #pragma omp parallel for for (int y = 0; y < ymax; y++) { // check up, down, left, right, down_diag left, down_diag right int values[5]; values[0] = up(data,x,y,xmax,ymax); values[1] = down(data,x,y,xmax,ymax); values[2] = left(data,x,y,xmax,ymax); values[3] = d_left(data,x,y,xmax,ymax); values[4] = d_right(data,x,y,xmax,ymax); int max_tmp = max_array(values, 5); if (max_tmp > max) { max = max_tmp; } } } printf("%d\n", max); free(data); return 0; }
char * cp_remove_params (const char *demangled_name) { int done = 0; struct demangle_component *ret_comp; char *ret = NULL; if (demangled_name == NULL) return NULL; ret_comp = cp_demangled_name_to_comp (demangled_name, NULL); if (ret_comp == NULL) return NULL; /* First strip off any qualifiers, if we have a function or method. */ while (!done) switch (ret_comp->type) { case DEMANGLE_COMPONENT_CONST: case DEMANGLE_COMPONENT_RESTRICT: case DEMANGLE_COMPONENT_VOLATILE: case DEMANGLE_COMPONENT_CONST_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS: case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: ret_comp = d_left (ret_comp); break; default: done = 1; break; } /* What we have now should be a function. Return its name. */ if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME) ret = cp_comp_to_string (d_left (ret_comp), 10); return ret; }
char * cp_class_name_from_physname (const char *physname) { void *storage = NULL; char *demangled_name = NULL, *ret; struct demangle_component *ret_comp, *prev_comp, *cur_comp; int done; ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage, &demangled_name); if (ret_comp == NULL) return NULL; done = 0; /* First strip off any qualifiers, if we have a function or method. */ while (!done) switch (ret_comp->type) { case DEMANGLE_COMPONENT_CONST: case DEMANGLE_COMPONENT_RESTRICT: case DEMANGLE_COMPONENT_VOLATILE: case DEMANGLE_COMPONENT_CONST_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS: case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: ret_comp = d_left (ret_comp); break; default: done = 1; break; } /* If what we have now is a function, discard the argument list. */ if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME) ret_comp = d_left (ret_comp); /* If what we have now is a template, strip off the template arguments. The left subtree may be a qualified name. */ if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE) ret_comp = d_left (ret_comp); /* What we have now should be a name, possibly qualified. Additional qualifiers could live in the left subtree or the right subtree. Find the last piece. */ done = 0; prev_comp = NULL; cur_comp = ret_comp; while (!done) switch (cur_comp->type) { case DEMANGLE_COMPONENT_QUAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME: prev_comp = cur_comp; cur_comp = d_right (cur_comp); break; case DEMANGLE_COMPONENT_TEMPLATE: case DEMANGLE_COMPONENT_NAME: case DEMANGLE_COMPONENT_CTOR: case DEMANGLE_COMPONENT_DTOR: case DEMANGLE_COMPONENT_OPERATOR: case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: done = 1; break; default: done = 1; cur_comp = NULL; break; } ret = NULL; if (cur_comp != NULL && prev_comp != NULL) { /* We want to discard the rightmost child of PREV_COMP. */ *prev_comp = *d_left (prev_comp); /* The ten is completely arbitrary; we don't have a good estimate. */ ret = cp_comp_to_string (ret_comp, 10); } xfree (storage); if (demangled_name) xfree (demangled_name); return ret; }
static int is_ctor_or_dtor (const char *mangled, enum gnu_v3_ctor_kinds *ctor_kind, enum gnu_v3_dtor_kinds *dtor_kind) { struct d_info di; struct demangle_component *dc; int ret; *ctor_kind = (enum gnu_v3_ctor_kinds) 0; *dtor_kind = (enum gnu_v3_dtor_kinds) 0; cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); { #ifdef CP_DYNAMIC_ARRAYS __extension__ struct demangle_component comps[di.num_comps]; __extension__ struct demangle_component *subs[di.num_subs]; di.comps = comps; di.subs = subs; #else di.comps = alloca (di.num_comps * sizeof (*di.comps)); di.subs = alloca (di.num_subs * sizeof (*di.subs)); #endif dc = cplus_demangle_mangled_name (&di, 1); /* Note that because we did not pass DMGL_PARAMS, we don't expect to demangle the entire string. */ ret = 0; while (dc != NULL) { switch (dc->type) { default: dc = NULL; break; case DEMANGLE_COMPONENT_TYPED_NAME: case DEMANGLE_COMPONENT_TEMPLATE: case DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS: case DEMANGLE_COMPONENT_CONST_THIS: dc = d_left (dc); break; case DEMANGLE_COMPONENT_QUAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME: dc = d_right (dc); break; case DEMANGLE_COMPONENT_CTOR: *ctor_kind = dc->u.s_ctor.kind; ret = 1; dc = NULL; break; case DEMANGLE_COMPONENT_DTOR: *dtor_kind = dc->u.s_dtor.kind; ret = 1; dc = NULL; break; } } } return ret; }
// Dimentionless Dichotomy solver Real Law2_ScGeom_ElectrostaticPhys::DL_DichoAdimExp_integrate_u(Real const& un, Real const& eps, Real const& alpha, Real const& Z, Real const& K, Real & prevDotU, Real const& dt, Real const& prev_d, Real const& undot) { Real F = 0.; Real d_left(prev_d-1.), d_right(prev_d+1.); Real F_left(ObjF(un, eps, alpha, prevDotU, dt, prev_d, undot, Z, K, d_left)); Real F_right(ObjF(un, eps, alpha, prevDotU, dt, prev_d, undot, Z, K, d_right)); Real d; // Init: search for interval that contain sign change Real inc = (F_left < 0.) ? 1. : -1; inc = (F_left < F_right) ? inc : -inc; while(F_left*F_right >= 0. && std::isfinite(F_left) && std::isfinite(F_right)) { d_left += inc; d_right += inc; F_left = ObjF(un, eps, alpha, prevDotU, dt, prev_d, undot, Z, K, d_left); F_right = ObjF(un, eps, alpha, prevDotU, dt, prev_d, undot, Z, K, d_right); } if((!std::isfinite(F_left) || !std::isfinite(F_right))) { if(debug) LOG_WARN("Wrong direction"); inc = -inc; // RE-INIT d_left = prev_d-1.; d_right = prev_d+1.; while(F_left*F_right >= 0. && std::isfinite(F_left) && std::isfinite(F_right)) { d_left += inc; d_right += inc; F_left = ObjF(un, eps, alpha, prevDotU, dt, prev_d, undot, Z, K, d_left); F_right = ObjF(un, eps, alpha, prevDotU, dt, prev_d, undot, Z, K, d_right); } } if((!std::isfinite(F_left) || !std::isfinite(F_right))) LOG_ERROR("Initial point problem!! d_left=" << d_left << " F_left=" << F_left << " d_right=" << d_right << " F_right=" << F_right); // Iterate to find the zero. int i; for(i=0;i<MaxIter;i++) { if(F_left*F_right > 0.) LOG_ERROR("Both function have same sign!! d_left=" << d_left << " F_left=" << F_left << " d_right=" << d_right << " F_right=" << F_right); //d = (d_left + d_right)/2.; // Dichotomy d = d_left - F_left*(d_right - d_left)/(F_right - F_left); // Regula Falsi F = ObjF(un, eps, alpha, prevDotU, dt, prev_d, undot, Z, K, d); if(std::abs(F) < SolutionTol) break; if(F*F_left < 0.) { F_right = F; d_right = d; } else { F_left = F; d_left = d; } } if(i == MaxIter) LOG_WARN("Max iteration reach: d_left=" << d_left << " F_left=" << F_left << " d_right=" << d_right << " F_right=" << F_right); Real a = (std::exp(d) < eps) ? alpha : 0.; prevDotU = -(1.+a)*std::exp(d) + a*eps + un + Z*K*std::exp(-K*std::exp(d)); return d; }