static void* cons(Object*) { double* p; const char* s; if (hoc_is_pdouble_arg(1)) { p = hoc_pgetarg(1); s = "unknown"; }else{ s = gargstr(1); ParseTopLevel ptl; p = hoc_val_pointer(s); } if (!p) { hoc_execerror("Pointer constructor failed", 0); } OcPointer* ocp = new OcPointer(s, p); if (ifarg(2)) { ocp->sti_ = new StmtInfo(gargstr(2)); } return (void*)ocp; }
static void unpack_help(int i, OcBBS* bbs) { for (; ifarg(i); ++i) { if (hoc_is_pdouble_arg(i)) { *hoc_pgetarg(i) = bbs->upkdouble(); }else if (hoc_is_str_arg(i)) { char* s = bbs->upkstr(); char** ps = hoc_pgargstr(i); hoc_assign_str(ps, s); delete [] s; }else if (is_vector_arg(i)){ Vect* vec = vector_arg(i); int n = bbs->upkint(); vec->resize(n); bbs->upkvec(n, vec->vec()); }else{ hoc_execerror("pc.unpack can only unpack str, scalar, or Vector.", "use pc.upkpyobj to unpack a Python Object"); } } }
void fit_praxis(void) { extern Symbol* hoc_lookup(); extern char* gargstr(); char* after_quad; int i; double err, fmin; double* px; /* allow nested calls to fit_praxis. I.e. store all the needed statics specific to this invocation with proper reference counting and then unref/destoy on exit from this invocation. Before the prax call save the statics from earlier invocation without increasing the ref count and on exit restore without decreasing the ref count. */ /* save before setting statics, restore after prax */ double minerrsav, *minargsav, maxstepsizesav, tolerancesav; long int printmodesav, nvarsav; Symbol* efun_sym_sav; Object* efun_py_save, *efun_py_arg_save; void* vec_py_save_save; /* store statics specified by this invocation */ /* will be copied just before calling prax */ double minerr_, *minarg_; long int nvar_; Symbol* efun_sym_; Object* efun_py_, *efun_py_arg_; void* vec_py_save_; minerr_ = 0.0; nvar_ = 0; minarg_ = NULL; efun_sym_ = NULL; efun_py_ = NULL; efun_py_arg_ = NULL; vec_py_save_ = NULL; fmin = 0.; if (hoc_is_object_arg(1)) { assert(nrnpy_praxis_efun); efun_py_ = *hoc_objgetarg(1); hoc_obj_ref(efun_py_); efun_py_arg_ = *vector_pobj(vector_arg(2)); hoc_obj_ref(efun_py_arg_); vec_py_save_ = vector_new2(efun_py_arg_->u.this_pointer); nvar_ = vector_capacity(vec_py_save_); px = vector_vec(vec_py_save_); }else{ nvar_ = (int)chkarg(1, 0., 1e6); efun_sym_ = hoc_lookup(gargstr(2)); if (!efun_sym_ || (efun_sym_->type != FUNCTION && efun_sym_->type != FUN_BLTIN)) { hoc_execerror(gargstr(2), "not a function name"); } if (!hoc_is_pdouble_arg(3)) { void* vec = vector_arg(3); if (vector_capacity(vec) != nvar_) { hoc_execerror("first arg not equal to size of Vector",0); } px = vector_vec(vec); }else{ px = hoc_pgetarg(3); } } minarg_ = (double*)ecalloc(nvar_, sizeof(double)); if (maxstepsize == 0.) { hoc_execerror("call attr_praxis first to set attributes", 0); } machep = 1e-15; if (ifarg(4)) { after_quad = gargstr(4); }else{ after_quad = (char*)0; } /* save the values set by earlier invocation */ minerrsav = minerr; minargsav = minarg; tolerancesav = tolerance; maxstepsizesav = maxstepsize; printmodesav = printmode; nvarsav = nvar; efun_sym_sav = hoc_efun_sym; efun_py_save = efun_py; efun_py_arg_save = efun_py_arg; vec_py_save_save = vec_py_save; /* copy this invocation values to the statics */ minerr = minerr_; minarg = minarg_; nvar = nvar_; hoc_efun_sym = efun_sym_; efun_py = efun_py_; efun_py_arg = efun_py_arg_; vec_py_save = vec_py_save_; minerr=1e9; err = praxis(&tolerance, &machep, &maxstepsize, nvar, &printmode, px, efun, &fmin, after_quad); err = minerr; if (minerr < 1e9) { for (i=0; i<nvar; ++i) { px[i] = minarg[i]; } } /* restore the values set by earlier invocation */ minerr = minerrsav; minarg = minargsav; tolerance = tolerancesav; maxstepsize = maxstepsizesav; printmode = printmodesav; nvar = nvar_; /* in case one calls prax_pval */ hoc_efun_sym = efun_sym_sav; efun_py = efun_py_save; efun_py_arg = efun_py_arg_save; vec_py_save = vec_py_save_save; if (efun_py_) { double* px = vector_vec(efun_py_arg_->u.this_pointer); for (i=0; i < nvar_; ++i) { px[i] = minarg_[i]; } hoc_obj_unref(efun_py_); hoc_obj_unref(efun_py_arg_); vector_delete(vec_py_save_); } if (minarg_) { free(minarg_); } hoc_retpushx(err); }