void PySimple1::getGap(double ylast, double dy, double dy_old) { // For stability in Closure spring, may limit "dy" step size to avoid // overshooting on the closing of this gap. // TGap_y = ylast + dy; if(TGap_y > TClose_yright) {dy = 0.75*(TClose_yright - ylast);} if(TGap_y < TClose_yleft) {dy = 0.75*(TClose_yleft - ylast);} // Limit "dy" step size if it is oscillating in sign and not shrinking // if(dy*dy_old < 0.0 && fabs(dy/dy_old) > 0.5) dy = -dy_old/2.0; // Combine the Drag and Closure elements in parallel, starting by // resetting TGap_y in case the step size was limited. // TGap_y = ylast + dy; getClosure(ylast,dy); getDrag(ylast,dy); TGap_p = TDrag_p + TClose_p; TGap_tang = TDrag_tang + TClose_tang; // Ensure that |p|<pmax. // if(fabs(TGap_p)>=pult) TGap_p =(TGap_p/fabs(TGap_p))*(1.0-PYtolerance)*pult; return; }
Lexeme *evalFuncCall(Lexeme *tree, Lexeme *env) { //printf("Eval func %s\n",displayLexeme(*tree)); Lexeme *closure = getClosure(tree,env); //printf("Closure: %s\n",displayLexeme(*closure)); if(strcmp(closure->type,BUILTIN) == 0) { //printf("Here1\n"); //printf("builtin: %s\n",closure->sval); return closure->builtin(cdr(tree),env); } //printf("eval prams\n"); Lexeme *params = getParams(closure); //printf("Eval args\n"); Lexeme *eargs = evalFuncArgs(cdr(tree),params,env); params = stripOparen(params); //displayTree(eargs,""); //printf("make scope\n"); Lexeme *newScope = extend(params,eargs,getDefScope(closure));; //printf("New scope for funcCall:\n"); //displayEnv(newScope); //printf("Closure bod:\n"); //displayTree(getBody(closure),""); //printf("Func call to %s fin\n",displayLexeme(*tree)); return eval(getBody(closure),newScope); }
void FuncScopeVariableEnvironment::flagStatic(CStrRef name, int64 hash) { if (!m_staticEnv) { void *closure = getClosure(); if (UNLIKELY(closure != NULL)) { // statics for closures live on a closure c_GeneratorClosure *typedClosure = (c_GeneratorClosure*) closure; m_staticEnv = &typedClosure->m_statics; } else { bool isContClosure = ParserBase::IsContinuationFromClosureName(m_func->name().c_str()); if (UNLIKELY(isContClosure)) { ObjectData *cont = getContinuation(); ASSERT(cont != NULL); c_GenericContinuation *typedCont = (c_GenericContinuation*) cont; m_staticEnv = &typedCont->m_statics; } else { m_staticEnv = m_func->getStaticVars(*this); } } } ASSERT(m_staticEnv != NULL); if (!m_staticEnv->exists(name)) { m_staticEnv->getVar(name, SgNormal) = m_func->getStaticValue(*this, name); } getVar(name, SgNormal).assignRef(m_staticEnv->getVar(name, SgNormal)); }
void QzSimple2::getGap(double zlast, double dz, double dz_old) { // For stability in Closure spring, limit "dz" step size to avoid // overshooting on the "closing" or "opening" of the gap. // if(zlast > 0.0 && (zlast + dz) < -QZtolerance) dz = -QZtolerance - zlast; if(zlast < 0.0 && (zlast + dz) > QZtolerance) dz = QZtolerance - zlast; TGap_z = zlast + dz; // Combine the Suction and Closure elements in parallel // getClosure(zlast,dz); getSuction(zlast,dz); TGap_Q = TSuction_Q + TClose_Q; TGap_tang = TSuction_tang + TClose_tang; return; }
/*************************************** * * * Evaluate * * * ***************************************/ COMB_EXPR *Evaluate(COMB_EXPR *expr, ST_TYPE *resultType) { V_INSTR *value = NULL; int machineOps = 0; CLOSURE *closure = NULL; COMB_EXPR *result = NULL; ST_TYPE *type = resultType; #if mcDebug printMsg(MSG, "Machine: Evaluating combinator expression..."); #endif if (expr->tag == CTT_CLOSURE) { closure = getClosure(expr->info.closure); V = closure->clo->info.closure.v; PC = closure->clo->info.closure.c; A = closure->rec->info.recMacroFrame.frame; R1 = closure->rec; pushD1(DPcont); D1->info.code = &_HALT; machineOps = _Machine(&value); type = closure->type; } else { MachineReset(); PC = _CompileHalt(expr); machineOps = _Machine(&value); } #if mcDebug printf("Done\n"); #endif if (value) result = deCompile(value, type); else /* here we have a bang */ result = deCompile(_BANG, type); return(result); }