AnyType MatrixUpWind0::operator()(Stack stack) const { Matrice_Creuse<R> * sparce_mat =GetAny<Matrice_Creuse<R>* >((*emat)(stack)); MatriceMorse<R> * amorse =0; MeshPoint *mp(MeshPointStack(stack)) , mps=*mp; Mesh * pTh = GetAny<pmesh>((*expTh)(stack)); ffassert(pTh); Mesh & Th (*pTh); { map< pair<int,int>, R> Aij; KN<double> cc(Th.nv); double infini=DBL_MAX; cc=infini; for (int it=0;it<Th.nt;it++) for (int iv=0;iv<3;iv++) { int i=Th(it,iv); if ( cc[i]==infini) { // if nuset the set mp->setP(&Th,it,iv); cc[i]=GetAny<double>((*expc)(stack)); } } for (int k=0;k<Th.nt;k++) { const Triangle & K(Th[k]); const Vertex & A(K[0]), &B(K[1]),&C(K[2]); R2 Pt(1./3.,1./3.); R u[2]; MeshPointStack(stack)->set(Th,K(Pt),Pt,K,K.lab); u[0] = GetAny< R>( (*expu1)(stack) ) ; u[1] = GetAny< R>( (*expu2)(stack) ) ; int ii[3] ={ Th(A), Th(B),Th(C)}; double q[3][2]= { { A.x,A.y} ,{B.x,B.y},{C.x,C.y} } ; // coordinates of 3 vertices (input) double c[3]={cc[ii[0]],cc[ii[1]],cc[ii[2]]}; double a[3][3]; if (gladys(q,u,c,a) ) { for (int i=0;i<3;i++) for (int j=0;j<3;j++) if (fabs(a[i][j]) >= 1e-30) Aij[make_pair(ii[i],ii[j])]+=a[i][j]; } } amorse= new MatriceMorse<R>(Th.nv,Th.nv,Aij,false); } sparce_mat->Uh=UniqueffId(); sparce_mat->Vh=UniqueffId(); sparce_mat->A.master(amorse); sparce_mat->typemat=(amorse->n == amorse->m) ? TypeSolveMat(TypeSolveMat::GMRES) : TypeSolveMat(TypeSolveMat::NONESQUARE); // none square matrice (morse) *mp=mps; if(verbosity>3) { cout << " End Build MatrixUpWind : " << endl;} return sparce_mat; }
ZLE_INT_T vigetkey(void) { Keymap mn = openkeymap("main"); char m[3], *str; Thingy cmd; if (getbyte(0L, NULL) == EOF) return ZLEEOF; m[0] = lastchar; metafy(m, 1, META_NOALLOC); if(mn) cmd = keybind(mn, m, &str); else cmd = t_undefinedkey; if (!cmd || cmd == Th(z_sendbreak)) { return ZLEEOF; } else if (cmd == Th(z_quotedinsert)) { if (getfullchar(0) == ZLEEOF) return ZLEEOF; } else if(cmd == Th(z_viquotedinsert)) { ZLE_CHAR_T sav = zleline[zlecs]; zleline[zlecs] = '^'; zrefresh(); getfullchar(0); zleline[zlecs] = sav; if(LASTFULLCHAR == ZLEEOF) return ZLEEOF; } else if (cmd == Th(z_vicmdmode)) { return ZLEEOF; } #ifdef MULTIBYTE_SUPPORT if (!lastchar_wide_valid) { getrestchar(lastchar); } #endif return LASTFULLCHAR; }
AnyType MatrixUpWind3::operator()(Stack stack) const { Matrice_Creuse<R> * sparce_mat =GetAny<Matrice_Creuse<R>* >((*emat)(stack)); MatriceMorse<R> * amorse =0; MeshPoint *mp(MeshPointStack(stack)) , mps=*mp; Mesh3 * pTh = GetAny<pmesh3>((*expTh)(stack)); ffassert(pTh); Mesh3 & Th (*pTh); { map< pair<int,int>, R> Aij; KN<double> cc(Th.nv); double infini=DBL_MAX; cc=infini; for (int it=0;it<Th.nt;it++) for (int iv=0;iv<4;iv++) { int i=Th(it,iv); if ( cc[i]==infini) { // if nuset the set mp->setP(&Th,it,iv); cc[i]=GetAny<double>((*expc)(stack)); } } for (int k=0;k<Th.nt;k++) { const Mesh3::Element & K(Th[k]); const Mesh3::Vertex & A(K[0]), &B(K[1]),&C(K[2]),&D(K[3]); R3 Pt(1./4.,1./4.,1./4.); R3 U; MeshPointStack(stack)->set(Th,K(Pt),Pt,K,K.lab); U.x = GetAny< R>( (*expu1)(stack) ) ; U.y = GetAny< R>( (*expu2)(stack) ) ; U.z = GetAny< R>( (*expu3)(stack) ) ; int ii[4] ={ Th(A), Th(B),Th(C),Th(D)};// number of 4 vertex double c[4]={cc[ii[0]],cc[ii[1]],cc[ii[2]],cc[ii[3]]}; double a[4][4]; if (Marco(K,U,c,a) ) { for (int i=0;i<4;i++) for (int j=0;j<4;j++) if (fabs(a[i][j]) >= 1e-30) Aij[make_pair(ii[i],ii[j])]+=a[i][j]; } } amorse= new MatriceMorse<R>(Th.nv,Th.nv,Aij,false); } sparce_mat->Uh=UniqueffId(); sparce_mat->Vh=UniqueffId(); sparce_mat->A.master(amorse); sparce_mat->typemat=(amorse->n == amorse->m) ? TypeSolveMat(TypeSolveMat::GMRES) : TypeSolveMat(TypeSolveMat::NONESQUARE); // none square matrice (morse) *mp=mps; if(verbosity>3) { cout << " End Build MatrixUpWind : " << endl;} return sparce_mat; }
/*********************************************************** start script in a new thread ***********************************************************/ void LuaHandlerBase::StartScript(const std::string & FunctionName, long ActorId, bool inlinefunction, ScriptEnvironmentBase* env, int &ThreadReference) { ThreadReference = -1; //try //{ // luabind::call_function<void>(m_LuaState, FunctionName.c_str(), 1, env); //} //catch(const std::exception &error) //{ // LogHandler::getInstance()->LogToFile(std::string("Exception calling lua function ") + FunctionName + std::string(" : ") + error.what() + std::string(" : ") + lua_tostring(m_LuaState, -1), 0); //} boost::shared_ptr<LuaThreadHandler> Th(new LuaThreadHandler(m_LuaState, ActorId, FunctionName, inlinefunction, env, ThreadReference, m_creatingthread)); if(Th->IsStarted()) m_RunningThreads[ThreadReference] = Th; else ThreadReference = -1; m_creatingthread = -1; }
Thingy executenamedcommand(char *prmt) { Thingy cmd, retval = NULL; int l, len, feep = 0, listed = 0, curlist = 0; int ols = (listshown && validlist), olll = lastlistlen; char *cmdbuf, *ptr; char *okeymap = ztrdup(curkeymapname); clearlist = 1; /* prmt may be constant */ prmt = ztrdup(prmt); l = strlen(prmt); cmdbuf = (char *)zhalloc(l + NAMLEN + 2 #ifdef MULTIBYTE_SUPPORT + 2 * MB_CUR_MAX #endif ); strcpy(cmdbuf, prmt); zsfree(prmt); statusline = cmdbuf; selectlocalmap(command_keymap); selectkeymap("main", 1); ptr = cmdbuf += l; len = 0; for (;;) { *ptr = '_'; ptr[1] = '\0'; zrefresh(); if (!(cmd = getkeycmd()) || cmd == Th(z_sendbreak)) { statusline = NULL; selectkeymap(okeymap, 1); zsfree(okeymap); if ((listshown = ols)) { showinglist = -2; lastlistlen = olll; } else if (listed) clearlist = listshown = 1; retval = NULL; goto done; } if(cmd == Th(z_clearscreen)) { clearscreen(zlenoargs); if (curlist) { int zmultsav = zmult; zmult = 1; listlist(namedcmdll); showinglist = 0; zmult = zmultsav; } } else if(cmd == Th(z_redisplay)) { redisplay(zlenoargs); if (curlist) { int zmultsav = zmult; zmult = 1; listlist(namedcmdll); showinglist = 0; zmult = zmultsav; } } else if(cmd == Th(z_viquotedinsert)) { *ptr = '^'; zrefresh(); getfullchar(0); if(LASTFULLCHAR == ZLEEOF || !LASTFULLCHAR || len >= NAMLEN) feep = 1; else { int ret = zlecharasstring(LASTFULLCHAR, ptr); len += ret; ptr += ret; curlist = 0; } } else if(cmd == Th(z_quotedinsert)) { if(getfullchar(0) == ZLEEOF || !LASTFULLCHAR || len == NAMLEN) feep = 1; else { int ret = zlecharasstring(LASTFULLCHAR, ptr); len += ret; ptr += ret; curlist = 0; } } else if(cmd == Th(z_backwarddeletechar) || cmd == Th(z_vibackwarddeletechar)) { if (len) { ptr = backwardmetafiedchar(cmdbuf, ptr, NULL); len = ptr - cmdbuf; curlist = 0; } } else if(cmd == Th(z_killregion) || cmd == Th(z_backwardkillword) || cmd == Th(z_vibackwardkillword)) { if (len) curlist = 0; while (len) { convchar_t cc; ptr = backwardmetafiedchar(cmdbuf, ptr, &cc); len = ptr - cmdbuf; if (cc == ZWC('-')) break; } } else if(cmd == Th(z_killwholeline) || cmd == Th(z_vikillline) || cmd == Th(z_backwardkillline)) { len = 0; ptr = cmdbuf; if (listed) clearlist = listshown = 1; curlist = 0; } else if (cmd == Th(z_bracketedpaste)) { char *insert = bracketedstring(); size_t inslen = strlen(insert); if (len + inslen > NAMLEN) feep = 1; else { strcpy(ptr, insert); len += inslen; ptr += inslen; if (listed) { clearlist = listshown = 1; listed = 0; } else curlist = 0; } free(insert); } else { if(cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode)) { Thingy r; unambiguous: *ptr = 0; r = rthingy(cmdbuf); if (!(r->flags & DISABLED)) { unrefthingy(r); statusline = NULL; selectkeymap(okeymap, 1); zsfree(okeymap); if ((listshown = ols)) { showinglist = -2; lastlistlen = olll; } else if (listed) clearlist = listshown = 1; retval = r; goto done; } unrefthingy(r); } if(cmd == Th(z_selfinsertunmeta)) { fixunmeta(); cmd = Th(z_selfinsert); } if (cmd == Th(z_listchoices) || cmd == Th(z_deletecharorlist) || cmd == Th(z_expandorcomplete) || cmd == Th(z_completeword) || cmd == Th(z_expandorcompleteprefix) || cmd == Th(z_vicmdmode) || cmd == Th(z_acceptline) || lastchar == ' ' || lastchar == '\t') { namedcmdambig = 100; namedcmdll = newlinklist(); *ptr = '\0'; namedcmdstr = cmdbuf; scanhashtable(thingytab, 1, 0, DISABLED, scancompcmd, 0); namedcmdstr = NULL; if (empty(namedcmdll)) { feep = 1; if (listed) clearlist = listshown = 1; curlist = 0; } else if (cmd == Th(z_listchoices) || cmd == Th(z_deletecharorlist)) { int zmultsav = zmult; *ptr = '_'; ptr[1] = '\0'; zmult = 1; listlist(namedcmdll); listed = curlist = 1; showinglist = 0; zmult = zmultsav; } else if (!nextnode(firstnode(namedcmdll))) { strcpy(ptr = cmdbuf, peekfirst(namedcmdll)); len = strlen(ptr); ptr += len; if (cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode)) goto unambiguous; } else { strcpy(cmdbuf, peekfirst(namedcmdll)); ptr = cmdbuf + namedcmdambig; *ptr = '_'; ptr[1] = '\0'; if (isset(AUTOLIST) && !(isset(LISTAMBIGUOUS) && namedcmdambig > len)) { int zmultsav = zmult; if (isset(LISTBEEP)) feep = 1; zmult = 1; listlist(namedcmdll); listed = curlist = 1; showinglist = 0; zmult = zmultsav; } len = namedcmdambig; } } else { if (len == NAMLEN || cmd != Th(z_selfinsert)) feep = 1; else { #ifdef MULTIBYTE_SUPPORT if (!lastchar_wide_valid) getrestchar(lastchar, NULL, NULL); if (lastchar_wide == WEOF) feep = 1; else #endif if (ZC_icntrl(LASTFULLCHAR)) feep = 1; else { int ret = zlecharasstring(LASTFULLCHAR, ptr); len += ret; ptr += ret; if (listed) { clearlist = listshown = 1; listed = 0; } else curlist = 0; } } } } if (feep) handlefeep(zlenoargs); feep = 0; } done: selectlocalmap(NULL); return retval; }
int main(int argc, char **argv) { Real8 cutoffradian = 30.0*Pi/180.0; char * fin=0,*fout=0,*fgeom=0; verbosity = 2; int ok=0,i=0; if (argc >= 3) { fin=argv[1]; fout=argv[2]; ok= !access(fin,R_OK) && (access(fout,F_OK) || !access(fout,W_OK)) ; } for (i=3;i<argc && ok ;i+=2) if (!strcmp(argv[i],"-g")) { fgeom=argv[i+1]; ok= ok && (access(fgeom,F_OK) || !access(fgeom,W_OK) ); } else if (!strcmp(argv[i],"-thetamax")) cutoffradian = atof(argv[i+1])*Pi/180.0; else if (!strcmp(argv[i],"-v")) verbosity = atoi(argv[i+1]); else ok=0; if (!ok) { cout << "2D mesh convertisor of type .am_fmt .amdba .am .nopo .msh .ftq + bd mesh\n"; cout << " in type .am_fmt .amdba .am .nopo .msh .ftq + bd mesh\n"; cout << endl; cout << " usage: cnmsh2 InMesh OutMesh \n"; cout << " or : cnmsh2 Inmeshfile OutBdmeshfile [-g OutGeomfile ] [ -thetamax theta ] [-v level]\n"; cout << endl; cout << " where theta is the angular limit for smooth curve in degre \n"; cout << " level is level of verbosity in [0..99] 0 => no message, 99 to much \n"; cout << endl; cout << " remark: "; cout << " the type of OutMesh is defined with the suffix\n"; cout << " si the suffixe is not in .am_fmt .amdba .am .nopo .msh .ftq, then \n"; cout << " the mesh is a bd mesh (cf .mesh)" << endl; return 1; } MeshIstreamErrorHandler = MeshErrorIO; set_new_handler( &NewHandler); #ifdef DRAWING initgraphique(); initgraph=1; #endif // cout << "open file in " << fin<< endl; Triangles Th(fin,cutoffradian); if (!fgeom) Th.Write(fout); else { // cout << " geom " << fgeom << endl; Th.Gh.Write(fgeom); Th.Write(fout,Triangles::BDMesh); } return 0; }
static int getvirange(int wf) { int pos = zlecs, ret = 0; int mult1 = zmult, hist1 = histline; Thingy k2; virangeflag = 1; wordflag = wf; /* Now we need to execute the movement command, to see where it * * actually goes. virangeflag here indicates to the movement * * function that it should place the cursor at the end of the * * range, rather than where the cursor would actually go if it * * were executed normally. This makes a difference to some * * commands, but not all. For example, if searching forward * * for a character, under normal circumstances the cursor lands * * on the character. For a range, the range must include the * * character, so the cursor gets placed after the character if * * virangeflag is set. vi-match-bracket needs to change the * * value of virangeflag under some circumstances, meaning that * * we need to change the *starting* position. */ zmod.flags &= ~MOD_TMULT; do { vilinerange = 0; prefixflag = 0; if (!(k2 = getkeycmd()) || (k2->flags & DISABLED) || k2 == Th(z_sendbreak)) { wordflag = 0; virangeflag = 0; return -1; } /* * With k2 == bindk, the command key is repeated: * a number of lines is used. If the function used * returns 1, we fail. */ if ((k2 == bindk) ? dovilinerange() : execzlefunc(k2, zlenoargs, 1)) ret = -1; if(vichgrepeat) zmult = mult1; else zmult = mult1 * zmod.tmult; } while(prefixflag && !ret); wordflag = 0; virangeflag = 0; /* It is an error to use a non-movement command to delimit the * * range. We here reject the case where the command modified * * the line, or selected a different history line. */ if (histline != hist1 || zlell != lastll || memcmp(zleline, lastline, zlell)) { histline = hist1; ZS_memcpy(zleline, lastline, zlell = lastll); zlecs = pos; return -1; } /* Can't handle an empty file. Also, if the movement command * * failed, or didn't move, it is an error. */ if (!zlell || (zlecs == pos && virangeflag != 2) || ret == -1) return -1; /* vi-match-bracket changes the value of virangeflag when * * moving to the opening bracket, meaning that we need to * * change the *starting* position. */ if(virangeflag == -1) { int origcs = zlecs; zlecs = pos; INCCS(); pos = zlecs; zlecs = origcs; } /* Get the range the right way round. zlecs is placed at the * * start of the range, and pos (the return value of this * * function) is the end. */ if (zlecs > pos) { int tmp = zlecs; zlecs = pos; pos = tmp; } /* Was it a line-oriented move? If so, the command will have set * * the vilinerange flag. In this case, entire lines are taken, * * rather than just the sequence of characters delimited by pos * * and zlecs. The terminating newline is left out of the range, * * which the real command must deal with appropriately. At this * * point we just need to make the range encompass entire lines. */ if(vilinerange) { int newcs = findbol(); zlecs = pos; pos = findeol(); zlecs = newcs; } return pos; }
REAL age_z(REAL x){ REAL res; REAL abr; int_su1p(x,tz,&res,&abr); return res*Th(); }
REAL Tl(REAL x){ REAL res; REAL abr; int_l1p(0.0,x,tz,&res,&abr); return res*Th(); }
static int getvirange(int wf) { int pos = zlecs, mpos = mark, ret = 0; int visual = region_active; /* movement command might set it */ int mult1 = zmult, hist1 = histline; Thingy k2; if (visual) { if (!zlell) return -1; pos = mark; vilinerange = (visual == 2); region_active = 0; } else { virangeflag = 1; wordflag = wf; mark = -1; /* use operator-pending keymap if one exists */ Keymap km = openkeymap("viopp"); if (km) selectlocalmap(km); /* Now we need to execute the movement command, to see where it * * actually goes. virangeflag here indicates to the movement * * function that it should place the cursor at the end of the * * range, rather than where the cursor would actually go if it * * were executed normally. This makes a difference to some * * commands, but not all. For example, if searching forward * * for a character, under normal circumstances the cursor lands * * on the character. For a range, the range must include the * * character, so the cursor gets placed after the character if * * virangeflag is set. */ zmod.flags &= ~MOD_TMULT; do { vilinerange = 0; prefixflag = 0; if (!(k2 = getkeycmd()) || (k2->flags & DISABLED) || k2 == Th(z_sendbreak)) { wordflag = 0; virangeflag = 0; mark = mpos; return -1; } /* * With k2 == bindk, the command key is repeated: * a number of lines is used. If the function used * returns 1, we fail. */ if ((k2 == bindk) ? dovilinerange() : execzlefunc(k2, zlenoargs, 1)) ret = -1; if(vichgrepeat) zmult = mult1; else zmult = mult1 * zmod.tmult; } while(prefixflag && !ret); wordflag = 0; selectlocalmap(NULL); /* It is an error to use a non-movement command to delimit the * * range. We here reject the case where the command modified * * the line, or selected a different history line. */ if (histline != hist1 || zlell != lastll || memcmp(zleline, lastline, zlell)) { histline = hist1; ZS_memcpy(zleline, lastline, zlell = lastll); zlecs = pos; mark = mpos; virangeflag = 0; return -1; } /* Can't handle an empty file. Also, if the movement command * * failed, or didn't move, it is an error. */ if (!zlell || (zlecs == pos && (mark == -1 || mark == zlecs) && virangeflag != 2) || ret == -1) { mark = mpos; virangeflag = 0; return -1; } virangeflag = 0; /* if the mark has moved, ignore the original cursor position * * and use the mark. */ if (mark != -1) pos = mark; } mark = mpos; /* Get the range the right way round. zlecs is placed at the * * start of the range, and pos (the return value of this * * function) is the end. */ if (zlecs > pos) { int tmp = zlecs; zlecs = pos; pos = tmp; } /* visual selection mode needs to include additional position */ if (visual == 1 && pos < zlell && invicmdmode()) INCPOS(pos); /* Was it a line-oriented move? If so, the command will have set * * the vilinerange flag. In this case, entire lines are taken, * * rather than just the sequence of characters delimited by pos * * and zlecs. The terminating newline is left out of the range, * * which the real command must deal with appropriately. At this * * point we just need to make the range encompass entire lines. */ vilinerange = (zmod.flags & MOD_LINE) || (vilinerange && !(zmod.flags & MOD_CHAR)); if (vilinerange) { int newcs = findbol(); lastcol = zlecs - newcs; zlecs = pos; pos = findeol(); zlecs = newcs; } else if (!visual) { /* for a character-wise move don't include a newline at the * * end of the range */ int prev = pos; DECPOS(prev); if (zleline[prev] == ZWC('\n')) pos = prev; } return pos; }