1 // -*- mode:C++ ; compile-command: "g++ -I.. -g -c ti89.cc -fno-strict-aliasing -DGIAC_GENERIC_CONSTANTS -DIN_GIAC -DHAVE_CONFIG_H" -*- 2 #include "giacPCH.h" 3 /* 4 * Copyright (C) 2000,2007 B. Parisse, Institut Fourier, 38402 St Martin d'Heres 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 3 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 using namespace std; 20 #include <stdexcept> 21 #include <cmath> 22 #include <cstdlib> 23 #include <string.h> 24 #if !defined GIAC_HAS_STO_38 && !defined NSPIRE && !defined FXCG && !defined POCKETCAS 25 #include <fstream> 26 #endif 27 // #include <numeric_limits> 28 #include "misc.h" 29 #include "usual.h" 30 #include "sym2poly.h" 31 #include "rpn.h" 32 #include "prog.h" 33 #include "derive.h" 34 #include "subst.h" 35 #include "intg.h" 36 #include "vecteur.h" 37 #include "ifactor.h" 38 #include "solve.h" 39 #include "modpoly.h" 40 #include "permu.h" 41 #include "sym2poly.h" 42 #include "plot.h" 43 #include "lin.h" 44 #include "modpoly.h" 45 #include "desolve.h" 46 #include "alg_ext.h" 47 #include "moyal.h" 48 #include "ti89.h" 49 #include "maple.h" 50 #include "input_parser.h" 51 #include "input_lexer.h" 52 #include "giacintl.h" 53 #ifdef HAVE_UNISTD_H 54 #include <unistd.h> 55 #endif 56 #ifdef FXCG 57 extern "C" { 58 #include <keyboard.h> 59 } 60 #endif 61 #ifdef KHICAS 62 #include "kdisplay.h" 63 #endif 64 65 #ifndef NO_NAMESPACE_GIAC 66 namespace giac { 67 #endif // ndef NO_NAMESPACE_GIAC 68 69 /* 70 string printasti_not_implemented(const gen & feuille,const char * sommetstr){ 71 if (feuille.type!=_VECT || feuille._VECTptr->size()!=2) 72 return sommetstr+("("+feuille.print()+")"); 73 vecteur & v=*feuille._VECTptr; 74 if (v[0].type==_STRNG) 75 return *v[0]._STRNGptr+"("+v[1].print()+")"; 76 else 77 return v[0].print()+"("+v[1].print()+")"; 78 } 79 */ 80 static const char _ti_not_implemented_s[]="ti_not_implemented"; 81 static define_unary_function_eval (__ti_not_implemented,&_nop,_ti_not_implemented_s); // never evaled 82 define_unary_function_ptr( at_ti_not_implemented ,alias_at_ti_not_implemented ,&__ti_not_implemented); 83 84 static const char _ti_endtag_s[]="ti_endtag"; 85 static define_unary_function_eval (__ti_endtag,&_nop,_ti_endtag_s); // never evaled 86 define_unary_function_ptr( at_ti_endtag ,alias_at_ti_endtag ,&__ti_endtag); 87 _seq(const gen & g,GIAC_CONTEXT)88 gen _seq(const gen & g,GIAC_CONTEXT){ 89 gen g1(g); 90 if (g.type==_VECT && g.subtype==_SEQ__VECT && !g._VECTptr->empty()){ 91 vecteur v(*g._VECTptr); 92 if (v.size()>=2){ 93 gen x(v[1]); 94 if (is_equal(x) && x._SYMBptr->feuille.type==_VECT && !x._SYMBptr->feuille._VECTptr->empty()) 95 x=x._SYMBptr->feuille._VECTptr->front(); 96 if (v.front().is_symb_of_sommet(at_quote)) 97 v.front()=v.front()._SYMBptr->feuille; 98 //gen tmp(quote_eval(makevecteur(v.front()),makevecteur(x),contextptr)); 99 //v.front()=tmp[0]; 100 } 101 else 102 v.front()=eval(v.front(),eval_level(contextptr),contextptr); 103 if (v.size()==2 && is_integral((g1=eval(v[1],eval_level(contextptr),contextptr))) && g1.val>=0){ 104 vecteur res; 105 int s=g1.val,l=eval_level(contextptr); 106 res.reserve(s); 107 gen v0=v[0]; 108 for (int i=0;i<s;++i) 109 res.push_back(eval(v0,l,contextptr)); 110 return res; 111 } 112 g1=gen(v,_SEQ__VECT); 113 } 114 return seqprod(g1,0,contextptr); 115 } 116 static const char _seq_s[]="seq"; 117 static define_unary_function_eval_quoted (__seq,&_seq,_seq_s); 118 define_unary_function_ptr5( at_seq ,alias_at_seq,&__seq,_QUOTE_ARGUMENTS,true); 119 _logb(const gen & g,GIAC_CONTEXT)120 gen _logb(const gen & g,GIAC_CONTEXT){ 121 if (g.type!=_VECT || g._VECTptr->size()!=2) 122 return ln(g,contextptr); 123 int n=0; gen e1(g._VECTptr->front()),b(g._VECTptr->back()),q; 124 if (is_integer(e1) && is_integer(b) && is_strictly_greater(b,1,contextptr) && !is_zero(e1)){ 125 while (is_zero(irem(e1,b,q))){ 126 if (q.type==_ZINT) 127 e1=*q._ZINTptr; 128 else 129 e1=q; 130 ++n; 131 } 132 } 133 return rdiv(ln(e1,contextptr),ln(b,contextptr),contextptr)+n; 134 // return ln(g._VECTptr->front(),contextptr)/ln(g._VECTptr->back(),contextptr); 135 } 136 static const char _logb_s[]="logb"; 137 static define_unary_function_eval (__logb,&_logb,_logb_s); 138 define_unary_function_ptr5( at_logb ,alias_at_logb,&__logb,0,true); 139 getType(const gen & g)140 static string getType(const gen & g){ 141 switch (g.type){ 142 case _INT_: case _REAL: case _DOUBLE_: case _FRAC: 143 return "NUM"; 144 case _VECT: 145 if (ckmatrix(g)) 146 return "MAT"; 147 else 148 return "LIST"; 149 case _IDNT: 150 return "VAR"; 151 case _SYMB: 152 if (g.is_symb_of_sommet(at_program)) 153 return "FUNC"; 154 else 155 return "EXPR"; 156 case _CPLX: 157 return "EXPR"; 158 case _STRNG: 159 return "STR"; 160 default: 161 return "OTHER"; 162 } 163 } _getType(const gen & g,GIAC_CONTEXT)164 gen _getType(const gen & g,GIAC_CONTEXT){ 165 return string2gen(getType(g),false); 166 } 167 static const char _getType_s[]="getType"; 168 static define_unary_function_eval (__getType,&_getType,_getType_s); 169 define_unary_function_ptr5( at_getType ,alias_at_getType,&__getType,0,true); 170 _Define(const gen & g,GIAC_CONTEXT)171 gen _Define(const gen & g,GIAC_CONTEXT){ 172 if (g.type!=_VECT || g._VECTptr->size()!=2) 173 return gensizeerr(contextptr); 174 vecteur & v=*g._VECTptr; 175 gen g1=v.front(),g2=v.back(); 176 if (!g1.is_symb_of_sommet(at_of)) 177 return gensizeerr(contextptr); 178 gen &g11=g1._SYMBptr->feuille; 179 if (g11.type!=_VECT || g11._VECTptr->size()!=2) 180 return gensizeerr(contextptr); 181 gen gname=g11._VECTptr->front(),garg=g11._VECTptr->back(); 182 return symb_sto(symb_program(garg,garg*zero,symb_bloc(g2),contextptr),gname); 183 } 184 static const char _colDim_s[]="colDim"; 185 static define_unary_function_eval (__colDim,&_ncols,_colDim_s); 186 define_unary_function_ptr5( at_colDim ,alias_at_colDim,&__colDim,0,true); 187 188 static const char _rowDim_s[]="rowDim"; 189 static define_unary_function_eval (__rowDim,&_nrows,_rowDim_s); 190 define_unary_function_ptr5( at_rowDim ,alias_at_rowDim,&__rowDim,0,true); 191 192 static const char _randMat_s[]="randMat"; 193 static define_unary_function_eval (__randMat,&_ranm,_randMat_s); 194 define_unary_function_ptr5( at_randMat ,alias_at_randMat,&__randMat,0,true); 195 196 static const char _eigVc_s[]="eigVc"; 197 static define_unary_function_eval (__eigVc,&_egv,_eigVc_s); 198 define_unary_function_ptr5( at_eigVc ,alias_at_eigVc,&__eigVc,0,true); 199 200 static const char _eigVl_s[]="eigVl"; 201 static define_unary_function_eval (__eigVl,&_egvl,_eigVl_s); 202 define_unary_function_ptr5( at_eigVl ,alias_at_eigVl,&__eigVl,0,true); 203 204 static const char _transpose_s[]="transpose"; 205 static define_unary_function_eval (__transpose,&_tran,_transpose_s); 206 define_unary_function_ptr5( at_transpose ,alias_at_transpose,&__transpose,0,true); 207 208 static const char _identity_s[]="identity"; 209 static define_unary_function_eval (__identity,&_idn,_identity_s); 210 define_unary_function_ptr5( at_identity ,alias_at_identity,&__identity,0,true); 211 _isprime(const gen & args,GIAC_CONTEXT)212 gen _isprime(const gen & args,GIAC_CONTEXT){ 213 gen g=_is_prime(args,contextptr); 214 if (is_undef(g)) return g; 215 if (g.type==_VECT) 216 return g; 217 if (g==0){ 218 g.subtype=_INT_BOOLEAN; 219 return g; 220 } 221 g=plus_one; 222 g.subtype=_INT_BOOLEAN; 223 return g; 224 } 225 static const char _isprime_s[]="isprime"; 226 static define_unary_function_eval (__isprime,&_isprime,_isprime_s); 227 define_unary_function_ptr5( at_isprime ,alias_at_isprime,&__isprime,0,true); 228 229 /* 230 gen _Input(const gen & g){ 231 vecteur v(gen2vecteur(g)); 232 int s=v.size(); 233 gen res; 234 if (s==1) 235 res=_inputform(symbolic(at_click,makesequence(v[0],0,v[0]))); 236 else { 237 if (s==2) 238 res= _inputform(symbolic(at_click,makesequence(v[0],0,v[1]))); 239 else 240 res= __click.op(g); 241 } 242 __interactive.op(symbolic(at_print,makesequence(g,res))); 243 return res; 244 } 245 */ _Input(const gen & args,GIAC_CONTEXT)246 gen _Input(const gen & args,GIAC_CONTEXT){ 247 return _input(args,false,contextptr); 248 } 249 static const char _Input_s[]="Input"; 250 static define_unary_function_eval2_quoted (__Input,&_Input,_Input_s,&printastifunction); 251 define_unary_function_ptr5( at_Input ,alias_at_Input,&__Input,_QUOTE_ARGUMENTS,T_RETURN); 252 253 static const char _lis_s[]="lis"; 254 static define_unary_function_eval2_quoted (__lis,&_Input,_lis_s,&printastifunction); 255 define_unary_function_ptr5( at_lis ,alias_at_lis,&__lis,_QUOTE_ARGUMENTS,T_RETURN); 256 _InputStr(const gen & g,GIAC_CONTEXT)257 gen _InputStr(const gen & g,GIAC_CONTEXT){ 258 vecteur v(gen2vecteur(g)); 259 int s=int(v.size()); 260 gen res; 261 if (s==1) 262 res= __click.op(makevecteur(string2gen(v[0].print(contextptr)),0,v[0],1),contextptr); 263 else { 264 if (s==2) 265 res= __click.op(makevecteur(string2gen(eval(v[0],eval_level(contextptr),contextptr).print(contextptr)),v[1],1),contextptr); 266 else 267 res= _input(g,true,contextptr); 268 } 269 if (is_zero(res)) 270 return gensizeerr(contextptr); 271 return res; 272 } 273 274 /* 275 gen _InputStr(const gen & args,GIAC_CONTEXT){ 276 return _input(args,true,contextptr); 277 } 278 */ 279 static const char _InputStr_s[]="InputStr"; 280 static define_unary_function_eval2_quoted (__InputStr,&_InputStr,_InputStr_s,&printastifunction); 281 define_unary_function_ptr5( at_InputStr ,alias_at_InputStr,&__InputStr,_QUOTE_ARGUMENTS,T_RETURN); 282 283 static const char _lis_phrase_s[]="lis_phrase"; 284 static define_unary_function_eval2_quoted (__lis_phrase,&_InputStr,_lis_phrase_s,&printastifunction); 285 define_unary_function_ptr5( at_lis_phrase ,alias_at_lis_phrase,&__lis_phrase,_QUOTE_ARGUMENTS,T_RETURN); 286 _Prompt(const gen & g,GIAC_CONTEXT)287 gen _Prompt(const gen & g,GIAC_CONTEXT){ 288 gen res= _inputform(symbolic(at_click,makesequence(g,g,g)),contextptr); 289 __interactive.op(symbolic(at_print,makesequence(g,res)),contextptr); 290 return res; 291 } 292 static const char _Prompt_s[]="Prompt"; 293 static define_unary_function_eval2_quoted (__Prompt,&_Prompt,_Prompt_s,&printastifunction); 294 define_unary_function_ptr5( at_Prompt ,alias_at_Prompt,&__Prompt,_QUOTE_ARGUMENTS,T_RETURN); 295 296 static const char _PopUp_s[]="PopUp"; 297 static define_unary_function_eval2_quoted (__PopUp,&_choosebox,_PopUp_s,&printastifunction); 298 define_unary_function_ptr5( at_PopUp ,alias_at_PopUp,&__PopUp,_QUOTE_ARGUMENTS,T_RETURN); 299 _cSolve(const gen & g,GIAC_CONTEXT)300 gen _cSolve(const gen & g,GIAC_CONTEXT){ 301 bool old_complex_mode=complex_mode(contextptr); 302 complex_mode(true,contextptr); 303 gen res=_solve(g,contextptr); 304 complex_mode(old_complex_mode,contextptr); 305 return res; 306 } 307 static const char _cSolve_s[]="cSolve"; 308 static define_unary_function_eval_quoted (__cSolve,&_cSolve,_cSolve_s); 309 define_unary_function_ptr5( at_cSolve ,alias_at_cSolve,&__cSolve,_QUOTE_ARGUMENTS,true); 310 311 static const char _csolve_s[]="csolve"; 312 static define_unary_function_eval_quoted (__csolve,&_cSolve,_csolve_s); 313 define_unary_function_ptr5( at_csolve ,alias_at_csolve,&__csolve,_QUOTE_ARGUMENTS,true); 314 315 static const char _resoudre_dans_C_s[]="resoudre_dans_C"; 316 static define_unary_function_eval_quoted (__resoudre_dans_C,&_cSolve,_resoudre_dans_C_s); 317 define_unary_function_ptr5( at_resoudre_dans_C ,alias_at_resoudre_dans_C,&__resoudre_dans_C,_QUOTE_ARGUMENTS,true); 318 _cFactor(const gen & g,GIAC_CONTEXT)319 gen _cFactor(const gen & g,GIAC_CONTEXT){ 320 bool old_complex_mode=complex_mode(contextptr); 321 complex_mode(true,contextptr); 322 gen res=_factor(g,contextptr); 323 complex_mode(old_complex_mode,contextptr); 324 return res; 325 } 326 static const char _cFactor_s[]="cFactor"; 327 static define_unary_function_eval (__cFactor,&_cFactor,_cFactor_s); 328 define_unary_function_ptr5( at_cFactor ,alias_at_cFactor,&__cFactor,0,true); 329 330 static const char _cfactor_s[]="cfactor"; 331 static define_unary_function_eval (__cfactor,&_cFactor,_cfactor_s); 332 define_unary_function_ptr5( at_cfactor ,alias_at_cfactor,&__cfactor,0,true); 333 334 static const char _factoriser_sur_C_s[]="factoriser_sur_C"; 335 static define_unary_function_eval (__factoriser_sur_C,&_cFactor,_factoriser_sur_C_s); 336 define_unary_function_ptr5( at_factoriser_sur_C ,alias_at_factoriser_sur_C,&__factoriser_sur_C,0,true); 337 _cpartfrac(const gen & g,GIAC_CONTEXT)338 gen _cpartfrac(const gen & g,GIAC_CONTEXT){ 339 bool old_complex_mode=complex_mode(contextptr); 340 complex_mode(true,contextptr); 341 gen res=_partfrac(g,contextptr); 342 complex_mode(old_complex_mode,contextptr); 343 return res; 344 } 345 static const char _cpartfrac_s[]="cpartfrac"; 346 static define_unary_function_eval (__cpartfrac,&_cpartfrac,_cpartfrac_s); 347 define_unary_function_ptr5( at_cpartfrac ,alias_at_cpartfrac,&__cpartfrac,0,true); 348 _nSolve(const gen & g,GIAC_CONTEXT)349 gen _nSolve(const gen & g,GIAC_CONTEXT){ 350 vecteur v(gen2vecteur(g)); 351 if (v.size()!=2) 352 return gensizeerr(contextptr); 353 gen var=v[1],guess; 354 if (var.type==_SYMB && (var._SYMBptr->sommet==at_equal || var._SYMBptr->sommet==at_equal2 || var._SYMBptr->sommet==at_same)){ 355 guess=var._SYMBptr->feuille._VECTptr->back(); 356 if (guess.is_symb_of_sommet(at_interval)) 357 return _fsolve(g,contextptr); 358 var=var._SYMBptr->feuille._VECTptr->front(); 359 return newton(remove_equal(v[0]),var,guess,NEWTON_DEFAULT_ITERATION,1e-5,1e-12,!complex_mode(contextptr),1,0,1,0,1,contextptr); 360 } 361 else 362 return newton(remove_equal(v[0]),var,0,NEWTON_DEFAULT_ITERATION,1e-5,1e-12,!complex_mode(contextptr),1,0,1,0,1,contextptr); 363 } 364 static const char _nSolve_s[]="nSolve"; 365 static define_unary_function_eval (__nSolve,&_nSolve,_nSolve_s); 366 define_unary_function_ptr5( at_nSolve ,alias_at_nSolve,&__nSolve,0,true); 367 zeros(const gen & g,bool complexmode,GIAC_CONTEXT)368 static gen zeros(const gen &g,bool complexmode,GIAC_CONTEXT){ 369 vecteur v(solvepreprocess(g,complexmode,contextptr)); 370 int s=int(v.size()); 371 if (s>2) 372 return gentoomanyargs("solve"); 373 return solve(remove_equal(v.front()),v.back(),complexmode,contextptr); 374 } _zeros(const gen & g,GIAC_CONTEXT)375 gen _zeros(const gen & g,GIAC_CONTEXT){ 376 if (g.type==_VECT && g._VECTptr->size()==2){ 377 gen a=eval(g._VECTptr->front(),1,contextptr); 378 gen b=eval(g._VECTptr->back(),1,contextptr); 379 if (is_integral(a) && is_integral(b)) 380 return _matrix(makesequence(a,b,0.0),contextptr); 381 } 382 return zeros(g,complex_mode(contextptr),contextptr); 383 } 384 static const char _zeros_s[]="zeros"; 385 static define_unary_function_eval_quoted (__zeros,&_zeros,_zeros_s); 386 define_unary_function_ptr5( at_zeros ,alias_at_zeros,&__zeros,_QUOTE_ARGUMENTS,true); 387 _cZeros(const gen & g,GIAC_CONTEXT)388 gen _cZeros(const gen & g,GIAC_CONTEXT){ 389 bool b=complex_mode(contextptr); 390 complex_mode(true,contextptr); 391 gen res=zeros(g,true,contextptr); 392 complex_mode(b,contextptr); 393 return res; 394 } 395 static const char _cZeros_s[]="cZeros"; 396 static define_unary_function_eval_quoted (__cZeros,&_cZeros,_cZeros_s); 397 define_unary_function_ptr5( at_cZeros ,alias_at_cZeros,&__cZeros,_QUOTE_ARGUMENTS,true); 398 static const char _czeros_s[]="czeros"; 399 static define_unary_function_eval_quoted (__czeros,&_cZeros,_czeros_s); 400 define_unary_function_ptr5( at_czeros ,alias_at_czeros,&__czeros,_QUOTE_ARGUMENTS,true); 401 getDenom(const gen & g,GIAC_CONTEXT)402 static gen getDenom(const gen & g,GIAC_CONTEXT){ 403 vecteur num,den; 404 prod2frac(g,num,den); 405 return vecteur2prod(den); 406 } _getDenom(const gen & g,GIAC_CONTEXT)407 gen _getDenom(const gen & g,GIAC_CONTEXT){ 408 return apply(g,getDenom,contextptr); 409 } 410 static const char _getDenom_s[]="getDenom"; 411 static define_unary_function_eval (__getDenom,&_getDenom,_getDenom_s); 412 define_unary_function_ptr5( at_getDenom ,alias_at_getDenom,&__getDenom,0,true); 413 denom(const gen & g,GIAC_CONTEXT)414 static gen denom(const gen & g,GIAC_CONTEXT){ 415 gen res=_fxnd(g,contextptr); 416 if (res.type!=_VECT) return res; 417 return res._VECTptr->back(); 418 } _denom(const gen & g,GIAC_CONTEXT)419 gen _denom(const gen & g,GIAC_CONTEXT){ 420 return apply(g,denom,contextptr); 421 } 422 static const char _denom_s[]="denom"; 423 static define_unary_function_eval (__denom,&_denom,_denom_s); 424 define_unary_function_ptr5( at_denom ,alias_at_denom,&__denom,0,true); 425 getNum(const gen & g,GIAC_CONTEXT)426 static gen getNum(const gen & g,GIAC_CONTEXT){ 427 vecteur num,den; 428 prod2frac(g,num,den); 429 return vecteur2prod(num); 430 } _getNum(const gen & g,GIAC_CONTEXT)431 gen _getNum(const gen & g,GIAC_CONTEXT){ 432 return apply(g,getNum,contextptr); 433 } 434 static const char _getNum_s[]="getNum"; 435 static define_unary_function_eval (__getNum,&_getNum,_getNum_s); 436 define_unary_function_ptr5( at_getNum ,alias_at_getNum,&__getNum,0,true); 437 numer(const gen & g,GIAC_CONTEXT)438 static gen numer(const gen & g,GIAC_CONTEXT){ 439 gen res=_fxnd(g,contextptr); 440 if (res.type!=_VECT) return res; 441 return res._VECTptr->front(); 442 } _numer(const gen & g,GIAC_CONTEXT)443 gen _numer(const gen & g,GIAC_CONTEXT){ 444 return apply(g,numer,contextptr); 445 } 446 static const char _numer_s[]="numer"; 447 static define_unary_function_eval (__numer,&_numer,_numer_s); 448 define_unary_function_ptr5( at_numer ,alias_at_numer,&__numer,0,true); 449 450 static const char _propFrac_s[]="propFrac"; 451 static define_unary_function_eval (__propFrac,&_propfrac,_propFrac_s); 452 define_unary_function_ptr5( at_propFrac ,alias_at_propFrac,&__propFrac,0,true); 453 454 static const char _tCollect_s[]="tCollect"; 455 static define_unary_function_eval (__tCollect,&_tcollect,_tCollect_s); 456 define_unary_function_ptr5( at_tCollect ,alias_at_tCollect,&__tCollect,0,true); 457 _tExpand(const gen & g,GIAC_CONTEXT)458 gen _tExpand(const gen & g,GIAC_CONTEXT){ 459 return _simplify(_texpand(g,contextptr),contextptr); 460 } 461 static const char _tExpand_s[]="tExpand"; 462 static define_unary_function_eval (__tExpand,&_tExpand,_tExpand_s); 463 define_unary_function_ptr5( at_tExpand ,alias_at_tExpand,&__tExpand,0,true); 464 _comDenom(const gen & g,GIAC_CONTEXT)465 gen _comDenom(const gen & g,GIAC_CONTEXT){ 466 if ( g.type==_STRNG && g.subtype==-1) return g; 467 if (g.type!=_VECT || g._VECTptr->size()<2 ) 468 return ratnormal(g,contextptr); 469 vecteur & v(*g._VECTptr); 470 return _reorder(makesequence(v.front(),vecteur(v.begin()+1,v.end())),contextptr); 471 } 472 static const char _comDenom_s[]="comDenom"; 473 static define_unary_function_eval (__comDenom,&_comDenom,_comDenom_s); 474 define_unary_function_ptr5( at_comDenom ,alias_at_comDenom,&__comDenom,0,true); 475 rand_index(int dim,int tdeg,GIAC_CONTEXT)476 index_t rand_index(int dim,int tdeg,GIAC_CONTEXT){ 477 index_t res(dim); 478 index_t w(tdeg+dim); 479 for (unsigned int i=0;i<w.size();++i) 480 w[i]=i; 481 for (int i=0;i<dim;++i){ 482 int tmp=int((double(giac_rand(contextptr))*w.size())/rand_max2); 483 res[i]=w[tmp]; 484 w.erase(w.begin()+tmp); 485 } 486 sort(res.begin(),res.end()); 487 for (int i=dim-1;i>0;--i){ 488 res[i] -= res[i-1]+1; 489 } 490 return res; 491 } 492 _randPoly(const gen & g,GIAC_CONTEXT)493 gen _randPoly(const gen & g,GIAC_CONTEXT){ 494 if ( g.type==_STRNG && g.subtype==-1) return g; 495 vecteur v(gen2vecteur(g)); 496 int vs=int(v.size()),deg=10; 497 gen x=vx_var; 498 if (vs && v.back().type==_VECT && v.back()._VECTptr->empty()){ 499 --vs; 500 x=v.back(); 501 v.pop_back(); 502 } 503 gen f=0; 504 if (vs>=3 && v[2].type==_INT_ && v[1].type==_INT_ && v[0].type==_VECT){ 505 // randpoly(variables,total_degree,nterms,[law]) 506 gen a=v[0],b=v[1]; 507 v[0]=b; v[1]=v[2]; v[2]=a; 508 } 509 if (vs>=2 && v[1].type==_VECT && v[0].type==_VECT){ 510 // randpoly(variables,partial_degrees,[law]) 511 vecteur vars=*v[0]._VECTptr; 512 vecteur degs=*v[1]._VECTptr; 513 if (degs.size()!=vars.size() || vars.empty()) 514 return gendimerr(contextptr); 515 gen var=vars[0]; 516 vars.erase(vars.begin()); 517 gen deg=degs[0]; 518 degs.erase(degs.begin()); 519 if (deg.type!=_INT_ || deg.val<0) 520 return gendimerr(contextptr); 521 if (!vars.empty()){ 522 gen res=0; 523 for (int i=deg.val;i>=0;--i){ 524 v[0]=vars; 525 v[1]=degs; 526 gen tmp=_randPoly(gen(v,_SEQ__VECT),contextptr); 527 res += tmp*pow(var,i,contextptr); 528 } 529 return res; 530 } 531 v[0]=var; 532 v[1]=deg; 533 } 534 if (vs>=3 && v[0].type==_INT_ && v[1].type==_INT_ && v[2].type==_VECT){ 535 // randpoly(total_degree,nterms,variables,[law]) 536 if (vs>=4) 537 f=v[3]; 538 if (vs==5){ 539 if (f.type==_FUNC) 540 f=symbolic(*f._FUNCptr,v.back()); 541 else 542 f=symb_of(f,v.back()); 543 } 544 if (vs>5){ 545 if (f.type==_FUNC) 546 f=symbolic(*f._FUNCptr,gen(vecteur(v.begin()+4,v.end()),_SEQ__VECT)); 547 else 548 f=symb_of(f,gen(vecteur(v.begin()+4,v.end()),_SEQ__VECT)); 549 } 550 int tdeg=v[0].val; 551 int nterms=absint(v[1].val); 552 int dim=int(v[2]._VECTptr->size()); 553 vecteur w=vranm(nterms,f,contextptr); 554 polynome p(dim); 555 for (int i=0;i<nterms;++i){ 556 index_t current=rand_index(dim,tdeg,contextptr); 557 p.coord.push_back(monomial<gen>(w[i],current)); 558 } 559 p.tsort(); 560 return _poly2symb(makesequence(p,v[2]),contextptr); 561 } 562 if (vs==1){ 563 if (v[0].type==_INT_) 564 deg=v[0].val; 565 else { 566 x=v[0]; 567 deg=10; 568 } 569 } 570 else { 571 if (vs>=2){ 572 if (v[0].type==_INT_){ 573 deg=v[0].val; 574 if (v[1].type==_IDNT) 575 x=v[1]; 576 else 577 f=v[1]; 578 } 579 else { 580 if (v[1].type==_INT_) 581 deg=v[1].val; 582 else 583 f=v[1]; 584 x=v[0]; 585 } 586 } 587 if (vs>=3){ 588 f=v[2]; 589 } 590 if (vs>=4 && v[2].type==_INT_ && v[3].type==_INT_){ 591 vecteur w(absint(deg)+1,1); 592 if (calc_mode(contextptr)==1 || abs_calc_mode(contextptr)==38){ 593 if (v[2]==v[3]) 594 return gensizeerr(contextptr); 595 for (;;){ 596 w[0]=int(giac_rand(contextptr)/(rand_max2+1.0)*(v[3].val-v[2].val+1)+v[2].val); 597 if (w[0].val) 598 break; 599 } 600 } 601 for (unsigned i=1;i<=(unsigned)absint(deg);++i){ 602 w[i]=int(giac_rand(contextptr)/(rand_max2+1.0)*(v[3].val-v[2].val+1)+v[2].val); 603 } 604 #ifdef GIAC_HAS_STO_38 605 return w; 606 #else 607 return symb_horner(w,x); 608 #endif 609 } 610 if (vs==4){ 611 if (f.type==_FUNC) 612 f=symbolic(*f._FUNCptr,v.back()); 613 else 614 f=symb_of(f,v.back()); 615 } 616 if (vs>4){ 617 if (f.type==_FUNC) 618 f=symbolic(*f._FUNCptr,gen(vecteur(v.begin()+3,v.end()),_SEQ__VECT)); 619 else 620 f=symb_of(f,gen(vecteur(v.begin()+3,v.end()),_SEQ__VECT)); 621 } 622 } 623 vecteur w; 624 if (calc_mode(contextptr)==1 || abs_calc_mode(contextptr)==38){ 625 for (int essai=0;essai<1000;++essai){ 626 w=vranm(absint(deg)+1,f,contextptr); 627 if (!is_zero(w.front())) 628 break; 629 } 630 } 631 else { 632 w=vranm(absint(deg),f,contextptr); 633 w.insert(w.begin(),1); 634 } 635 #ifdef GIAC_HAS_STO_38 636 return w; 637 #else 638 return (deg>=1024 || (f.type==_VECT && f._VECTptr->empty()) )?gen(w,_POLY1__VECT):symb_horner(w,x); 639 #endif 640 } 641 static const char _randPoly_s[]="randPoly"; 642 static define_unary_function_eval (__randPoly,&_randPoly,_randPoly_s); 643 define_unary_function_ptr5( at_randPoly ,alias_at_randPoly,&__randPoly,0,true); 644 645 static const char _randpoly_s[]="randpoly"; 646 static define_unary_function_eval (__randpoly,&_randPoly,_randpoly_s); 647 define_unary_function_ptr5( at_randpoly ,alias_at_randpoly,&__randpoly,0,true); 648 _nInt(const gen & g,GIAC_CONTEXT)649 gen _nInt(const gen & g,GIAC_CONTEXT){ 650 if ( g.type==_STRNG && g.subtype==-1) return g; 651 if (g.type!=_VECT || g._VECTptr->size()!=4) 652 return gensizeerr(contextptr); 653 return evalf(symbolic(at_integrate,g),1,contextptr); 654 } 655 static const char _nInt_s[]="nInt"; 656 static define_unary_function_eval (__nInt,&_nInt,_nInt_s); 657 define_unary_function_ptr5( at_nInt ,alias_at_nInt,&__nInt,0,true); 658 _nDeriv(const gen & g,GIAC_CONTEXT)659 gen _nDeriv(const gen & g,GIAC_CONTEXT){ 660 if ( g.type==_STRNG && g.subtype==-1) return g; 661 vecteur v(gen2vecteur(g)); 662 if (v.size()<2) 663 return gensizeerr(contextptr); 664 gen step(0.001); 665 if (v.size()>2) 666 step=v[2]; 667 return evalf(rdiv(subst(v[0],v[1],v[1]+step,false,contextptr)-subst(v[0],v[1],v[1]-step,false,contextptr),2*step,contextptr),1,contextptr); 668 } 669 static const char _nDeriv_s[]="nDeriv"; 670 static define_unary_function_eval (__nDeriv,&_nDeriv,_nDeriv_s); 671 define_unary_function_ptr5( at_nDeriv ,alias_at_nDeriv,&__nDeriv,0,true); 672 _avgRC(const gen & g,GIAC_CONTEXT)673 gen _avgRC(const gen & g,GIAC_CONTEXT){ 674 if ( g.type==_STRNG && g.subtype==-1) return g; 675 vecteur v(gen2vecteur(g)); 676 if (v.size()<2) 677 return gensizeerr(contextptr); 678 gen step(0.001); 679 if (v.size()>2) 680 step=v[2]; 681 return evalf(rdiv(subst(v[0],v[1],v[1]+step,false,contextptr)-subst(v[0],v[1],v[1],false,contextptr),step,contextptr),1,contextptr); 682 } 683 static const char _avgRC_s[]="avgRC"; 684 static define_unary_function_eval (__avgRC,&_avgRC,_avgRC_s); 685 define_unary_function_ptr5( at_avgRC ,alias_at_avgRC,&__avgRC,0,true); 686 _fMin(const gen & g,GIAC_CONTEXT)687 gen _fMin(const gen & g,GIAC_CONTEXT){ 688 if ( g.type==_STRNG && g.subtype==-1) return g; 689 vecteur v(gen2vecteur(g)); 690 if (v.size()==1) 691 v.push_back(vx_var); 692 if (v.size()==4) // fMin(func,[constraints],[variables],[guess]) 693 return fmin_cobyla(v[0],gen2vecteur(v[1]),gen2vecteur(v[2]),gen2vecteur(v[3]),undef,undef,contextptr); 694 if (v.size()==5) // fMin(func,[constraints],[variables],[guess],eps) 695 return fmin_cobyla(v[0],gen2vecteur(v[1]),gen2vecteur(v[2]),gen2vecteur(v[3]),v[4],undef,contextptr); 696 if (v.size()==6) // fMin(func,[constraints],[variables],[guess],eps,maxiter) 697 return fmin_cobyla(v[0],gen2vecteur(v[1]),gen2vecteur(v[2]),gen2vecteur(v[3]),v[4],v[5],contextptr); 698 gen w(fminmax(v,4,contextptr)); 699 if (is_undef(w)) return w; 700 return solvepostprocess(w,v[1],contextptr); 701 } 702 static const char _fMin_s[]="fMin"; 703 static define_unary_function_eval (__fMin,&_fMin,_fMin_s); 704 define_unary_function_ptr5( at_fMin ,alias_at_fMin,&__fMin,0,true); 705 _fMax(const gen & g,GIAC_CONTEXT)706 gen _fMax(const gen & g,GIAC_CONTEXT){ 707 if ( g.type==_STRNG && g.subtype==-1) return g; 708 vecteur v(gen2vecteur(g)); 709 if (v.size()==1) 710 v.push_back(vx_var); 711 if (v.size()==4) // fMax(func,[constraints],[variables],[guess]) 712 return fmin_cobyla(-v[0],gen2vecteur(v[1]),gen2vecteur(v[2]),gen2vecteur(v[3]),undef,undef,contextptr); 713 if (v.size()==5) // fMax(func,[constraints],[variables],[guess],eps) 714 return fmin_cobyla(-v[0],gen2vecteur(v[1]),gen2vecteur(v[2]),gen2vecteur(v[3]),v[4],undef,contextptr); 715 if (v.size()==6) // fMax(func,[constraints],[variables],[guess],eps,maxiter) 716 return fmin_cobyla(-v[0],gen2vecteur(v[1]),gen2vecteur(v[2]),gen2vecteur(v[3]),v[4],v[5],contextptr); 717 gen w(fminmax(v,5,contextptr)); 718 if (is_undef(w)) return w; 719 return solvepostprocess(w,v[1],contextptr); 720 } 721 static const char _fMax_s[]="fMax"; 722 static define_unary_function_eval (__fMax,&_fMax,_fMax_s); 723 define_unary_function_ptr5( at_fMax ,alias_at_fMax,&__fMax,0,true); 724 _taylor(const gen & g,GIAC_CONTEXT)725 gen _taylor(const gen & g,GIAC_CONTEXT){ 726 if ( g.type==_STRNG && g.subtype==-1) return g; 727 /* if (xcas_mode(contextptr)==0) 728 return _series(g); */ 729 vecteur v(gen2vecteur(g)); 730 if (v.empty()) 731 return gentoofewargs("Taylor needs 3 args"); 732 if (v.back().type==_INT_ && v.back().subtype==_INT_MAPLECONVERSION && v.back().val==_POLY1__VECT){ 733 gen p=v.back(); 734 v.pop_back(); 735 gen res=_taylor(gen(v,_SEQ__VECT),contextptr); 736 res=_convert(makesequence(res,p),contextptr); 737 return res; 738 } 739 if (v.size()<2) 740 v.push_back(vx_var); 741 if (v.size()<3) 742 v.push_back(5); 743 else is_integral(v[2]); 744 gen x0; 745 if (v.size()==4) 746 x0=v[3]; 747 if (is_equal(v[1])) 748 return _series(makesequence(v[0],v[1],v[2]),contextptr); 749 return _series(makesequence(v[0],symbolic(at_equal,makesequence(v[1],x0)),v[2]),contextptr); 750 } 751 static const char _taylor_s[]="taylor"; 752 static define_unary_function_eval (__taylor,&_taylor,_taylor_s); 753 define_unary_function_ptr5( at_taylor ,alias_at_taylor,&__taylor,0,true); 754 arclen(const gen & g,GIAC_CONTEXT)755 gen arclen(const gen & g,GIAC_CONTEXT){ 756 if ( g.type==_STRNG && g.subtype==-1) return g; 757 vecteur v(gen2vecteur(g)); 758 if (!v.empty() && v.front().type==_VECT){ 759 // more than one arc? 760 if (!v.front()._VECTptr->empty() && v.front()._VECTptr->back().is_symb_of_sommet(at_pnt)){ 761 v.front()=v.front()._VECTptr->back(); 762 *logptr(contextptr) << gettext("Selecting last arc") << '\n'; 763 } 764 } 765 if (!v.empty() && v.front().is_symb_of_sommet(at_pnt)){ 766 if (v.size()==1) 767 return _perimetre(g,contextptr); 768 if (v.size()!=3) 769 return gensizeerr(contextptr); 770 gen g=remove_at_pnt(v[0]); 771 if (g.is_symb_of_sommet(at_cercle)){ 772 gen centre,rayon; 773 if (!centre_rayon(g,centre,rayon,true,contextptr)) 774 return gensizeerr(contextptr); // don't care about radius 775 return (v[2]-v[1])*rayon; 776 } 777 if (g.is_symb_of_sommet(at_curve) && g._SYMBptr->feuille.type==_VECT && g._SYMBptr->feuille._VECTptr->size()>1){ 778 g=(*g._SYMBptr->feuille._VECTptr)[0]; 779 if (g.type==_VECT && g._VECTptr->size()>2){ 780 gen f=g._VECTptr->front(); 781 if (g._VECTptr->size()>6) 782 f=(*g._VECTptr)[6]; 783 gen x=(*g._VECTptr)[1]; 784 gen fprime=derive(f,x,contextptr); 785 if (is_undef(fprime)) return fprime; 786 fprime=abs(fprime,contextptr); 787 if (v[1].is_symb_of_sommet(at_pnt)) 788 v[1]=projection(v[0],v[1],contextptr); 789 if (v[2].is_symb_of_sommet(at_pnt)) 790 v[2]=projection(v[0],v[2],contextptr); 791 if (is_greater(v[1],v[2],contextptr)) 792 return _integrate(gen(makevecteur(fprime,x,v[2],v[1]),_SEQ__VECT),contextptr); 793 return _integrate(gen(makevecteur(fprime,x,v[1],v[2]),_SEQ__VECT),contextptr); 794 } 795 } 796 return gensizeerr(contextptr); 797 } 798 if (v.size()==3) 799 v.insert(v.begin()+1,ggb_var(v.front())); 800 if (v.size()!=4 || v[1].type!=_IDNT) 801 return gentoofewargs("arcLen"); 802 gen fprime=derive(v[0],v[1],contextptr); 803 if (is_undef(fprime)) return fprime; 804 if (fprime.type==_VECT) 805 fprime=_l2norm(fprime,contextptr); 806 else 807 fprime=sqrt(normal(sq(fprime)+1,contextptr),contextptr); 808 return _integrate(gen(makevecteur(fprime,v[1],v[2],v[3]),_SEQ__VECT),contextptr); 809 } _arcLen(const gen & g,GIAC_CONTEXT)810 gen _arcLen(const gen & g,GIAC_CONTEXT){ 811 bool b=complex_variables(contextptr); 812 complex_variables(false,contextptr); 813 gen res=arclen(g,contextptr); 814 complex_variables(b,contextptr); 815 return res; 816 } 817 static const char _arcLen_s[]="arcLen"; 818 static define_unary_function_eval (__arcLen,&_arcLen,_arcLen_s); 819 define_unary_function_ptr5( at_arcLen ,alias_at_arcLen,&__arcLen,0,true); 820 821 static const char _arclen_s[]="arclen"; 822 static define_unary_function_eval (__arclen,&_arcLen,_arclen_s); 823 define_unary_function_ptr5( at_arclen ,alias_at_arclen,&__arclen,0,true); 824 825 // find T,N,B,kappa,tau, Nsurkappa (center of osc circle-M) return dimension frenet(const gen & g,gen & M,gen & T,gen & N,gen & B,gen & kappa,gen & Nsurkappa,gen & tau,gen & t,bool compute_torsion,GIAC_CONTEXT)826 gen frenet(const gen &g,gen & M,gen & T, gen &N, gen &B, gen & kappa,gen &Nsurkappa,gen & tau,gen & t,bool compute_torsion,GIAC_CONTEXT){ 827 if (g.is_symb_of_sommet(at_pnt)){ 828 if (g._SYMBptr->feuille.type==_VECT && g._SYMBptr->feuille._VECTptr->size()>=2){ // element 829 gen arg=(*g._SYMBptr->feuille._VECTptr)[1]; 830 if (arg.type==_VECT) 831 return frenet((*arg._VECTptr)[1],M,T,N,B,kappa,Nsurkappa,tau,t,compute_torsion,contextptr); 832 } 833 return frenet(remove_at_pnt(g),M,T,N,B,kappa,Nsurkappa,tau,t,compute_torsion,contextptr); 834 } 835 if (g.is_symb_of_sommet(at_curve)){ 836 gen f=g._SYMBptr->feuille; 837 gen res=frenet(f[0],M,T,N,B,kappa,Nsurkappa,tau,t,compute_torsion,contextptr); 838 return res; 839 } 840 if (g.type!=_VECT || g._VECTptr->size()<2) 841 return gensizeerr(contextptr); 842 vecteur v=*g._VECTptr; 843 gen f=v[0],x=v[1],x0=undef; 844 if (f.is_symb_of_sommet(at_pnt)){ 845 x0=v[1]; 846 if (x0.is_symb_of_sommet(at_pnt)) 847 x0=projection(f,x0,contextptr); 848 f=remove_at_pnt(f); 849 if (!f.is_symb_of_sommet(at_curve)) 850 return gensizeerr(contextptr); 851 f=f._SYMBptr->feuille[0]; 852 x=f[1]; 853 t=makesequence(x,f[2],f[3],f[4]); 854 f=f[0]; 855 } 856 else 857 t=x; 858 if (v.size()==3) 859 x0=v[2]; 860 if (v.size()>3) 861 t=gen(vecteur(v.begin()+1,v.begin()+4),_SEQ__VECT); 862 if (f.type!=_VECT){ 863 gen r,i; 864 reim(f,r,i,contextptr); 865 f=makevecteur(r,i); 866 } 867 M=f; 868 int dim=int(f._VECTptr->size()); 869 gen vitesse=derive(f,x,contextptr),v2=normal(l2norm2(vitesse),contextptr); 870 gen sqrtv2=sqrt(v2,contextptr); // v=ds/dt 871 T=vitesse/sqrtv2; 872 gen accel=derive(vitesse,x,contextptr); 873 if (dim==2 && T.type==_VECT && T._VECTptr->size()==2){ 874 kappa=normal(vitesse[0]*accel[1]-vitesse[1]*accel[0],contextptr)/pow(v2,2)*sqrtv2; 875 Nsurkappa=normal(v2/(vitesse[0]*accel[1]-vitesse[1]*accel[0])*makevecteur(-vitesse[1],vitesse[0]),contextptr); 876 N=makevecteur(-T._VECTptr->back(),T._VECTptr->front()); 877 } 878 else { 879 gen an=normal(accel-(scalar_product(accel,vitesse,contextptr)/v2)*vitesse,contextptr); // normal accel 880 gen normean=_l2norm(an,contextptr); 881 N=an/normean; 882 kappa=normean/v2; 883 Nsurkappa=normal(an*v2/l2norm2(an),contextptr); 884 } 885 if (dim!=3 || !compute_torsion) 886 B=tau=undef; 887 else { 888 B=cross(T,N,contextptr); 889 gen f3=derive(accel,x,contextptr); 890 tau=_det(makesequence(vitesse,accel,f3),contextptr)/l2norm2(cross(vitesse,accel,contextptr)); 891 } 892 if (!is_undef(x0)){ 893 M=subst(M,x,x0,false,contextptr); 894 T=subst(T,x,x0,false,contextptr); 895 N=subst(N,x,x0,false,contextptr); 896 B=subst(B,x,x0,false,contextptr); 897 tau=subst(tau,x,x0,false,contextptr); 898 kappa=subst(kappa,x,x0,false,contextptr); 899 Nsurkappa=subst(Nsurkappa,x,x0,false,contextptr); 900 } 901 return dim; 902 } 903 // curvature([x(t),y(t)],t) curvature(const gen & g,GIAC_CONTEXT)904 gen curvature(const gen & g,GIAC_CONTEXT){ 905 if (g.is_symb_of_sommet(at_pnt)){ 906 if (g._SYMBptr->feuille.type==_VECT && g._SYMBptr->feuille._VECTptr->size()>=2){ // element 907 gen arg=(*g._SYMBptr->feuille._VECTptr)[1]; 908 if (arg.type==_VECT) 909 return curvature((*arg._VECTptr)[1],contextptr); 910 } 911 return curvature(remove_at_pnt(g),contextptr); 912 } 913 if (g.is_symb_of_sommet(at_curve)){ 914 gen f=g._SYMBptr->feuille; 915 return curvature(f[0],contextptr); 916 } 917 if (g.type!=_VECT || g._VECTptr->size()<2) 918 return gensizeerr(contextptr); 919 vecteur v=*g._VECTptr; 920 gen f=v[0],x=v[1],x0(undef); 921 if (f.is_symb_of_sommet(at_pnt)){ 922 x0=v[1]; 923 if (x0.is_symb_of_sommet(at_pnt)) 924 x0=projection(f,x0,contextptr); 925 f=remove_at_pnt(f); 926 if (!f.is_symb_of_sommet(at_curve)) 927 return gensizeerr(contextptr); 928 f=f._SYMBptr->feuille[0]; 929 x=f[1]; 930 f=f[0]; 931 } 932 if (v.size()>=3) 933 x0=v[2]; 934 if (f.type!=_VECT){ 935 gen r,i; 936 reim(f,r,i,contextptr); 937 if (is_zero(i)) 938 f=makevecteur(x,r); 939 else 940 f=makevecteur(r,i); 941 } 942 int dim=int(f._VECTptr->size()); 943 gen vitesse=derive(f,x,contextptr),v2=normal(l2norm2(vitesse),contextptr); 944 gen sqrtv2=sqrt(v2,contextptr); // v=ds/dt 945 gen accel=derive(vitesse,x,contextptr),res; 946 if (dim==2) 947 res= normal(vitesse[0]*accel[1]-vitesse[1]*accel[0],contextptr)/pow(v2,2)*sqrtv2; 948 else { 949 if (dim==3){ 950 gen f3=cross(vitesse,accel,contextptr); 951 res= _l2norm(f3,contextptr)/pow(v2,2)*sqrtv2; 952 } 953 else { 954 gen an=accel-(scalar_product(accel,vitesse,contextptr)/v2)*vitesse; // normal 955 res=_l2norm(an,contextptr)/v2; 956 } 957 } 958 if (!is_undef(x0)) 959 res=subst(res,x,x0,false,contextptr); 960 return res; 961 } _curvature(const gen & g,GIAC_CONTEXT)962 gen _curvature(const gen & g,GIAC_CONTEXT){ 963 bool b=complex_variables(contextptr); 964 complex_variables(false,contextptr); 965 gen res=curvature(g,contextptr); 966 complex_variables(b,contextptr); 967 return res; 968 } 969 static const char _curvature_s[]="curvature"; 970 static define_unary_function_eval (__curvature,&_curvature,_curvature_s); 971 define_unary_function_ptr5( at_curvature ,alias_at_curvature,&__curvature,0,true); 972 _frenet(const gen & g,GIAC_CONTEXT)973 gen _frenet(const gen & g,GIAC_CONTEXT){ 974 bool b=complex_variables(contextptr); 975 complex_variables(false,contextptr); 976 gen t,M,T,N,B,kappa,Nsurkappa,tau,dim=frenet(g,M,T,N,B,kappa,Nsurkappa,tau,t,true,contextptr); 977 complex_variables(b,contextptr); 978 if (dim.type!=_INT_) 979 return dim; 980 if (dim.val==2) 981 return makesequence(kappa,M+Nsurkappa,T,N); 982 else 983 return makesequence(kappa,M+Nsurkappa,tau,T,N,B); 984 } 985 static const char _frenet_s[]="frenet"; 986 static define_unary_function_eval (__frenet,&_frenet,_frenet_s); 987 define_unary_function_ptr5( at_frenet ,alias_at_frenet,&__frenet,0,true); 988 _osculating_circle(const gen & args,GIAC_CONTEXT)989 gen _osculating_circle(const gen & args,GIAC_CONTEXT){ 990 vecteur attributs(1,default_color(contextptr)); 991 vecteur v(seq2vecteur(args)); 992 int s=read_attributs(v,attributs,contextptr); 993 if (s==0) 994 return gendimerr(contextptr); 995 gen g; 996 if (s==1) 997 g=v.front(); 998 else 999 g=gen(vecteur(v.begin(),v.begin()+s),_SEQ__VECT); 1000 bool b=complex_variables(contextptr); 1001 complex_variables(false,contextptr); 1002 gen t,M,T,N,B,kappa,Nsurkappa,tau,dim=frenet(g,M,T,N,B,kappa,Nsurkappa,tau,t,false,contextptr); 1003 complex_variables(b,contextptr); 1004 if (dim.type!=_INT_) 1005 return dim; 1006 if (dim.val==2) 1007 return put_attributs(_cercle(makesequence(_point(M,contextptr),_point(M+2*Nsurkappa,contextptr)),contextptr),attributs,contextptr); 1008 return gendimerr(contextptr); 1009 } 1010 static const char _osculating_circle_s[]="osculating_circle"; 1011 static define_unary_function_eval (__osculating_circle,&_osculating_circle,_osculating_circle_s); 1012 define_unary_function_ptr5( at_osculating_circle ,alias_at_osculating_circle,&__osculating_circle,0,true); 1013 _evolute(const gen & args,GIAC_CONTEXT)1014 gen _evolute(const gen & args,GIAC_CONTEXT){ 1015 vecteur attributs(1,default_color(contextptr)); 1016 vecteur v(seq2vecteur(args)); 1017 int s=read_attributs(v,attributs,contextptr); 1018 if (s==0) 1019 return gendimerr(contextptr); 1020 gen g; 1021 if (s==1) 1022 g=v.front(); 1023 else 1024 g=gen(vecteur(v.begin(),v.begin()+s),_SEQ__VECT); 1025 bool b=complex_variables(contextptr); 1026 complex_variables(false,contextptr); 1027 gen t,M,T,N,B,kappa,Nsurkappa,tau,dim=frenet(g,M,T,N,B,kappa,Nsurkappa,tau,t,false,contextptr); 1028 complex_variables(b,contextptr); 1029 if (dim.type!=_INT_) 1030 return dim; 1031 if (dim.val==2){ 1032 if (t.type==_VECT) 1033 t=gen(mergevecteur(vecteur(1,M+Nsurkappa),*t._VECTptr),_SEQ__VECT); 1034 else 1035 t=gen(makevecteur(M+Nsurkappa,t),_SEQ__VECT); 1036 return put_attributs(_plotparam(t,contextptr),attributs,contextptr); 1037 } 1038 return gendimerr(contextptr); 1039 } 1040 static const char _evolute_s[]="evolute"; 1041 static define_unary_function_eval (__evolute,&_evolute,_evolute_s); 1042 define_unary_function_ptr5( at_evolute ,alias_at_evolute,&__evolute,0,true); 1043 _dim(const gen & g,GIAC_CONTEXT)1044 gen _dim(const gen & g,GIAC_CONTEXT){ 1045 if ( g.type==_STRNG && g.subtype==-1) return g; 1046 if (!ckmatrix(g)) 1047 return _size(g,contextptr); 1048 vecteur res(2); 1049 if (!g._VECTptr->empty()){ 1050 res[0]=int(g._VECTptr->size()); 1051 res[1]=int(g._VECTptr->front()._VECTptr->size()); 1052 } 1053 return res; 1054 } 1055 static const char _dim_s[]="dim"; 1056 static define_unary_function_eval (__dim,&_dim,_dim_s); 1057 define_unary_function_ptr5( at_dim ,alias_at_dim,&__dim,0,true); 1058 1059 // FIXME: the print() should have an additionnal format argument 1060 // that would cover normal, tex, C, and formatted output format(const gen & g,const string & forme,GIAC_CONTEXT)1061 static string format(const gen & g,const string & forme,GIAC_CONTEXT){ 1062 if (g.type == _ZINT){ 1063 string txt = g.print(); 1064 if (!forme.empty()){ 1065 char ch=forme[0]; 1066 if (tolower(ch) == 'f') 1067 return txt; 1068 if (forme.size()<2) 1069 return txt; 1070 unsigned int digits = atol(forme.substr(1,forme.size()-1).c_str()) - 1; 1071 if (tolower(ch) == 'e') 1072 digits ++; 1073 digits = digits < 2 ? 2 : digits; 1074 if (digits + 1 < txt.size()){ 1075 string tmp = txt.substr(0, 1) + "." + txt.substr(1, digits) + "e+" + print_INT_(int(txt.size()) - 1); 1076 return tmp; 1077 } 1078 } 1079 return txt; 1080 } 1081 else { 1082 gen tmp=evalf_double(g,eval_level(contextptr),contextptr); 1083 string saveforme=format_double(contextptr); 1084 format_double(contextptr)=forme; 1085 string s=tmp.print(contextptr); 1086 format_double(contextptr)=saveforme; 1087 return s; 1088 } 1089 } _format(const gen & g,GIAC_CONTEXT)1090 gen _format(const gen & g,GIAC_CONTEXT){ 1091 if ( g.type==_STRNG && g.subtype==-1) return g; 1092 vecteur v(gen2vecteur(g)); 1093 size_t vs=v.size(); 1094 if (vs>=2 && v[0].type==_STRNG){ 1095 const string & fmt=*v[0]._STRNGptr; 1096 size_t fs=fmt.size(),count=1; 1097 string res; 1098 for (size_t i=0;i<fs;++i){ 1099 if (i==fs-1 || fmt[i]!='{' || (i!=0 && fmt[i-1]=='\\')){ 1100 res += fmt[i]; 1101 continue; 1102 } 1103 if (fmt[i+1]=='}'){ 1104 ++i; 1105 if (count<vs) 1106 res += v[count].type==_STRNG? *v[count]._STRNGptr: v[count].print(contextptr); 1107 else 1108 return gendimerr(contextptr); 1109 ++count; 1110 continue; 1111 } 1112 int c=0; 1113 for (++i;i<fs && fmt[i]>='0' && fmt[i]<='9';++i){ 1114 c=c*10+int(fmt[i]-'0'); 1115 } 1116 if (i==fs || fmt[i]!='}') 1117 return gendimerr(contextptr); 1118 c++; 1119 res += v[c].type==_STRNG? *v[c]._STRNGptr: v[c].print(contextptr); 1120 ++count; 1121 } 1122 return string2gen(res,false); 1123 } 1124 if (vs!=2 || v[1].type!=_STRNG) 1125 return gensizeerr(contextptr); 1126 return string2gen(format(v.front(),*v[1]._STRNGptr,contextptr),false); 1127 } 1128 static const char _format_s[]="format"; 1129 static define_unary_function_eval (__format,&_format,_format_s); 1130 define_unary_function_ptr5( at_format ,alias_at_format,&__format,0,true); 1131 _inString(const gen & g,GIAC_CONTEXT)1132 gen _inString(const gen & g,GIAC_CONTEXT){ 1133 if ( g.type==_STRNG && g.subtype==-1) return g; 1134 vecteur v(gen2vecteur(g)); 1135 if (v.size()<2 || v[0].type!=_STRNG || v[1].type!=_STRNG) 1136 return gensizeerr(contextptr); 1137 int shift = array_start(contextptr); //xcas_mode(contextptr)!=0 || abs_calc_mode(contextptr)==38; 1138 int debut=shift; 1139 if (v.size()>2 && v[2].type==_INT_) 1140 debut=v[2].val; 1141 return v[0]._STRNGptr->find(*v[1]._STRNGptr,debut-shift)+shift; 1142 } 1143 static const char _inString_s[]="inString"; 1144 static define_unary_function_eval (__inString,&_inString,_inString_s); 1145 define_unary_function_ptr5( at_inString ,alias_at_inString,&__inString,0,true); 1146 _left(const gen & g,GIAC_CONTEXT)1147 gen _left(const gen & g,GIAC_CONTEXT){ 1148 if ( g.type==_STRNG && g.subtype==-1) return g; 1149 if (g.type==_SYMB && g._SYMBptr->feuille.type==_VECT && !g._SYMBptr->feuille._VECTptr->empty()) 1150 return g._SYMBptr->feuille._VECTptr->front(); 1151 #if defined HAVE_LIBMPFI && !defined NO_RTTI 1152 if (g.type==_REAL){ 1153 if (real_interval * ptr=dynamic_cast<real_interval *>(g._REALptr)){ 1154 mpfr_t tmp; mpfr_init2(tmp,mpfi_get_prec(ptr->infsup)); 1155 mpfi_get_left(tmp,ptr->infsup); 1156 gen einf=real_object(tmp); 1157 mpfr_clear(tmp); 1158 return einf; 1159 } 1160 } 1161 #endif 1162 if (g.type==_INT_ || g.type==_DOUBLE_) 1163 return _tourne_gauche(g,contextptr); 1164 vecteur v(1,g); 1165 if (g.type==_VECT && g.subtype==_SEQ__VECT){ 1166 v=*g._VECTptr; 1167 if (v.empty()) 1168 return _tourne_gauche(g,contextptr); 1169 } 1170 if (v.size()<2 || !is_integral(v[1]) || v[1].type!=_INT_) 1171 return g; 1172 if (v[0].type==_STRNG) 1173 return string2gen(v[0]._STRNGptr->substr(0,v[1].val),false); 1174 if (v[0].type==_VECT){ 1175 const_iterateur it=v[0]._VECTptr->begin(),itend=v[0]._VECTptr->end(); 1176 int length=giacmax(0,giacmin(int(itend-it),v[1].val)); 1177 return gen(vecteur(it,it+length),v[0].subtype); 1178 } 1179 return g; 1180 } 1181 static const char _left_s[]="left"; 1182 static define_unary_function_eval (__left,&_left,_left_s); 1183 define_unary_function_ptr5( at_left ,alias_at_left,&__left,0,true); 1184 1185 static const char _gauche_s[]="gauche"; 1186 static define_unary_function_eval (__gauche,&_left,_gauche_s); 1187 define_unary_function_ptr5( at_gauche ,alias_at_gauche,&__gauche,0,true); 1188 _right(const gen & g,GIAC_CONTEXT)1189 gen _right(const gen & g,GIAC_CONTEXT){ 1190 if ( g.type==_STRNG && g.subtype==-1) return g; 1191 if (g.type==_SYMB && g._SYMBptr->feuille.type==_VECT && !g._SYMBptr->feuille._VECTptr->empty()) 1192 return g._SYMBptr->feuille._VECTptr->back(); 1193 if (g.type==_INT_ || g.type==_DOUBLE_) 1194 return _tourne_droite(g,contextptr); 1195 #if defined HAVE_LIBMPFI && !defined NO_RTTI 1196 if (g.type==_REAL){ 1197 if (real_interval * ptr=dynamic_cast<real_interval *>(g._REALptr)){ 1198 mpfr_t tmp; mpfr_init2(tmp,mpfi_get_prec(ptr->infsup)); 1199 mpfi_get_right(tmp,ptr->infsup); 1200 gen einf=real_object(tmp); 1201 mpfr_clear(tmp); 1202 return einf; 1203 } 1204 } 1205 #endif 1206 vecteur v(1,g); 1207 if (g.type==_VECT && g.subtype==_SEQ__VECT){ 1208 v=*g._VECTptr; 1209 if (v.empty()) 1210 return _tourne_droite(g,contextptr); 1211 } 1212 if (v.size()<2 || !is_integral(v[1]) || v[1].type!=_INT_) 1213 return g; 1214 if (v[0].type==_STRNG){ 1215 string & s=*v[0]._STRNGptr; 1216 int l=int(s.size()); 1217 int m=giacmin(giacmax(v[1].val,0),l); 1218 return string2gen(s.substr(l-m,m),false); 1219 } 1220 if (v[0].type==_VECT){ 1221 const_iterateur it=v[0]._VECTptr->begin(),itend=v[0]._VECTptr->end(); 1222 int length=giacmax(0,giacmin(int(itend-it),v[1].val)); 1223 return gen(vecteur(itend-length,itend),v[0].subtype); 1224 } 1225 return g; 1226 } 1227 static const char _right_s[]="right"; 1228 static define_unary_function_eval (__right,&_right,_right_s); 1229 define_unary_function_ptr5( at_right ,alias_at_right,&__right,0,true); 1230 1231 static const char _droit_s[]="droit"; 1232 static define_unary_function_eval (__droit,&_right,_droit_s); 1233 define_unary_function_ptr5( at_droit ,alias_at_droit,&__droit,0,true); 1234 _mid(const gen & g,GIAC_CONTEXT)1235 gen _mid(const gen & g,GIAC_CONTEXT){ 1236 if ( g.type==_STRNG && g.subtype==-1) return g; 1237 vecteur v(1,g); 1238 if (g.type==_VECT && g.subtype==_SEQ__VECT) 1239 v=*g._VECTptr; 1240 if (v.size()<2 || v[1].type!=_INT_) 1241 return g; 1242 int shift = array_start(contextptr); //xcas_mode(contextptr)!=0 || abs_calc_mode(contextptr)==38; 1243 int debut=v[1].val-shift; 1244 int nbre=RAND_MAX; 1245 if (v.size()>2 && v[2].type==_INT_) 1246 nbre=v[2].val; 1247 if (v[0].type==_STRNG){ 1248 string & s=*v[0]._STRNGptr; 1249 if (debut>=signed(s.size()) || debut<0) 1250 return string2gen("",false); 1251 int m=giacmin(giacmax(nbre,0),int(s.size())); 1252 return string2gen(s.substr(debut,m),false); 1253 } 1254 if (v[0].type==_VECT){ 1255 const_iterateur it=v[0]._VECTptr->begin(),itend=v[0]._VECTptr->end(); 1256 if (debut>=itend-it || debut<0) 1257 return gen(vecteur(0),v[0].subtype); 1258 int length=giacmax(0,giacmin(int(itend-it)-debut,nbre)); 1259 return gen(vecteur(it+debut,it+debut+length),v[0].subtype); 1260 } 1261 return g; 1262 } 1263 static const char _mid_s[]="mid"; 1264 static define_unary_function_eval (__mid,&_mid,_mid_s); 1265 define_unary_function_ptr5( at_mid ,alias_at_mid,&__mid,0,true); 1266 _ord(const gen & g,GIAC_CONTEXT)1267 gen _ord(const gen & g,GIAC_CONTEXT){ 1268 if ( g.type==_STRNG && g.subtype==-1) return g; 1269 if (g.type==_VECT) 1270 return apply(g,_ord,contextptr); 1271 if (g.type!=_STRNG || !g._STRNGptr->size()) 1272 return gensizeerr(contextptr); 1273 return int((*g._STRNGptr)[0]); 1274 } 1275 static const char _ord_s[]="ord"; 1276 static define_unary_function_eval (__ord,&_ord,_ord_s); 1277 define_unary_function_ptr5( at_ord ,alias_at_ord,&__ord,0,true); 1278 shiftrotate(const gen & g,bool right)1279 static gen shiftrotate(const gen & g,bool right){ 1280 bool shift=right; 1281 vecteur v(1,g); 1282 if (g.type==_VECT && g.subtype==_SEQ__VECT) 1283 v=*g._VECTptr; 1284 int nbre=-1; 1285 /* if (shift) 1286 nbre=1; */ 1287 if (v.size()>1 && v[1].type==_INT_) 1288 nbre=v[1].val; 1289 if (nbre<0){ 1290 nbre=-nbre; 1291 right=!right; 1292 } 1293 gen & a=v[0]; 1294 if (a.type==_INT_){ 1295 if (right) 1296 return a.val >> nbre; 1297 else 1298 return a.val << nbre; 1299 } 1300 if (a.type==_VECT){ 1301 const_iterateur it=a._VECTptr->begin(),itend=a._VECTptr->end(); 1302 nbre=giacmin(nbre,int(itend-it)); 1303 if (shift){ 1304 if (right) 1305 return gen(mergevecteur(vecteur(it+nbre,itend),vecteur(nbre,0)),a.subtype); 1306 return gen(mergevecteur(vecteur(nbre,0),vecteur(it,itend-nbre)),a.subtype); 1307 } 1308 if (right) 1309 return gen(mergevecteur(vecteur(itend-nbre,itend),vecteur(it,itend-nbre)),a.subtype); 1310 return gen(mergevecteur(vecteur(it+nbre,itend),vecteur(it,it+nbre)),a.subtype); 1311 } 1312 if (a.type==_STRNG){ 1313 string & s=*a._STRNGptr; 1314 int l=int(s.size()); 1315 nbre=giacmin(nbre,l); 1316 if (shift){ 1317 if (right) 1318 return string2gen(s.substr(nbre,l-nbre)+string(nbre,' '),false); 1319 return string2gen(string(l-nbre,' ')+s.substr(0,nbre),false); 1320 } 1321 if (right) 1322 return string2gen(s.substr(l-nbre,nbre)+s.substr(0,l-nbre),false); 1323 return string2gen(s.substr(nbre,l-nbre)+s.substr(0,nbre),false); 1324 } 1325 return a; 1326 } _rotate(const gen & g,GIAC_CONTEXT)1327 gen _rotate(const gen & g,GIAC_CONTEXT){ 1328 if ( g.type==_STRNG && g.subtype==-1) return g; 1329 return shiftrotate(g,false); 1330 } 1331 static const char _rotate_s[]="rotate"; 1332 static define_unary_function_eval (__rotate,&_rotate,_rotate_s); 1333 define_unary_function_ptr5( at_rotate ,alias_at_rotate,&__rotate,0,true); 1334 _shift(const gen & g,GIAC_CONTEXT)1335 gen _shift(const gen & g,GIAC_CONTEXT){ 1336 if ( g.type==_STRNG && g.subtype==-1) return g; 1337 return shiftrotate(g,true); 1338 } 1339 static const char _shift_s[]="shift"; 1340 static define_unary_function_eval (__shift,&_shift,_shift_s); 1341 define_unary_function_ptr5( at_shift ,alias_at_shift,&__shift,0,true); 1342 _augment(const gen & g,GIAC_CONTEXT)1343 gen _augment(const gen & g,GIAC_CONTEXT){ 1344 if ( g.type==_STRNG && g.subtype==-1) return g; 1345 return concat(g,false,contextptr); 1346 } 1347 static const char _augment_s[]="augment"; 1348 static define_unary_function_eval (__augment,&_augment,_augment_s); 1349 define_unary_function_ptr5( at_augment ,alias_at_augment,&__augment,0,true); 1350 _semi_augment(const gen & g,GIAC_CONTEXT)1351 gen _semi_augment(const gen & g,GIAC_CONTEXT){ 1352 if ( g.type==_STRNG && g.subtype==-1) return g; 1353 return concat(g,true,contextptr); 1354 } 1355 static const char _semi_augment_s[]="semi_augment"; 1356 static define_unary_function_eval (__semi_augment,&_semi_augment,_semi_augment_s); 1357 define_unary_function_ptr5( at_semi_augment ,alias_at_semi_augment,&__semi_augment,0,true); 1358 1359 static const char _crossP_s[]="crossP"; 1360 static define_unary_function_eval (__crossP,&_cross,_crossP_s); 1361 define_unary_function_ptr5( at_crossP ,alias_at_crossP,&__crossP,0,true); 1362 1363 static const char _scalarProduct_s[]="scalarProduct"; 1364 static define_unary_function_eval (__scalarProduct,&_dotprod,_scalarProduct_s); 1365 define_unary_function_ptr5( at_scalarProduct ,alias_at_scalarProduct,&__scalarProduct,0,true); 1366 1367 static const char _dotP_s[]="dotP"; 1368 static define_unary_function_eval (__dotP,&_dotprod,_dotP_s); 1369 define_unary_function_ptr5( at_dotP ,alias_at_dotP,&__dotP,0,true); 1370 _cumSum(const gen & g,GIAC_CONTEXT)1371 gen _cumSum(const gen & g,GIAC_CONTEXT){ 1372 if ( g.type==_STRNG && g.subtype==-1) return g; 1373 if (g.type!=_VECT) 1374 return gensizeerr(contextptr); 1375 vecteur & v=*g._VECTptr; 1376 if (g.subtype==_SEQ__VECT && v.size()==2){ 1377 if (v.back()==at_col) 1378 return _tran(_cumSum(_tran(v.front(),contextptr),contextptr),contextptr); 1379 if (v.back()==at_row) 1380 return _cumSum(v.front(),contextptr); 1381 } 1382 const_iterateur it=v.begin(),itend=v.end(); 1383 if (it==itend) 1384 return zero; 1385 vecteur res; 1386 res.reserve(itend-it); 1387 gen somme(it->type==_STRNG?string2gen("",false):zero*(*it)); 1388 for (;it!=itend;++it){ 1389 res.push_back(somme=somme+*it); 1390 } 1391 return gen(res,g.subtype); 1392 } 1393 static const char _cumSum_s[]="cumSum"; 1394 static define_unary_function_eval (__cumSum,&_cumSum,_cumSum_s); 1395 define_unary_function_ptr5( at_cumSum ,alias_at_cumSum,&__cumSum,0,true); 1396 1397 static const char _cumsum_s[]="cumsum"; 1398 static define_unary_function_eval (__cumsum,&_cumSum,_cumsum_s); 1399 define_unary_function_ptr5( at_cumsum ,alias_at_cumsum,&__cumsum,0,true); 1400 _rightapply(const gen & g,GIAC_CONTEXT)1401 static gen _rightapply(const gen & g,GIAC_CONTEXT){ 1402 if ( g.type==_STRNG && g.subtype==-1) return g; 1403 if (g.type!=_VECT) 1404 return _right(g,contextptr); 1405 return apply(g,_rightapply,contextptr); 1406 } _exp2list(const gen & g,GIAC_CONTEXT)1407 gen _exp2list(const gen & g,GIAC_CONTEXT){ 1408 if ( g.type==_STRNG && g.subtype==-1) return g; 1409 if (is_zero(g)) return vecteur(0); 1410 gen g1(g); 1411 if (!g1.is_symb_of_sommet(at_ou)) 1412 g1=eval(g,eval_level(contextptr),contextptr); 1413 g1=remove_and(g1,at_ou); 1414 g1=_rightapply(g1,contextptr); 1415 if (g1.type!=_VECT) 1416 return vecteur(1,g1); 1417 else 1418 return g1; 1419 } 1420 static const char _exp2list_s[]="exp2list"; 1421 static define_unary_function_eval_quoted (__exp2list,&_exp2list,_exp2list_s); 1422 define_unary_function_ptr5( at_exp2list ,alias_at_exp2list,&__exp2list,_QUOTE_ARGUMENTS,true); 1423 _list2exp(const gen & g,GIAC_CONTEXT)1424 gen _list2exp(const gen & g,GIAC_CONTEXT){ 1425 if ( g.type==_STRNG && g.subtype==-1) return g; 1426 if (g.type!=_VECT || g.subtype!=_SEQ__VECT || g._VECTptr->size()!=2 ) 1427 return gensizeerr(contextptr); 1428 gen gf=g._VECTptr->front(); 1429 if (gf.type==_VECT && gf._VECTptr->empty()) 1430 return change_subtype(0,_INT_BOOLEAN); 1431 int x=xcas_mode(contextptr); 1432 xcas_mode(3,contextptr); 1433 gen vars=g._VECTptr->back(); 1434 if (vars.type==_VECT && !ckmatrix(gf)) 1435 gf=vecteur(1,gf); 1436 gen res=solvepostprocess(gf,vars,contextptr); 1437 if (res.is_symb_of_sommet(at_ou) && res._SYMBptr->feuille.type==_VECT && res._SYMBptr->feuille._VECTptr->size()==1) 1438 res=res._SYMBptr->feuille._VECTptr->front(); 1439 xcas_mode(x,contextptr); 1440 return res; 1441 } 1442 static const char _list2exp_s[]="list2exp"; 1443 static define_unary_function_eval (__list2exp,&_list2exp,_list2exp_s); 1444 define_unary_function_ptr5( at_list2exp ,alias_at_list2exp,&__list2exp,0,true); 1445 _list2mat(const gen & g,GIAC_CONTEXT)1446 gen _list2mat(const gen & g,GIAC_CONTEXT){ 1447 if ( g.type==_STRNG && g.subtype==-1) return g; 1448 if (g.type!=_VECT) 1449 return gensizeerr(contextptr); 1450 vecteur v=*g._VECTptr; 1451 if (ckmatrix(g)){ 1452 for (unsigned i=0;i<v.size();++i){ 1453 v[i].subtype=0; 1454 } 1455 return gen(v,_MATRIX__VECT); 1456 } 1457 if (v.size()!=2) 1458 return gensizeerr(contextptr); 1459 gen taille=evalf_double(v[1],1,contextptr); 1460 if (g.subtype!=_SEQ__VECT || v.size()!=2 || v[0].type!=_VECT || taille.type!=_DOUBLE_) 1461 return gen(vecteur(1,v),_MATRIX__VECT); 1462 vecteur res; 1463 int nbre=giacmax(1,int(taille._DOUBLE_val)); 1464 const_iterateur it=v[0]._VECTptr->begin(),itend=v[0]._VECTptr->end(); 1465 for (;it!=itend;it+=nbre){ 1466 if (itend-it<nbre){ 1467 res.push_back(mergevecteur(vecteur(it,itend),vecteur(nbre-(itend-it)))); 1468 break; 1469 } 1470 res.push_back(vecteur(it,it+nbre)); 1471 } 1472 return gen(res,_MATRIX__VECT); 1473 } 1474 static const char _list2mat_s[]="list2mat"; 1475 static define_unary_function_eval (__list2mat,&_list2mat,_list2mat_s); 1476 define_unary_function_ptr5( at_list2mat ,alias_at_list2mat,&__list2mat,0,true); 1477 _deltalist(const gen & g,GIAC_CONTEXT)1478 gen _deltalist(const gen & g,GIAC_CONTEXT){ 1479 if ( g.type==_STRNG && g.subtype==-1) return g; 1480 if (g.type!=_VECT) 1481 return gensizeerr(contextptr); 1482 vecteur & v=*g._VECTptr; 1483 const_iterateur it=v.begin(),itend=v.end(); 1484 if (itend-it<2) 1485 return gendimerr(contextptr); 1486 vecteur res; 1487 res.reserve(itend-it-1); 1488 gen prec=*it; 1489 ++it; 1490 for (;it!=itend;++it){ 1491 res.push_back(*it-prec); 1492 prec=*it; 1493 } 1494 return gen(res,g.subtype); 1495 } 1496 static const char _deltalist_s[]="deltalist"; 1497 static define_unary_function_eval (__deltalist,&_deltalist,_deltalist_s); 1498 define_unary_function_ptr5( at_deltalist ,alias_at_deltalist,&__deltalist,0,true); 1499 _mat2list(const gen & g,GIAC_CONTEXT)1500 gen _mat2list(const gen & g,GIAC_CONTEXT){ 1501 if ( g.type==_STRNG && g.subtype==-1) return g; 1502 if (g.type!=_VECT) 1503 return gensizeerr(contextptr); 1504 vecteur & v=*g._VECTptr; 1505 int subt=abs_calc_mode(contextptr)==38?_LIST__VECT:0; 1506 if (!ckmatrix(v)) 1507 return gen(v,subt); 1508 vecteur res; 1509 const_iterateur it=v.begin(),itend=v.end(); 1510 for (;it!=itend;++it){ 1511 res=mergevecteur(res,*it->_VECTptr); 1512 } 1513 return gen(res,subt); 1514 } 1515 static const char _mat2list_s[]="mat2list"; 1516 static define_unary_function_eval (__mat2list,&_mat2list,_mat2list_s); 1517 define_unary_function_ptr5( at_mat2list ,alias_at_mat2list,&__mat2list,0,true); 1518 _newList(const gen & g,GIAC_CONTEXT)1519 gen _newList(const gen & g,GIAC_CONTEXT){ 1520 if ( g.type==_STRNG && g.subtype==-1) return g; 1521 if (absint(g.val) > LIST_SIZE_LIMIT) 1522 return genstabilityerr(contextptr); 1523 if (g.type!=_INT_) 1524 return gensizeerr(contextptr); 1525 return vecteur(absint(g.val)); 1526 } 1527 static const char _newList_s[]="newList"; 1528 static define_unary_function_eval (__newList,&_newList,_newList_s); 1529 define_unary_function_ptr5( at_newList ,alias_at_newList,&__newList,0,true); 1530 polyEval(const gen & p,const gen & x)1531 static gen polyEval(const gen & p,const gen & x){ 1532 if (x.type==_VECT) 1533 return apply2nd(p,x,polyEval); 1534 return horner(p,x); 1535 } _polyEval(const gen & g,GIAC_CONTEXT)1536 gen _polyEval(const gen & g,GIAC_CONTEXT){ 1537 if ( g.type==_STRNG && g.subtype==-1) return g; 1538 if (g.type!=_VECT || g._VECTptr->size()!=2) 1539 return gensizeerr(contextptr); 1540 vecteur & v=*g._VECTptr; 1541 return polyEval(v[0],v[1]); 1542 } 1543 static const char _polyEval_s[]="polyEval"; 1544 static define_unary_function_eval (__polyEval,&_polyEval,_polyEval_s); 1545 define_unary_function_ptr5( at_polyEval ,alias_at_polyEval,&__polyEval,0,true); 1546 _product(const gen & g,GIAC_CONTEXT)1547 gen _product(const gen & g,GIAC_CONTEXT){ 1548 if ( g.type==_STRNG && g.subtype==-1) return g; 1549 if (g.type==_VECT){ 1550 if (g.subtype!=_SEQ__VECT) 1551 return prodsum(g.eval(eval_level(contextptr),contextptr),true); 1552 vecteur v=*g._VECTptr; 1553 maple_sum_product_unquote(v,contextptr); 1554 int s=int(v.size()); 1555 if (s==2 && v[1]==at_prod){ 1556 gen tmp=eval(v[0],1,contextptr); 1557 if (tmp.type==_VECT){ 1558 gen res(1); 1559 const_iterateur it=tmp._VECTptr->begin(),itend=tmp._VECTptr->end(); 1560 for (;it!=itend;++it) 1561 res = res * *it; 1562 return res; 1563 } 1564 } 1565 if (!adjust_int_sum_arg(v,s)) 1566 return gensizeerr(contextptr); 1567 if (v.size()==4 && (v[2].type!=_INT_ || v[3].type!=_INT_)){ 1568 if (v[1].type!=_IDNT){ 1569 if (v[1].type!=_SYMB || lidnt(v[1]).empty()) 1570 return prodsum(g.eval(eval_level(contextptr),contextptr),true); 1571 identificateur tmp("x"); 1572 v[0]=quotesubst(v[0],v[1],tmp,contextptr); 1573 v[1]=tmp; 1574 gen res=_product(gen(v,g.subtype),contextptr); 1575 return quotesubst(res,tmp,v[1],contextptr); 1576 } 1577 v=quote_eval(v,makevecteur(v[1]),contextptr); 1578 gen n=v[1]; 1579 vecteur lv(1,n); 1580 lvar(v[0],lv); 1581 if (is_zero(derive(vecteur(lv.begin()+1,lv.end()),n,contextptr),contextptr)){ 1582 v[0]=e2r(v[0],lv,contextptr); 1583 gen p1,p2; 1584 fxnd(v[0],p1,p2); 1585 return simplify(product(gen2polynome(p1,int(lv.size())),lv,n,v[2],v[3],contextptr)/product(gen2polynome(p2,int(lv.size())),lv,n,v[2],v[3],contextptr),contextptr); 1586 } 1587 } 1588 if (v.size()==4 && v[2].type==_INT_ && v[3].type==_INT_ && v[2].val>v[3].val){ 1589 if (v[3].val==v[2].val-1) 1590 return 1; 1591 #if defined RTOS_THREADX || defined BESTA_OS || defined USTL 1592 { gen a=v[2]; v[2]=v[3]; v[3]=a; } 1593 #else 1594 swap(v[2],v[3]); 1595 #endif 1596 v[2]=v[2]+1; 1597 v[3]=v[3]-1; 1598 return inv(seqprod(gen(v,_SEQ__VECT),1,contextptr),contextptr); 1599 } 1600 return seqprod(gen(v,_SEQ__VECT),1,contextptr); 1601 } 1602 gen tmp=g.eval(eval_level(contextptr),contextptr); 1603 if (tmp.type==_VECT) 1604 return _product(tmp,contextptr); 1605 return seqprod(g,1,contextptr); 1606 } 1607 static const char _product_s[]="product"; 1608 static define_unary_function_eval_quoted (__product,&_product,_product_s); 1609 define_unary_function_ptr5( at_product ,alias_at_product,&__product,_QUOTE_ARGUMENTS,true); 1610 1611 // maple name for product 1612 static const char _mul_s[]="mul"; 1613 static define_unary_function_eval (__mul,&_product,_mul_s); 1614 define_unary_function_ptr5( at_mul ,alias_at_mul,&__mul,0,true); 1615 complex_sort(const gen & a,const gen & b,GIAC_CONTEXT)1616 bool complex_sort(const gen & a,const gen & b,GIAC_CONTEXT){ 1617 if (a.type==_VECT && !a._VECTptr->empty() && b.type==_VECT && !b._VECTptr->empty()) 1618 return complex_sort(a._VECTptr->front(),b._VECTptr->front(),contextptr); 1619 if (a==b) 1620 return false; 1621 if (a.type==_CPLX && b.type==_CPLX){ 1622 if (*a._CPLXptr!=*b._CPLXptr) 1623 return is_strictly_greater(*b._CPLXptr,*a._CPLXptr,contextptr); 1624 return is_strictly_greater(*(b._CPLXptr+1),*(a._CPLXptr+1),contextptr); 1625 } 1626 if (a.type==_CPLX){ 1627 if (*a._CPLXptr!=b) 1628 return is_strictly_greater(b,*a._CPLXptr,contextptr); 1629 return is_strictly_greater(0,*(a._CPLXptr+1),contextptr); 1630 } 1631 if (b.type==_CPLX){ 1632 if (a!=*b._CPLXptr) 1633 return is_strictly_greater(*b._CPLXptr,a,contextptr); 1634 return is_strictly_greater(*(b._CPLXptr+1),0,contextptr); 1635 } 1636 gen g=inferieur_strict(a,b,contextptr); 1637 if (g.type!=_INT_) 1638 return a.islesscomplexthan(b); 1639 return g.val==1; 1640 } sortad(const vecteur & v,bool ascend,GIAC_CONTEXT)1641 gen sortad(const vecteur & v,bool ascend,GIAC_CONTEXT){ 1642 if (v.empty()) return v; 1643 vecteur valeur=*eval(v,eval_level(contextptr),contextptr)._VECTptr; 1644 bool ismat=ckmatrix(valeur); 1645 if (!ismat) 1646 valeur=vecteur(1,valeur); 1647 valeur=mtran(valeur); 1648 #if 1 1649 gen_sort_f_context(valeur.begin(),valeur.end(),complex_sort,contextptr); 1650 if (!ascend) 1651 reverse(valeur.begin(),valeur.end()); 1652 #else 1653 if (ascend) 1654 gen_sort_f(valeur.begin(),valeur.end(),first_ascend_sort); 1655 else 1656 gen_sort_f(valeur.begin(),valeur.end(),first_descend_sort); 1657 #endif 1658 valeur=mtran(valeur); 1659 if (!ismat) 1660 return valeur.front(); 1661 return valeur; 1662 } _SortA(const gen & g,GIAC_CONTEXT)1663 gen _SortA(const gen & g,GIAC_CONTEXT){ 1664 if ( g.type==_STRNG && g.subtype==-1) return g; 1665 if (g.type==_VECT) 1666 return sortad(*g._VECTptr,true,contextptr); 1667 if (g.type!=_IDNT) 1668 return gensizeerr(contextptr); 1669 gen valeur=eval(g,eval_level(contextptr),contextptr); 1670 if (valeur.type!=_VECT) 1671 return gensizeerr(contextptr); 1672 return sto(sortad(*valeur._VECTptr,true,contextptr),g,contextptr); 1673 } 1674 static const char _SortA_s[]="SortA"; 1675 static define_unary_function_eval_quoted (__SortA,&_SortA,_SortA_s); 1676 define_unary_function_ptr5( at_SortA ,alias_at_SortA,&__SortA,_QUOTE_ARGUMENTS,T_RETURN); _sorta(const gen & g,GIAC_CONTEXT)1677 gen _sorta(const gen & g,GIAC_CONTEXT){ 1678 if ( g.type==_STRNG && g.subtype==-1) return g; 1679 if (g.type==_VECT) 1680 return sortad(*g._VECTptr,true,contextptr); 1681 return gensizeerr(contextptr); 1682 } 1683 static const char _sorta_s[]="sorta"; 1684 static define_unary_function_eval (__sorta,&_sorta,_sorta_s); 1685 define_unary_function_ptr5( at_sorta ,alias_at_sorta,&__sorta,0,true); 1686 _SortD(const gen & g,GIAC_CONTEXT)1687 gen _SortD(const gen & g,GIAC_CONTEXT){ 1688 if ( g.type==_STRNG && g.subtype==-1) return g; 1689 if (g.type==_VECT) 1690 return sortad(*g._VECTptr,false,contextptr); 1691 if (g.type!=_IDNT) 1692 return gensizeerr(contextptr); 1693 gen valeur=eval(g,eval_level(contextptr),contextptr); 1694 if (valeur.type!=_VECT) 1695 return gensizeerr(contextptr); 1696 return sto(sortad(*valeur._VECTptr,false,contextptr),g,contextptr); 1697 } 1698 static const char _SortD_s[]="SortD"; 1699 static define_unary_function_eval_quoted (__SortD,&_SortD,_SortD_s); 1700 define_unary_function_ptr5( at_SortD ,alias_at_SortD,&__SortD,_QUOTE_ARGUMENTS,T_RETURN); _sortd(const gen & g,GIAC_CONTEXT)1701 gen _sortd(const gen & g,GIAC_CONTEXT){ 1702 if ( g.type==_STRNG && g.subtype==-1) return g; 1703 if (g.type==_VECT) 1704 return sortad(*g._VECTptr,false,contextptr); 1705 return gensizeerr(contextptr); 1706 } 1707 static const char _sortd_s[]="sortd"; 1708 static define_unary_function_eval (__sortd,&_sortd,_sortd_s); 1709 define_unary_function_ptr5( at_sortd ,alias_at_sortd,&__sortd,0,true); 1710 1711 static const char _approx_s[]="approx"; 1712 static define_unary_function_eval (__approx,&_evalf,_approx_s); 1713 define_unary_function_ptr5( at_approx ,alias_at_approx,&__approx,0,true); 1714 1715 static const char _ceiling_s[]="ceiling"; 1716 static define_unary_function_eval (__ceiling,&_ceil,_ceiling_s); 1717 define_unary_function_ptr5( at_ceiling ,alias_at_ceiling,&__ceiling,0,true); 1718 1719 static const char _imag_s[]="imag"; 1720 static define_unary_function_eval (unary__imag,(const gen_op_context)im,_imag_s); 1721 define_unary_function_ptr5( at_imag ,alias_at_imag,&unary__imag,0,true); 1722 1723 static const char _real_s[]="real"; 1724 static define_unary_function_eval (unary__real,(const gen_op_context)re,_real_s); 1725 define_unary_function_ptr5( at_real ,alias_at_real,&unary__real,0,true); 1726 1727 static const char _intDiv_s[]="intDiv"; 1728 static define_unary_function_eval (__intDiv,(const gen_op_context)_iquo,_intDiv_s); 1729 define_unary_function_ptr5( at_intDiv ,alias_at_intDiv,&__intDiv,0,true); 1730 1731 static const char _remain_s[]="remain"; 1732 static define_unary_function_eval (__remain,(const gen_op_context)_irem,_remain_s); 1733 define_unary_function_ptr5( at_remain ,alias_at_remain,&__remain,0,true); 1734 _int(const gen & g,GIAC_CONTEXT)1735 gen _int(const gen & g,GIAC_CONTEXT){ 1736 if ( g.type==_STRNG && g.subtype==-1) return g; 1737 if (g.type==_VECT && g.subtype==_SEQ__VECT && g._VECTptr->size()==2 && g._VECTptr->front().type==_STRNG && g._VECTptr->back().type==_INT_){ 1738 gen b=g._VECTptr->back(); 1739 if (b.val<2 || b.val>36) 1740 return gendimerr(contextptr); 1741 gen res=0; 1742 const string & s=*g._VECTptr->front()._STRNGptr; 1743 int ss=int(s.size()); 1744 for (int i=0;i<ss;++i){ 1745 char ch=s[i]; 1746 if (ch>='0' && ch<='9'){ 1747 res = res*b+int(ch-'0'); 1748 continue; 1749 } 1750 if (ch>='A' && ch<='Z'){ 1751 res = res*b+int(ch-'A')+10; 1752 continue; 1753 } 1754 if (ch>='a' && ch<='z'){ 1755 res = res*b+int(ch-'a')+10; 1756 continue; 1757 } 1758 } 1759 return res; 1760 } 1761 if (xcas_mode(contextptr)==3 || (python_compat(contextptr) && g.type!=_VECT)){ 1762 gen g_=eval(g,1,contextptr); 1763 if (g_.type==_STRNG) 1764 g_=gen(*g_._STRNGptr,contextptr); 1765 return _floor(evalf(g_,1,contextptr),contextptr); 1766 } 1767 else 1768 return _integrate(g,contextptr); 1769 } 1770 static const char _int_s[]="int"; 1771 static define_unary_function_eval_quoted (__int,(const gen_op_context)_int,_int_s); 1772 define_unary_function_ptr5( at_int ,alias_at_int,&__int,_QUOTE_ARGUMENTS,true); 1773 1774 static const char _isPrime_s[]="isPrime"; 1775 static define_unary_function_eval (__isPrime,&_isprime,_isPrime_s); 1776 define_unary_function_ptr5( at_isPrime ,alias_at_isPrime,&__isPrime,0,true); 1777 1778 static const char _nCr_s[]="nCr"; 1779 static define_unary_function_eval (__nCr,&_comb,_nCr_s); 1780 define_unary_function_ptr5( at_nCr ,alias_at_nCr,&__nCr,0,true); 1781 1782 static const char _nPr_s[]="nPr"; 1783 static define_unary_function_eval (__nPr,&_perm,_nPr_s); 1784 define_unary_function_ptr5( at_nPr ,alias_at_nPr,&__nPr,0,true); 1785 _iPart(const gen & g,GIAC_CONTEXT)1786 gen _iPart(const gen & g,GIAC_CONTEXT){ 1787 if ( g.type==_STRNG && g.subtype==-1) return g; 1788 if (is_positive(g,contextptr)) 1789 return evalf(_floor(g,contextptr),eval_level(contextptr),contextptr); 1790 if (is_positive(-g,contextptr)) 1791 return -evalf(_floor(-g,contextptr),eval_level(contextptr),contextptr); 1792 if (g.type==_CPLX) 1793 return _iPart(re(g,contextptr),contextptr)+cst_i*_iPart(im(g,contextptr),contextptr); 1794 if (g.type==_VECT) 1795 return apply(g,_iPart,contextptr); 1796 return symbolic(at_iPart,g); 1797 } 1798 static const char _iPart_s[]="iPart"; 1799 static define_unary_function_eval (__iPart,&_iPart,_iPart_s); 1800 define_unary_function_ptr5( at_iPart ,alias_at_iPart,&__iPart,0,true); 1801 _Fill(const gen & g,GIAC_CONTEXT)1802 gen _Fill(const gen & g,GIAC_CONTEXT){ 1803 if ( g.type==_STRNG && g.subtype==-1) return g; 1804 vecteur v(gen2vecteur(g)); 1805 if (v.size()!=2 || v[1].type!=_IDNT) 1806 return gensizeerr(contextptr); 1807 gen value(eval(v[1],eval_level(contextptr),contextptr)); 1808 if (value.type!=_VECT) 1809 return sto(v[0],v[1],contextptr); 1810 gen dim=_dim(value,contextptr); 1811 if (dim.type==_INT_) 1812 return sto(vecteur(dim.val,eval(v[0],eval_level(contextptr),contextptr)),v[1],contextptr); 1813 if (dim.type==_VECT){ 1814 vecteur & w=*dim._VECTptr; 1815 if (w.size()!=2 || w.front().type!=_INT_ || w.back().type!=_INT_) 1816 return gensizeerr(contextptr); 1817 return sto(vecteur(w[0].val,vecteur(w[1].val,eval(v[0],eval_level(contextptr),contextptr))),v[1],contextptr); 1818 } 1819 return gensizeerr(contextptr); 1820 } 1821 static const char _Fill_s[]="Fill"; 1822 static define_unary_function_eval_quoted (__Fill,&_Fill,_Fill_s); 1823 define_unary_function_ptr5( at_Fill ,alias_at_Fill,&__Fill,_QUOTE_ARGUMENTS,T_RETURN); 1824 _mRow(const gen & g,GIAC_CONTEXT)1825 gen _mRow(const gen & g,GIAC_CONTEXT){ 1826 if ( g.type==_STRNG && g.subtype==-1) return g; 1827 vecteur v(gen2vecteur(g)); 1828 if (v.size()>1 && is_Ans(v[1])) 1829 v[1]=eval(v[1],1,contextptr); 1830 if (v.size()>1 && v[1].type==_IDNT){ 1831 gen v1=v[1]; 1832 gen args=eval(g,eval_level(contextptr),contextptr); 1833 if (ckmatrix(args[1])) 1834 return sto(_mRow(args,contextptr),v1,contextptr); 1835 } 1836 if (v.size()!=3 || !ckmatrix(v[1]) || v[2].type!=_INT_ ) 1837 return gentypeerr(contextptr); 1838 int s=int(v[1]._VECTptr->size()); 1839 int shift = array_start(contextptr); //xcas_mode(contextptr)!=0 || abs_calc_mode(contextptr)==38; 1840 int l=v[2].val-shift; 1841 if (l<0 || l>=s) 1842 return gendimerr(contextptr); 1843 vecteur w=*v[1]._VECTptr; 1844 w[l]=v[0]*w[l]; 1845 return w; 1846 } 1847 static const char _mRow_s[]="mRow"; 1848 static define_unary_function_eval (__mRow,&_mRow,_mRow_s); 1849 define_unary_function_ptr5( at_mRow ,alias_at_mRow,&__mRow,0,true); 1850 _mRowAdd(const gen & g,GIAC_CONTEXT)1851 gen _mRowAdd(const gen & g,GIAC_CONTEXT){ 1852 if ( g.type==_STRNG && g.subtype==-1) return g; 1853 vecteur v(gen2vecteur(g)); 1854 if (v.size()>1 && is_Ans(v[1])) 1855 v[1]=eval(v[1],1,contextptr); 1856 if (v.size()>1 && v[1].type==_IDNT){ 1857 gen v1=v[1]; 1858 gen args=eval(g,eval_level(contextptr),contextptr); 1859 if (ckmatrix(args[1])) 1860 return sto(_mRowAdd(args,contextptr),v1,contextptr); 1861 } 1862 if (v.size()!=4) 1863 return gentypeerr(contextptr); 1864 v[3]=_floor(v[3],contextptr); 1865 v[2]=_floor(v[2],contextptr); 1866 if (!ckmatrix(v[1]) || v[2].type!=_INT_ || v[3].type!=_INT_) 1867 return gentypeerr(contextptr); 1868 int s=int(v[1]._VECTptr->size()); 1869 int shift = array_start(contextptr); //xcas_mode(contextptr)!=0 || abs_calc_mode(contextptr)==38; 1870 int l1=v[2].val-shift,l2=v[3].val-shift; 1871 if (l1<0 || l1>=s || l2<0 || l2>=s) 1872 return gendimerr(contextptr); 1873 vecteur w=*v[1]._VECTptr; 1874 w[l2]=v[0]*w[l1]+w[l2]; 1875 return w; 1876 } 1877 static const char _mRowAdd_s[]="mRowAdd"; 1878 static define_unary_function_eval (__mRowAdd,&_mRowAdd,_mRowAdd_s); 1879 define_unary_function_ptr5( at_mRowAdd ,alias_at_mRowAdd,&__mRowAdd,0,true); 1880 _rowAdd(const gen & g,GIAC_CONTEXT)1881 gen _rowAdd(const gen & g,GIAC_CONTEXT){ 1882 if ( g.type==_STRNG && g.subtype==-1) return g; 1883 vecteur v(gen2vecteur(g)); 1884 if (!v.empty() && is_Ans(v[0])) 1885 v[0]=eval(v[0],1,contextptr); 1886 if (!v.empty() && v[0].type==_IDNT){ 1887 gen v0=v[0]; 1888 gen args=eval(g,eval_level(contextptr),contextptr); 1889 if (ckmatrix(args)) 1890 return sto(_rowAdd(args,contextptr),v0,contextptr); 1891 } 1892 if (v.size()!=3) 1893 return gentypeerr(contextptr); 1894 v[1]=_floor(v[1],contextptr); 1895 v[2]=_floor(v[2],contextptr); 1896 if (!ckmatrix(v[0]) || v[1].type!=_INT_ || v[2].type!=_INT_) 1897 return gentypeerr(contextptr); 1898 int s=int(v[0]._VECTptr->size()); 1899 int shift = array_start(contextptr); //xcas_mode(contextptr)!=0 || abs_calc_mode(contextptr)==38; 1900 int l1=v[1].val-shift,l2=v[2].val-shift; 1901 if (l1<0 || l1>=s || l2<0 || l2>=s) 1902 return gendimerr(contextptr); 1903 vecteur w=*v[0]._VECTptr; 1904 w[l2]=w[l1]+w[l2]; 1905 return w; 1906 } 1907 static const char _rowAdd_s[]="rowAdd"; 1908 static define_unary_function_eval (__rowAdd,&_rowAdd,_rowAdd_s); 1909 define_unary_function_ptr5( at_rowAdd ,alias_at_rowAdd,&__rowAdd,0,true); 1910 _rowSwap(const gen & g,GIAC_CONTEXT)1911 gen _rowSwap(const gen & g,GIAC_CONTEXT){ 1912 if ( g.type==_STRNG && g.subtype==-1) return g; 1913 vecteur v(gen2vecteur(g)); 1914 if (!v.empty() && is_Ans(v[0])) 1915 v[0]=eval(v[0],1,contextptr); 1916 if (!v.empty() && v[0].type==_IDNT){ 1917 gen v0=v[0]; 1918 gen args=eval(g,eval_level(contextptr),contextptr); 1919 if (ckmatrix(args[0])) 1920 return sto(_rowSwap(args,contextptr),v0,contextptr); 1921 } 1922 if (v.size()!=3) 1923 return gentypeerr(contextptr); 1924 v[1]=_floor(v[1],contextptr); 1925 v[2]=_floor(v[2],contextptr); 1926 if (!ckmatrix(v[0]) || v[1].type!=_INT_ || v[2].type!=_INT_) 1927 return gentypeerr(contextptr); 1928 int s=int(v[0]._VECTptr->size()); 1929 int shift = array_start(contextptr); //xcas_mode(contextptr)!=0 || abs_calc_mode(contextptr)==38; 1930 int l1=v[1].val-shift,l2=v[2].val-shift; 1931 if (l1<0 || l1>=s || l2<0 || l2>=s) 1932 return gendimerr(contextptr); 1933 vecteur w=*v[0]._VECTptr; 1934 swapgen(w[l2],w[l1]); 1935 return w; 1936 } 1937 static const char _rowSwap_s[]="rowSwap"; 1938 static define_unary_function_eval (__rowSwap,&_rowSwap,_rowSwap_s); 1939 define_unary_function_ptr5( at_rowSwap ,alias_at_rowSwap,&__rowSwap,0,true); 1940 1941 static const char _rowswap_s[]="rowswap"; 1942 static define_unary_function_eval (__rowswap,&_rowSwap,_rowswap_s); 1943 define_unary_function_ptr5( at_rowswap ,alias_at_rowswap,&__rowswap,0,true); 1944 1945 static const char _swaprow_s[]="swaprow"; 1946 static define_unary_function_eval (__swaprow,&_rowSwap,_swaprow_s); 1947 define_unary_function_ptr5( at_swaprow ,alias_at_swaprow,&__swaprow,0,true); 1948 _LU(const gen & g,GIAC_CONTEXT)1949 gen _LU(const gen & g,GIAC_CONTEXT){ 1950 if ( g.type==_STRNG && g.subtype==-1) return g; 1951 if (abs_calc_mode(contextptr)==38){ 1952 gen args=evalf(g,eval_level(contextptr),contextptr); 1953 gen res=lu(args,contextptr); 1954 if (res.type==_VECT && res._VECTptr->size()==3){ 1955 vecteur & v = *res._VECTptr; 1956 gen tmpv=_permu2mat(v[0],contextptr); 1957 if (is_undef(tmpv)) 1958 return tmpv; 1959 return gen(makevecteur(v[1],v[2],tmpv),_LIST__VECT); 1960 } 1961 return res; 1962 } 1963 vecteur v(gen2vecteur(g)); 1964 gen res; 1965 if (v.size()==5) 1966 v.pop_back(); 1967 if (v.size()!=4 || !is_squarematrix(res=eval(v[0],eval_level(contextptr),contextptr)) || v[1].type!=_IDNT || v[2].type!=_IDNT || v[3].type!=_IDNT) 1968 return gentypeerr(contextptr); 1969 res=lu(res,contextptr); // P,L,U 1970 if (is_undef(res) || res.type!=_VECT || res.subtype!=_SEQ__VECT || res._VECTptr->size()!=3) 1971 return res; 1972 gen tmpsto=sto(res[1],v[1],contextptr); 1973 if (is_undef(tmpsto)) return tmpsto; 1974 tmpsto=sto(res[2],v[2],contextptr); 1975 if (is_undef(tmpsto)) return tmpsto; 1976 res=sto(_permu2mat(res[0],contextptr),v[3],contextptr); 1977 return res; 1978 } 1979 static const char _LU_s[]="LU"; 1980 static define_unary_function_eval_quoted (__LU,&_LU,_LU_s); 1981 define_unary_function_ptr5( at_LU ,alias_at_LU,&__LU,_QUOTE_ARGUMENTS,true); 1982 _QR(const gen & g,GIAC_CONTEXT)1983 gen _QR(const gen & g,GIAC_CONTEXT){ 1984 if ( g.type==_STRNG && g.subtype==-1) return g; 1985 if (abs_calc_mode(contextptr)==38){ 1986 gen args=evalf(eval(g,1,contextptr),eval_level(contextptr),contextptr); 1987 gen res=qr(makevecteur(args,-1),contextptr); 1988 if (res.type==_VECT) 1989 res.subtype=_SEQ__VECT; 1990 return res; 1991 } 1992 vecteur v(gen2vecteur(g)); 1993 if (v.size()==4) 1994 v.pop_back(); 1995 gen res; 1996 if (v.size()!=3 || !is_squarematrix(res=eval(v[0],eval_level(contextptr),contextptr)) || v[1].type!=_IDNT || v[2].type!=_IDNT ) 1997 return gentypeerr(contextptr); 1998 gen res1=qr(res,contextptr); 1999 if (is_undef(res1) || !ckmatrix(res1[0]) || !ckmatrix(res1[1])) 2000 return res; 2001 gen tmpsto=sto(res1[0],v[1],contextptr); 2002 if (is_undef(tmpsto)) return tmpsto; 2003 return sto(res1[1],v[2],contextptr); 2004 } 2005 static const char _QR_s[]="QR"; 2006 static define_unary_function_eval_quoted (__QR,&_QR,_QR_s); 2007 define_unary_function_ptr5( at_QR ,alias_at_QR,&__QR,_QUOTE_ARGUMENTS,true); 2008 _newMat(const gen & g,GIAC_CONTEXT)2009 gen _newMat(const gen & g,GIAC_CONTEXT){ 2010 if ( g.type==_STRNG && g.subtype==-1) return g; 2011 if (g.type!=_VECT || g._VECTptr->size()!=2) 2012 return gentypeerr(contextptr); 2013 vecteur & v=*g._VECTptr; 2014 if (v[0].type!=_INT_ || v[1].type!=_INT_ ) 2015 return gensizeerr(contextptr); 2016 int l=absint(v[0].val),c=absint(v[1].val); 2017 if (l > LIST_SIZE_LIMIT || c > LIST_SIZE_LIMIT || longlong(l) * c > LIST_SIZE_LIMIT) 2018 return gendimerr(contextptr); 2019 vecteur res(l); 2020 for (int i=0;i<l;++i) 2021 res[i]=vecteur(c); 2022 return res; 2023 } 2024 static const char _newMat_s[]="newMat"; 2025 static define_unary_function_eval (__newMat,&_newMat,_newMat_s); 2026 define_unary_function_ptr5( at_newMat ,alias_at_newMat,&__newMat,0,true); 2027 _ref(const gen & a_orig,GIAC_CONTEXT)2028 gen _ref(const gen & a_orig,GIAC_CONTEXT) { 2029 if ( a_orig.type==_STRNG && a_orig.subtype==-1) return a_orig; 2030 matrice a; 2031 bool convert_internal,minor_det,keep_pivot; 2032 int algorithm,last_col; 2033 if (!read_reduction_options(a_orig,a,convert_internal,algorithm,minor_det,keep_pivot,last_col)) 2034 return gensizeerr(contextptr); 2035 if (minor_det) 2036 return gensizeerr(gettext("minor_det option applies only to det")); 2037 gen det; 2038 vecteur pivots; 2039 matrice res; 2040 mrref(a,res,pivots,det,0,int(a.size()),0,int(a.front()._VECTptr->size()), 2041 /* fullreduction */0,0,true,1,0, 2042 contextptr); 2043 if (keep_pivot) 2044 return res; 2045 bool reducelast = a.size()!=a.front()._VECTptr->size()-1; 2046 mdividebypivot(res,reducelast?-1:-2); 2047 return res; 2048 } 2049 static const char _ref_s[]="ref"; 2050 static define_unary_function_eval (__ref,&_ref,_ref_s); 2051 define_unary_function_ptr5( at_ref ,alias_at_ref,&__ref,0,true); 2052 gen2vecteur(const gen & g,int exclude)2053 vecteur gen2vecteur(const gen & g,int exclude){ 2054 if (g.type!=_VECT || g.subtype==exclude) 2055 return vecteur(1,g); 2056 return *g._VECTptr; 2057 } _subMat(const gen & g,GIAC_CONTEXT)2058 gen _subMat(const gen & g,GIAC_CONTEXT) { 2059 if ( g.type==_STRNG && g.subtype==-1) return g; 2060 vecteur v(gen2vecteur(g,0)); 2061 if (v.empty() || !ckmatrix(v[0]) ) 2062 return gentypeerr(contextptr); 2063 int lignedeb=1,colonnedeb=1,lignefin=1,colonnefin=1; 2064 mdims(*v[0]._VECTptr,lignefin,colonnefin); 2065 int shift = array_start(contextptr); //xcas_mode(contextptr)!=0 || abs_calc_mode(contextptr)==38; 2066 if (v.size()>2 && v[1].is_symb_of_sommet(at_interval)){ 2067 gen f = v[1]._SYMBptr->feuille; 2068 if (f.type==_VECT && f._VECTptr->size()==2){ 2069 gen f1=f._VECTptr->front(); 2070 gen f2=f._VECTptr->back(); 2071 if (is_integral(f1) && is_integral(f2) && f1.type==_INT_ && f2.type==_INT_){ 2072 lignedeb=giacmax(1,f1.val+!shift); 2073 lignefin=giacmax(1,f2.val+!shift); 2074 } 2075 else gensizeerr(contextptr); 2076 } 2077 if (v[2].is_symb_of_sommet(at_interval)){ 2078 gen f = v[2]._SYMBptr->feuille; 2079 if (f.type==_VECT && f._VECTptr->size()==2){ 2080 gen f1=f._VECTptr->front(); 2081 gen f2=f._VECTptr->back(); 2082 if (is_integral(f1) && is_integral(f2) && f1.type==_INT_ && f2.type==_INT_){ 2083 colonnedeb=giacmax(1,f1.val+!shift); 2084 colonnefin=giacmax(1,f2.val+!shift); 2085 } 2086 else gensizeerr(contextptr); 2087 } 2088 } 2089 } 2090 if (v.size()>2 && v[1].type==_VECT && v[1]._VECTptr->size()==2 && v[2].type==_VECT && v[2]._VECTptr->size()==2){ 2091 gen f1=v[1]._VECTptr->front(); 2092 gen f2=v[1]._VECTptr->back(); 2093 gen f3=v[2]._VECTptr->front(); 2094 gen f4=v[2]._VECTptr->back(); 2095 if (is_integral(f1) && is_integral(f2) && f1.type==_INT_ && f2.type==_INT_ && is_integral(f3) && is_integral(f4) && f3.type==_INT_ && f4.type==_INT_){ 2096 lignedeb=giacmax(1,f1.val+!shift); 2097 colonnedeb=giacmax(1,f2.val+!shift); 2098 lignefin=giacmax(1,f3.val+!shift); 2099 colonnefin=giacmax(1,f4.val+!shift); 2100 } 2101 else gensizeerr(contextptr); 2102 } 2103 if (v.size()>1 && is_integral(v[1]) && v[1].type==_INT_) 2104 lignedeb=giacmax(1,v[1].val+!shift); 2105 if (v.size()>2 && is_integral(v[2]) && v[2].type==_INT_) 2106 colonnedeb=giacmax(1,v[2].val+!shift); 2107 if (v.size()>3 && is_integral(v[3]) && v[3].type==_INT_) 2108 lignefin=giacmax(giacmin(lignefin,v[3].val+!shift),lignedeb); 2109 if (v.size()>4 && is_integral(v[4]) && v[4].type==_INT_) 2110 colonnefin=giacmax(colonnedeb,giacmin(colonnefin,v[4].val+!shift)); 2111 return matrice_extract(*v[0]._VECTptr,lignedeb-1,colonnedeb-1,lignefin-lignedeb+1,colonnefin-colonnedeb+1); 2112 } 2113 static const char _subMat_s[]="subMat"; 2114 static define_unary_function_eval (__subMat,&_subMat,_subMat_s); 2115 define_unary_function_ptr5( at_subMat ,alias_at_subMat,&__subMat,0,true); 2116 2117 static const char _submatrix_s[]="submatrix"; 2118 static define_unary_function_eval (__submatrix,&_subMat,_submatrix_s); 2119 define_unary_function_ptr5( at_submatrix ,alias_at_submatrix,&__submatrix,0,true); 2120 _unitV(const gen & g,GIAC_CONTEXT)2121 gen _unitV(const gen & g,GIAC_CONTEXT) { 2122 if ( g.type==_STRNG && g.subtype==-1) return g; 2123 return rdiv(g,_l2norm(g,contextptr),contextptr); 2124 } 2125 static const char _unitV_s[]="unitV"; 2126 static define_unary_function_eval (__unitV,&_unitV,_unitV_s); 2127 define_unary_function_ptr5( at_unitV ,alias_at_unitV,&__unitV,0,true); 2128 L1norm(const gen & g,GIAC_CONTEXT)2129 gen L1norm(const gen & g,GIAC_CONTEXT){ 2130 if (g.type!=_VECT) 2131 return abs(g,contextptr); 2132 vecteur & v=*g._VECTptr; 2133 gen res; 2134 const_iterateur it=v.begin(),itend=v.end(); 2135 for (;it!=itend;++it) 2136 res=res+abs(*it,contextptr); 2137 return res; 2138 } 2139 _rowNorm(const gen & g,GIAC_CONTEXT)2140 gen _rowNorm(const gen & g,GIAC_CONTEXT) { 2141 if ( g.type==_STRNG && g.subtype==-1) return g; 2142 if (!ckmatrix(g)) 2143 return gentypeerr(contextptr); 2144 const_iterateur it=g._VECTptr->begin(),itend=g._VECTptr->end(); 2145 gen res; 2146 for (;it!=itend;++it){ 2147 res=max(res,L1norm(*it,contextptr),contextptr); 2148 } 2149 return res; 2150 } 2151 static const char _rowNorm_s[]="rowNorm"; 2152 static define_unary_function_eval (__rowNorm,&_rowNorm,_rowNorm_s); 2153 define_unary_function_ptr5( at_rowNorm ,alias_at_rowNorm,&__rowNorm,0,true); 2154 2155 static const char _rownorm_s[]="rownorm"; 2156 static define_unary_function_eval (__rownorm,&_rowNorm,_rownorm_s); 2157 define_unary_function_ptr5( at_rownorm ,alias_at_rownorm,&__rownorm,0,true); 2158 _colNorm(const gen & g,GIAC_CONTEXT)2159 gen _colNorm(const gen & g,GIAC_CONTEXT) { 2160 if ( g.type==_STRNG && g.subtype==-1) return g; 2161 if (!ckmatrix(g)) 2162 return gentypeerr(contextptr); 2163 return _rowNorm(mtran(*g._VECTptr),contextptr); 2164 } 2165 static const char _colNorm_s[]="colNorm"; 2166 static define_unary_function_eval (__colNorm,&_colNorm,_colNorm_s); 2167 define_unary_function_ptr5( at_colNorm ,alias_at_colNorm,&__colNorm,0,true); 2168 2169 static const char _colnorm_s[]="colnorm"; 2170 static define_unary_function_eval (__colnorm,&_colNorm,_colnorm_s); 2171 define_unary_function_ptr5( at_colnorm ,alias_at_colnorm,&__colnorm,0,true); 2172 _ClrIO(const gen & g,GIAC_CONTEXT)2173 gen _ClrIO(const gen & g,GIAC_CONTEXT){ 2174 if ( g.type==_STRNG && g.subtype==-1) return g; 2175 #ifdef EMCC 2176 return _print(_char(12,contextptr),contextptr); 2177 #endif 2178 return __interactive.op(symbolic(at_ClrIO,0),contextptr); 2179 } 2180 static const char _ClrIO_s[]="ClrIO"; 2181 static define_unary_function_eval2 (__ClrIO,&_ClrIO,_ClrIO_s,&printastifunction); 2182 define_unary_function_ptr5( at_ClrIO ,alias_at_ClrIO,&__ClrIO,0,T_EXPRESSION); 2183 _Output(const gen & g,GIAC_CONTEXT)2184 gen _Output(const gen & g,GIAC_CONTEXT){ 2185 if ( g.type==_STRNG && g.subtype==-1) return g; 2186 vecteur v(gen2vecteur(g)); 2187 if (v.size()!=3 || v[0].type!=_INT_ || v[1].type!=_INT_ ) 2188 return gentypeerr(contextptr); 2189 return __interactive.op(g,contextptr); 2190 } 2191 static const char _Output_s[]="Output"; 2192 static define_unary_function_eval2 (__Output,&_Output,_Output_s,&printastifunction); 2193 define_unary_function_ptr5( at_Output ,alias_at_Output,&__Output,0,T_RETURN); 2194 _getKey(const gen & g,GIAC_CONTEXT)2195 gen _getKey(const gen & g,GIAC_CONTEXT){ 2196 #ifdef KHICAS 2197 control_c(); 2198 int key=getkey(0); 2199 return key; 2200 #else 2201 if (interactive_op_tab && interactive_op_tab[4]) 2202 return interactive_op_tab[4](g,contextptr); 2203 if ( g.type==_STRNG && g.subtype==-1) return g; 2204 #ifdef FXCG 2205 return PRGM_GetKey(); 2206 #else 2207 char ch; 2208 CERR << "Waiting for a keystroke in konsole screen" << '\n'; 2209 CIN >> ch; 2210 return int(ch); 2211 #endif 2212 #endif 2213 } 2214 static const char _getKey_s[]="getKey"; 2215 #if defined RTOS_THREADX || defined BESTA_OS 2216 static define_unary_function_eval(__getKey,&_getKey,_getKey_s); 2217 #else 2218 unary_function_eval __getKey(0,&_getKey,_getKey_s); 2219 #endif 2220 define_unary_function_ptr5( at_getKey ,alias_at_getKey,&__getKey,0,true); 2221 2222 static const char _get_key_s[]="get_key"; 2223 static define_unary_function_eval(__get_key,&_getKey,_get_key_s); 2224 define_unary_function_ptr5( at_get_key ,alias_at_get_key,&__get_key,0,true); 2225 _keydown(const gen & g,GIAC_CONTEXT)2226 gen _keydown(const gen & g,GIAC_CONTEXT){ 2227 if (g.type!=_INT_) 2228 return gensizeerr(contextptr); 2229 #ifdef KHICAS 2230 return iskeydown(g.val); 2231 #else 2232 return 0; 2233 #endif 2234 } 2235 static const char _keydown_s[]="keydown"; 2236 static define_unary_function_eval(__keydown,&_keydown,_keydown_s); 2237 define_unary_function_ptr5( at_keydown ,alias_at_keydown,&__keydown,0,true); 2238 _CopyVar(const gen & g,GIAC_CONTEXT)2239 gen _CopyVar(const gen & g,GIAC_CONTEXT){ 2240 if ( g.type==_STRNG && g.subtype==-1) return g; 2241 vecteur v(gen2vecteur(g)); 2242 if (v.size()!=2 || v[0].type!=_IDNT || v[1].type!=_IDNT ) 2243 return gentypeerr(contextptr); 2244 return sto(v[0].eval(1,contextptr),v[1],contextptr); 2245 } 2246 static const char _CopyVar_s[]="CopyVar"; 2247 static define_unary_function_eval2_quoted (__CopyVar,&_CopyVar,_CopyVar_s,&printastifunction); 2248 define_unary_function_ptr5( at_CopyVar ,alias_at_CopyVar,&__CopyVar,_QUOTE_ARGUMENTS,T_RETURN); 2249 _DelFold(const gen & g,GIAC_CONTEXT)2250 gen _DelFold(const gen & g,GIAC_CONTEXT){ 2251 if ( g.type==_STRNG && g.subtype==-1) return g; 2252 gen res=_SetFold(0,contextptr); 2253 gen e=_purge(g,contextptr); 2254 if (is_undef(e)){ 2255 _SetFold(res,contextptr); 2256 return e; 2257 } 2258 return res; 2259 } 2260 static const char _DelFold_s[]="DelFold"; 2261 static define_unary_function_eval2_quoted (__DelFold,&_DelFold,_DelFold_s,&printastifunction); 2262 define_unary_function_ptr5( at_DelFold ,alias_at_DelFold,&__DelFold,_QUOTE_ARGUMENTS,T_RETURN); 2263 _DispG(const gen & g,GIAC_CONTEXT)2264 gen _DispG(const gen & g,GIAC_CONTEXT){ 2265 if ( g.type==_STRNG && g.subtype==-1) return g; 2266 return __interactive.op(symbolic(at_DispG,0),contextptr); 2267 } 2268 static const char _DispG_s[]="DispG"; 2269 static define_unary_function_eval2 (__DispG,&_DispG,_DispG_s,&printastifunction); 2270 define_unary_function_ptr5( at_DispG ,alias_at_DispG,&__DispG,0,T_EXPRESSION); 2271 _DispHome(const gen & g,GIAC_CONTEXT)2272 gen _DispHome(const gen & g,GIAC_CONTEXT){ 2273 if ( g.type==_STRNG && g.subtype==-1) return g; 2274 return __interactive.op(symbolic(at_DispHome,0),contextptr); 2275 } 2276 static const char _DispHome_s[]="DispHome"; 2277 static define_unary_function_eval2 (__DispHome,&_DispHome,_DispHome_s,&printastifunction); 2278 define_unary_function_ptr5( at_DispHome ,alias_at_DispHome,&__DispHome,0,T_EXPRESSION); 2279 2280 static const char _entry_s[]="entry"; 2281 static define_unary_function_eval (__entry,&_quest,_entry_s); 2282 define_unary_function_ptr5( at_entry ,alias_at_entry,&__entry,0,true); 2283 _Exec(const gen & g,GIAC_CONTEXT)2284 gen _Exec(const gen & g,GIAC_CONTEXT){ 2285 if ( g.type==_STRNG && g.subtype==-1) return g; 2286 return string2gen("TI instruction not supported",false); 2287 } 2288 static const char _Exec_s[]="Exec"; 2289 static define_unary_function_eval2 (__Exec,&_Exec,_Exec_s,&printastifunction); 2290 define_unary_function_ptr5( at_Exec ,alias_at_Exec,&__Exec,0,T_RETURN); 2291 2292 static const char _Get_s[]="Get"; 2293 static define_unary_function_eval2_quoted (__Get,&_Exec,_Get_s,&printastifunction); 2294 define_unary_function_ptr5( at_Get ,alias_at_Get,&__Get,_QUOTE_ARGUMENTS,T_RETURN); 2295 2296 static const char _GetCalc_s[]="GetCalc"; 2297 static define_unary_function_eval2_quoted (__GetCalc,&_Exec,_GetCalc_s,&printastifunction); 2298 define_unary_function_ptr5( at_GetCalc ,alias_at_GetCalc,&__GetCalc,_QUOTE_ARGUMENTS,T_RETURN); 2299 _NewFold(const gen & g,GIAC_CONTEXT)2300 gen _NewFold(const gen & g,GIAC_CONTEXT){ 2301 if ( g.type==_STRNG && g.subtype==-1) return g; 2302 if (g.type!=_IDNT) 2303 return gensizeerr(contextptr); 2304 _SetFold(0,contextptr); 2305 gen tmpsto=sto(gen(vecteur(1,vecteur(0)),_FOLDER__VECT),g,contextptr); 2306 if (is_undef(tmpsto)) return tmpsto; 2307 return _SetFold(g,contextptr); 2308 } 2309 static const char _NewFold_s[]="NewFold"; 2310 static define_unary_function_eval2_quoted (__NewFold,&_NewFold,_NewFold_s,&printastifunction); 2311 define_unary_function_ptr5( at_NewFold ,alias_at_NewFold,&__NewFold,_QUOTE_ARGUMENTS,T_RETURN); 2312 _GetFold(const gen & g,GIAC_CONTEXT)2313 gen _GetFold(const gen & g,GIAC_CONTEXT){ 2314 if ( g.type==_STRNG && g.subtype==-1) return g; 2315 return getfold(current_folder_name); 2316 } 2317 static const char _GetFold_s[]="GetFold"; 2318 static define_unary_function_eval2 (__GetFold,&_GetFold,_GetFold_s,&printastifunction); 2319 define_unary_function_ptr5( at_GetFold ,alias_at_GetFold,&__GetFold,0,T_EXPRESSION); 2320 _StoPic(const gen & g,GIAC_CONTEXT)2321 gen _StoPic(const gen & g,GIAC_CONTEXT){ 2322 if ( g.type==_STRNG && g.subtype==-1) return g; 2323 if (g.type!=_IDNT) 2324 return gensizeerr(contextptr); 2325 return sto(__interactive.op(0,contextptr),g,contextptr); 2326 } 2327 static const char _StoPic_s[]="StoPic"; 2328 static define_unary_function_eval2_quoted (__StoPic,&_StoPic,_StoPic_s,&printastifunction); 2329 define_unary_function_ptr5( at_StoPic ,alias_at_StoPic,&__StoPic,_QUOTE_ARGUMENTS,T_RETURN); 2330 _RclPic(const gen & g,GIAC_CONTEXT)2331 gen _RclPic(const gen & g,GIAC_CONTEXT){ 2332 if ( g.type==_STRNG && g.subtype==-1) return g; 2333 if (g.type!=_IDNT) 2334 return gensizeerr(contextptr); 2335 gen tmp=eval(g,eval_level(contextptr),contextptr); 2336 if (tmp.type!=_VECT) 2337 return gensizeerr(contextptr); 2338 return __interactive.op(symbolic(at_RclPic,tmp),contextptr); 2339 } 2340 static const char _RclPic_s[]="RclPic"; 2341 static define_unary_function_eval2_quoted (__RclPic,&_RclPic,_RclPic_s,&printastifunction); 2342 define_unary_function_ptr5( at_RclPic ,alias_at_RclPic,&__RclPic,_QUOTE_ARGUMENTS,T_RETURN); 2343 _RplcPic(const gen & g,GIAC_CONTEXT)2344 gen _RplcPic(const gen & g,GIAC_CONTEXT){ 2345 if ( g.type==_STRNG && g.subtype==-1) return g; 2346 if (g.type!=_IDNT) 2347 return gensizeerr(contextptr); 2348 gen tmp=eval(g,eval_level(contextptr),contextptr); 2349 if (tmp.type!=_VECT) 2350 return gensizeerr(contextptr); 2351 return __interactive.op(symbolic(at_RplcPic,tmp),contextptr); 2352 } 2353 static const char _RplcPic_s[]="RplcPic"; 2354 static define_unary_function_eval2_quoted (__RplcPic,&_RplcPic,_RplcPic_s,&printastifunction); 2355 define_unary_function_ptr5( at_RplcPic ,alias_at_RplcPic,&__RplcPic,_QUOTE_ARGUMENTS,T_RETURN); 2356 _ClrGraph(const gen & g,GIAC_CONTEXT)2357 gen _ClrGraph(const gen & g,GIAC_CONTEXT){ 2358 if ( g.type==_STRNG && g.subtype==-1) return g; 2359 return __interactive.op(symbolic(at_erase,0),contextptr); 2360 } 2361 static const char _ClrGraph_s[]="ClrGraph"; 2362 static define_unary_function_eval2 (__ClrGraph,&_ClrGraph,_ClrGraph_s,&printastifunction); 2363 define_unary_function_ptr5( at_ClrGraph ,alias_at_ClrGraph,&__ClrGraph,0,T_EXPRESSION); 2364 _ClrDraw(const gen & g,GIAC_CONTEXT)2365 gen _ClrDraw(const gen & g,GIAC_CONTEXT){ 2366 if ( g.type==_STRNG && g.subtype==-1) return g; 2367 return __interactive.op(symbolic(at_erase,0),contextptr); 2368 } 2369 static const char _ClrDraw_s[]="ClrDraw"; 2370 static define_unary_function_eval2 (__ClrDraw,&_ClrDraw,_ClrDraw_s,&printastifunction); 2371 define_unary_function_ptr5( at_ClrDraw ,alias_at_ClrDraw,&__ClrDraw,0,T_EXPRESSION); 2372 _PtOn(const gen & g,GIAC_CONTEXT)2373 gen _PtOn(const gen & g,GIAC_CONTEXT){ 2374 if ( g.type==_STRNG && g.subtype==-1) return g; 2375 return _point(g,contextptr); 2376 } 2377 static const char _PtOn_s[]="PtOn"; 2378 static define_unary_function_eval2 (__PtOn,&_PtOn,_PtOn_s,&printastifunction); 2379 define_unary_function_ptr5( at_PtOn ,alias_at_PtOn,&__PtOn,0,T_RETURN); 2380 _PtOff(const gen & g,GIAC_CONTEXT)2381 gen _PtOff(const gen & g,GIAC_CONTEXT){ 2382 if ( g.type==_STRNG && g.subtype==-1) return g; 2383 gen tmp=_point(g,contextptr); 2384 if (tmp.type==_SYMB && tmp._SYMBptr->sommet==at_pnt) 2385 return symb_pnt(tmp[0],int(FL_WHITE),contextptr); 2386 else 2387 return tmp; 2388 } 2389 static const char _PtOff_s[]="PtOff"; 2390 static define_unary_function_eval2 (__PtOff,&_PtOff,_PtOff_s,&printastifunction); 2391 define_unary_function_ptr5( at_PtOff ,alias_at_PtOff,&__PtOff,0,T_RETURN); 2392 2393 static const char _PxlOn_s[]="PxlOn"; 2394 static define_unary_function_eval2 (__PxlOn,&_pixon,_PxlOn_s,&printastifunction); 2395 define_unary_function_ptr5( at_PxlOn ,alias_at_PxlOn,&__PxlOn,0,T_RETURN); 2396 2397 static const char _PxlOff_s[]="PxlOff"; 2398 static define_unary_function_eval2 (__PxlOff,&_pixoff,_PxlOff_s,&printastifunction); 2399 define_unary_function_ptr5( at_PxlOff ,alias_at_PxlOff,&__PxlOff,0,T_RETURN); 2400 _Line(const gen & g,GIAC_CONTEXT)2401 gen _Line(const gen & g,GIAC_CONTEXT){ 2402 if ( g.type==_STRNG && g.subtype==-1) return g; 2403 vecteur v(gen2vecteur(g)); 2404 if (v.size()<4) 2405 return gensizeerr(contextptr); 2406 int couleur=FL_BLACK; 2407 if (v.size()==5 && v[4].val==0) 2408 couleur=FL_WHITE; 2409 return _couleur(makesequence(_segment(makesequence(v[0]+cst_i*v[1],v[2]+cst_i*v[3]),contextptr),couleur),contextptr); 2410 } 2411 static const char _Line_s[]="Line"; 2412 static define_unary_function_eval2 (__Line,&_Line,_Line_s,&printastifunction); 2413 define_unary_function_ptr5( at_Line ,alias_at_Line,&__Line,0,T_RETURN); 2414 _LineHorz(const gen & g,GIAC_CONTEXT)2415 gen _LineHorz(const gen & g,GIAC_CONTEXT){ 2416 if ( g.type==_STRNG && g.subtype==-1) return g; 2417 vecteur v(gen2vecteur(g)); 2418 if (v.size()<1) 2419 return gensizeerr(contextptr); 2420 int couleur=FL_BLACK; 2421 if (v.size()==2 && v[1].val==0) 2422 couleur=FL_WHITE; 2423 return _couleur(makesequence(_droite(makesequence(cst_i*v[0],1+cst_i*v[0]),contextptr),couleur),contextptr); 2424 } 2425 static const char _LineHorz_s[]="LineHorz"; 2426 static define_unary_function_eval2 (__LineHorz,&_LineHorz,_LineHorz_s,&printastifunction); 2427 define_unary_function_ptr5( at_LineHorz ,alias_at_LineHorz,&__LineHorz,0,T_RETURN); 2428 _LineVert(const gen & g,GIAC_CONTEXT)2429 gen _LineVert(const gen & g,GIAC_CONTEXT){ 2430 if ( g.type==_STRNG && g.subtype==-1) return g; 2431 vecteur v(gen2vecteur(g)); 2432 if (v.size()<1) 2433 return gensizeerr(contextptr); 2434 int couleur=FL_BLACK; 2435 if (v.size()==2 && v[1].val==0) 2436 couleur=FL_WHITE; 2437 return _couleur(makesequence(_droite(makesequence(v[0],cst_i+v[0]),contextptr),couleur),contextptr); 2438 } 2439 static const char _LineVert_s[]="LineVert"; 2440 static define_unary_function_eval2 (__LineVert,&_LineVert,_LineVert_s,&printastifunction); 2441 define_unary_function_ptr5( at_LineVert ,alias_at_LineVert,&__LineVert,0,T_RETURN); 2442 _DrawSlp(const gen & g,GIAC_CONTEXT)2443 gen _DrawSlp(const gen & g,GIAC_CONTEXT){ 2444 if ( g.type==_STRNG && g.subtype==-1) return g; 2445 vecteur v(gen2vecteur(g)); 2446 if (v.size()<3) 2447 return gensizeerr(contextptr); 2448 gen pt(v[0]+cst_i*v[1]); 2449 return _droite(makesequence(pt,pt+1+cst_i*v[2]),contextptr); 2450 } 2451 static const char _DrawSlp_s[]="DrawSlp"; 2452 static define_unary_function_eval2 (__DrawSlp,&_DrawSlp,_DrawSlp_s,&printastifunction); 2453 define_unary_function_ptr5( at_DrawSlp ,alias_at_DrawSlp,&__DrawSlp,0,T_RETURN); 2454 _Circle(const gen & g,GIAC_CONTEXT)2455 gen _Circle(const gen & g,GIAC_CONTEXT){ 2456 if ( g.type==_STRNG && g.subtype==-1) return g; 2457 vecteur v(gen2vecteur(g)); 2458 if (v.size()<3) 2459 return gensizeerr(contextptr); 2460 int couleur=FL_BLACK; 2461 if (v.size()==4 && v[3].val==0) 2462 couleur=FL_WHITE; 2463 gen centre(v[0]+cst_i*v[1]); 2464 return _couleur(makesequence(_cercle(makesequence(centre,v[2]),contextptr),couleur),contextptr); 2465 } 2466 static const char _Circle_s[]="Circle"; 2467 static define_unary_function_eval2 (__Circle,&_Circle,_Circle_s,&printastifunction); 2468 define_unary_function_ptr5( at_Circle ,alias_at_Circle,&__Circle,0,T_RETURN); 2469 _PtText(const gen & g,GIAC_CONTEXT)2470 gen _PtText(const gen & g,GIAC_CONTEXT){ 2471 if ( g.type==_STRNG && g.subtype==-1) return g; 2472 vecteur v(gen2vecteur(g)); 2473 if (v.size()<3) 2474 return gensizeerr(contextptr); 2475 gen tmp(v[1]+cst_i*v[2]); 2476 return _legende(makesequence(tmp,v[0]),contextptr); 2477 } 2478 static const char _PtText_s[]="PtText"; 2479 static define_unary_function_eval2 (__PtText,&_PtText,_PtText_s,&printastifunction); 2480 define_unary_function_ptr5( at_PtText ,alias_at_PtText,&__PtText,0,T_RETURN); 2481 _NewPic(const gen & g,GIAC_CONTEXT)2482 gen _NewPic(const gen & g,GIAC_CONTEXT){ 2483 if ( g.type==_STRNG && g.subtype==-1) return g; 2484 vecteur v(gen2vecteur(g)); 2485 if (v.size()<2|| !ckmatrix(v[0]) || v[1].type!=_IDNT) 2486 return gensizeerr(contextptr); 2487 vecteur w=*v[0]._VECTptr; 2488 iterateur it=w.begin(),itend=w.end(); 2489 for (;it!=itend;++it){ 2490 if (it->_VECTptr->size()!=2) 2491 return gensizeerr(contextptr); 2492 *it=symbolic(at_pnt,makevecteur(it->_VECTptr->front()+cst_i*it->_VECTptr->back(),int(FL_BLACK)),_PNT__VECT); 2493 } 2494 return sto(gen(w,_SEQ__VECT),v[1],contextptr); 2495 } 2496 static const char _NewPic_s[]="NewPic"; 2497 static define_unary_function_eval2 (__NewPic,&_NewPic,_NewPic_s,&printastifunction); 2498 define_unary_function_ptr5( at_NewPic ,alias_at_NewPic,&__NewPic,0,T_RETURN); 2499 2500 vecteur zoom_save; _ZoomSto(const gen & g,GIAC_CONTEXT)2501 gen _ZoomSto(const gen & g,GIAC_CONTEXT){ 2502 if ( g.type==_STRNG && g.subtype==-1) return g; 2503 vecteur v; 2504 v.push_back(gnuplot_xmin); 2505 v.push_back(gnuplot_xmax); 2506 v.push_back(gnuplot_ymin); 2507 v.push_back(gnuplot_ymax); 2508 v.push_back(gnuplot_zmin); 2509 v.push_back(gnuplot_zmax); 2510 v.push_back(gnuplot_tmin); 2511 v.push_back(gnuplot_tmax); 2512 v.push_back(global_window_xmin); 2513 v.push_back(global_window_xmax); 2514 v.push_back(global_window_ymin); 2515 v.push_back(global_window_ymax); 2516 v.push_back(show_axes(contextptr)); 2517 zoom_save=v; 2518 return v; 2519 } 2520 static const char _ZoomSto_s[]="ZoomSto"; 2521 static define_unary_function_eval2 (__ZoomSto,&_ZoomSto,_ZoomSto_s,&printastifunction); 2522 define_unary_function_ptr5( at_ZoomSto ,alias_at_ZoomSto,&__ZoomSto,0,T_RETURN); 2523 _ZoomRcl(const gen & g,GIAC_CONTEXT)2524 gen _ZoomRcl(const gen & g,GIAC_CONTEXT){ 2525 if ( g.type==_STRNG && g.subtype==-1) return g; 2526 vecteur v; 2527 if (g.type!=_VECT || g._VECTptr->size()<13) 2528 v=zoom_save; 2529 else 2530 v=*g._VECTptr; 2531 return _xyztrange(v,contextptr); 2532 } 2533 static const char _ZoomRcl_s[]="ZoomRcl"; 2534 static define_unary_function_eval2 (__ZoomRcl,&_ZoomRcl,_ZoomRcl_s,&printastifunction); 2535 define_unary_function_ptr5( at_ZoomRcl ,alias_at_ZoomRcl,&__ZoomRcl,0,T_RETURN); 2536 _deSolve(const gen & g,GIAC_CONTEXT)2537 gen _deSolve(const gen & g,GIAC_CONTEXT){ 2538 if ( g.type==_STRNG && g.subtype==-1) return g; 2539 vecteur v(gen2vecteur(g)); 2540 if (v.empty()) 2541 return gensizeerr(contextptr); 2542 if (v[0].is_symb_of_sommet(at_and)) 2543 v[0]=remove_and(v[0],at_and); 2544 return _desolve(gen(v,_SEQ__VECT),contextptr); 2545 } 2546 static const char _deSolve_s[]="deSolve"; 2547 static define_unary_function_eval2_quoted (__deSolve,&_deSolve,_deSolve_s,&printastifunction); 2548 define_unary_function_ptr5( at_deSolve ,alias_at_deSolve,&__deSolve,_QUOTE_ARGUMENTS,T_RETURN); 2549 _LineTan(const gen & g,GIAC_CONTEXT)2550 gen _LineTan(const gen & g,GIAC_CONTEXT){ 2551 if ( g.type==_STRNG && g.subtype==-1) return g; 2552 vecteur attributs(1,default_color(contextptr)); 2553 vecteur v(seq2vecteur(g)); 2554 int s=read_attributs(v,attributs,contextptr); 2555 if (s<1 || s>3) 2556 return gensizeerr(contextptr); 2557 gen f(v[0]),x(vx_var),x0(0); 2558 if (s==3){ 2559 x=v[1]; 2560 x0=v[2]; 2561 } 2562 if (s==2){ 2563 x0=v[1]; 2564 if (is_equal(x0)){ 2565 gen & x0f=x0._SYMBptr->feuille; 2566 if (x0f.type==_VECT && x0f._VECTptr->size()==2){ 2567 x=x0f._VECTptr->front(); 2568 x0=x0f._VECTptr->back(); 2569 } 2570 } 2571 } 2572 gen fprime(derive(f,x,contextptr)); 2573 if (is_undef(fprime)) return fprime; 2574 gen M0(x0+cst_i*subst(f,x,x0,false,contextptr)); 2575 gen direction(1+cst_i*subst(fprime,x,x0,false,contextptr)); 2576 return put_attributs(_droite(makesequence(M0,M0+direction),contextptr),attributs,contextptr); 2577 } 2578 static const char _LineTan_s[]="LineTan"; 2579 static define_unary_function_eval2 (__LineTan,&_LineTan,_LineTan_s,&printastifunction); 2580 define_unary_function_ptr5( at_LineTan ,alias_at_LineTan,&__LineTan,0,T_RETURN); 2581 2582 static const char _droite_tangente_s[]="droite_tangente"; 2583 static define_unary_function_eval2 (__droite_tangente,&_LineTan,_droite_tangente_s,&printastifunction); 2584 define_unary_function_ptr5( at_droite_tangente ,alias_at_droite_tangente,&__droite_tangente,0,true); 2585 2586 static const char _tangente_s[]="tangente"; 2587 static define_unary_function_eval2 (__tangente,&_tangent,_tangente_s,&printastifunction); 2588 define_unary_function_ptr5( at_tangente ,alias_at_tangente,&__tangente,0,true); 2589 _CyclePic(const gen & g,GIAC_CONTEXT)2590 gen _CyclePic(const gen & g,GIAC_CONTEXT){ 2591 if ( g.type==_STRNG && g.subtype==-1) return g; 2592 vecteur v(gen2vecteur(g)); 2593 int s=int(v.size()); 2594 if (s<2 || v[0].type!=_STRNG || v[1].type!=_INT_) 2595 return gensizeerr(contextptr); 2596 int n=giacmax(absint(v[1].val),1); 2597 double delay=1.0; 2598 if (s>2 && v[2].type==_DOUBLE_) 2599 delay=v[2]._DOUBLE_val; 2600 delay=absdouble(delay*1e3); 2601 int d=int(delay); 2602 int ds=d/1000,ns=(d%1000)*1000000; 2603 #ifndef HAVE_NO_SYS_TIMES_H 2604 timespec t; // ,tr; 2605 t.tv_sec=ds; 2606 t.tv_nsec=ns; 2607 #endif 2608 int repete=1; 2609 if (s>3 && v[3].type==_INT_) 2610 repete=giacmax(absint(v[3].val),1); 2611 int direction=1; 2612 if (s>4 && is_minus_one(v[4])) 2613 direction=-1; 2614 string & orig_name = *v[0]._STRNGptr; 2615 for (int i=0;i<repete;++i){ 2616 if (direction==1){ 2617 for (int j=1;j<=n;++j){ 2618 string name=orig_name+print_INT_(j); 2619 gen g(name,contextptr); 2620 if (g.type==_IDNT) 2621 _RplcPic(g,contextptr); 2622 wait_1ms(d); 2623 /* 2624 #ifdef WIN32 2625 sleep(ds); 2626 #else 2627 #ifdef __APPLE__ 2628 usleep(2000); 2629 #else 2630 nanosleep(&t,&tr); 2631 #endif 2632 #endif 2633 */ 2634 } 2635 } 2636 else { 2637 for (int j=n;j>=1;--j){ 2638 string name=orig_name+print_INT_(j); 2639 gen g(name,contextptr); 2640 if (g.type==_IDNT) 2641 _RplcPic(g,contextptr); 2642 wait_1ms(d); 2643 /* 2644 #ifdef WIN32 2645 sleep(ds); 2646 #else 2647 #ifdef __APPLE__ 2648 usleep(2000); 2649 #else 2650 nanosleep(&t,&tr); 2651 #endif 2652 #endif 2653 */ 2654 } 2655 } 2656 } 2657 return zero; 2658 } 2659 static const char _CyclePic_s[]="CyclePic"; 2660 static define_unary_function_eval2 (__CyclePic,&_CyclePic,_CyclePic_s,&printastifunction); 2661 define_unary_function_ptr5( at_CyclePic ,alias_at_CyclePic,&__CyclePic,0,T_RETURN); 2662 2663 #ifndef FXCG _RandSeed(const gen & g,GIAC_CONTEXT)2664 gen _RandSeed(const gen & g,GIAC_CONTEXT){ 2665 if ( g.type==_STRNG && g.subtype==-1) return g; 2666 #if defined(NSPIRE_NEWLIB) || defined KHICAS || defined(VISUALC) || defined(__MINGW_H) || defined BESTA_OS || defined EMCC || defined NSPIRE 2667 srand(g.val); 2668 #else 2669 #ifndef GNUWINCE 2670 srandom(g.val); 2671 #endif 2672 #endif // visualc 2673 return g; 2674 } 2675 static const char _RandSeed_s[]="RandSeed"; 2676 static define_unary_function_eval2 (__RandSeed,&_RandSeed,_RandSeed_s,&printastifunction); 2677 define_unary_function_ptr5( at_RandSeed ,alias_at_RandSeed,&__RandSeed,0,T_RETURN); 2678 #endif 2679 _Store(const gen & g,const context * contextptr)2680 gen _Store(const gen & g,const context * contextptr){ 2681 if ( g.type==_STRNG && g.subtype==-1) return g; 2682 return _sto(g,contextptr); 2683 } 2684 static const char _Store_s[]="Store"; 2685 static define_unary_function_eval_quoted (__Store,&_Store,_Store_s); 2686 define_unary_function_ptr5( at_Store ,alias_at_Store,&__Store,_QUOTE_ARGUMENTS,true); 2687 exact_double(double d,double eps)2688 gen exact_double(double d,double eps){ 2689 if (eps<1e-14) 2690 eps=1e-14; 2691 if (d<0) 2692 return -exact_double(-d,eps); 2693 if (d > (1<<30) ) 2694 return _floor(d,context0); 2695 if (d==0) 2696 return 0; 2697 if (d<1) 2698 return inv(exact_double(1/d,eps),context0); 2699 vector<int> res; 2700 double eps1(1+eps); 2701 for (;!interrupted;){ 2702 #ifdef TIMEOUT 2703 control_c(); 2704 #endif 2705 if (ctrl_c || interrupted) { 2706 interrupted = true; ctrl_c=false; 2707 return gensizeerr(gettext("Stopped by user interruption.")); 2708 } 2709 res.push_back(int(d*eps1)); 2710 d=d-int(d*eps1); 2711 if (d<=eps) 2712 break; 2713 d=1/d; 2714 if (d > (1<<30)) 2715 break; 2716 eps=eps*d*d; 2717 } 2718 if (res.empty()) 2719 return gensizeerr(gettext("Stopped by user interruption.")); 2720 reverse(res.begin(),res.end()); 2721 vector<int>::const_iterator it=res.begin(),itend=res.end(); 2722 if (it==itend) 2723 return undef; 2724 gen x(*it); 2725 for (++it;it!=itend;++it){ 2726 x=*it+inv(x,context0); 2727 } 2728 return x; 2729 } exact(const gen & g,GIAC_CONTEXT)2730 gen exact(const gen & g,GIAC_CONTEXT){ 2731 switch (g.type){ 2732 case _DOUBLE_: 2733 return exact_double(g._DOUBLE_val,epsilon(contextptr)); 2734 case _REAL: 2735 return exact_double(evalf_double(g,1,contextptr)._DOUBLE_val,epsilon(contextptr)); 2736 #ifdef BCD 2737 case _FLOAT_: 2738 return exact_double(evalf_double(g,1,contextptr)._DOUBLE_val,1e-10); 2739 #endif 2740 case _CPLX: 2741 return exact(re(g,contextptr),contextptr)+cst_i*exact(im(g,contextptr),contextptr); 2742 case _SYMB: 2743 return symbolic(g._SYMBptr->sommet,exact(g._SYMBptr->feuille,contextptr)); 2744 case _VECT: 2745 return apply(g,exact,contextptr); 2746 default: 2747 return g; 2748 } 2749 } _exact(const gen & g,GIAC_CONTEXT)2750 gen _exact(const gen & g,GIAC_CONTEXT){ 2751 #if 0 // def BCD 2752 return symb_quote(exact(g,contextptr)); 2753 #else 2754 return exact(g,contextptr); 2755 #endif 2756 } 2757 static const char _exact_s[]="exact"; 2758 static define_unary_function_eval (__exact,&_exact,_exact_s); 2759 define_unary_function_ptr5( at_exact ,alias_at_exact,&__exact,0,true); 2760 fPart(const gen & g,GIAC_CONTEXT)2761 gen fPart(const gen & g,GIAC_CONTEXT){ 2762 if (is_undef(g)) 2763 return g; 2764 if (is_equal(g)) 2765 return apply_to_equal(g,fPart,contextptr); 2766 if (g.type==_VECT) 2767 return apply(g,fPart,contextptr); 2768 // if (is_strictly_positive(-g,contextptr)) return -fPart(-g,contextptr); 2769 // return g-_floor(g,contextptr); 2770 return g-_INT(g,contextptr); 2771 } 2772 static const char _fPart_s[]="fPart"; 2773 static define_unary_function_eval (__fPart,&fPart,_fPart_s); 2774 define_unary_function_ptr5( at_fPart ,alias_at_fPart,&__fPart,0,true); 2775 2776 static const char _frac_s[]="frac"; 2777 static define_unary_function_eval (__frac,&fPart,_frac_s); 2778 define_unary_function_ptr5( at_frac ,alias_at_frac,&__frac,0,true); 2779 simult(const gen & g,GIAC_CONTEXT)2780 gen simult(const gen & g,GIAC_CONTEXT){ 2781 if (g.type!=_VECT || g._VECTptr->size()!=2) 2782 return gensizeerr(contextptr); 2783 vecteur & v=*g._VECTptr; 2784 gen m1(v[0]),m2(v[1]); 2785 if (!is_squarematrix(m1)|| !ckmatrix(m2) || m1._VECTptr->size()!=m2._VECTptr->size()) 2786 return gensizeerr(contextptr); 2787 matrice m=mtran(mergevecteur(mtran(*m1._VECTptr),mtran(*m2._VECTptr))); 2788 m=mrref(m,contextptr); 2789 mdividebypivot(m); 2790 int n,c; 2791 mdims(m,n,c); 2792 // check for identity 2793 for (int i=0;i<n;++i){ 2794 if (m[i][i]!=1) 2795 return gensizeerr(contextptr); 2796 } 2797 return matrice_extract(m,0,n,n,c-n); 2798 } 2799 static const char _simult_s[]="simult"; 2800 static define_unary_function_eval (__simult,&simult,_simult_s); 2801 define_unary_function_ptr5( at_simult ,alias_at_simult,&__simult,0,true); 2802 2803 #if defined NSPIRE || defined FXCG // (almost) inert function system for keyboard template system(const gen & g,GIAC_CONTEXT)2804 gen system(const gen & g,GIAC_CONTEXT){ 2805 if (g.type==_VECT) 2806 return *g._VECTptr; 2807 return g; 2808 } 2809 static const char _system_s[]="system"; 2810 static define_unary_function_eval (__system,&system,_system_s); 2811 define_unary_function_ptr5( at_system ,alias_at_system,&__system,0,true); 2812 #endif 2813 2814 /* TI89 compatibility Notes 2815 Use xcas_mode(contextptr)(3) in your config file (~/.xcasrc or xcas.rc) or 2816 begin your session with cas configuration (or type xcas_mode(contextptr)(3)) 2817 2818 1/ Instructions implemented 2819 Algebra: all 2820 Calculus: all except product 2821 Strings: all 2822 Graphics: pixel instructions are not implemented except PxlOn/PxlOff 2823 And/Xor/Pixel tests are not implemented 2824 Zoom instructions not implemented except ZoomSto/ZoomRcl 2825 BldData/RclGDB/StoGDB not implemented 2826 Graph currently points to DrawFunc 2827 Lists: all 2828 Maths: all except conversions and units 2829 Matrices: all except statistics. 2830 LU/QR work with numeric matrices and tolerance argument is ignored 2831 Program: all except 2832 mode handling, units, 2833 getKeys, the Custom and Toolbar instructions 2834 Lock/Unlock 2835 Stats: implemented !, rand, RandSeed, nCr, nPr, median, mean, stddev 2836 2837 2/ Be sure to use correct case. archive (native) is not like Archive (TI) 2838 Conversion of special char (ASCII code >128) 2839 conversion sign translated to to 2840 Store sign: => 2841 Different: != or <>, Greater or equal: >=, Lower or equal: <= 2842 i=sqrt(-1): use the i button of xcas 2843 transpose sign not translated (use transpose()) 2844 */ 2845 2846 // FIXME SECURITY 2847 // archive is made of couples name/value read_ti_archive(const string & s,GIAC_CONTEXT)2848 static sym_string_tab read_ti_archive(const string & s,GIAC_CONTEXT){ 2849 vecteur v; 2850 #if !defined NSPIRE && !defined FXCG && !defined GIAC_HAS_STO_38 2851 ifstream inf(s.c_str()); 2852 readargs_from_stream(inf,v,contextptr); 2853 #endif 2854 sym_string_tab res; 2855 const_iterateur it=v.begin(),itend=v.end(); 2856 for (;it!=itend;++it){ 2857 if (it->type!=_STRNG) 2858 continue; 2859 string name=*it->_STRNGptr; 2860 ++it; 2861 if (it==itend) 2862 break; 2863 gen value=*it; 2864 res[name]=value; 2865 } 2866 return res; 2867 } 2868 print_ti_archive(const string & s,const sym_string_tab & m)2869 static void print_ti_archive(const string & s,const sym_string_tab & m){ 2870 #if defined NSPIRE || defined FXCG || defined GIAC_HAS_STO_38 2871 return; 2872 #else 2873 if (is_undef(check_secure())) 2874 return ; 2875 ofstream of(s.c_str()); 2876 sym_string_tab::const_iterator it=m.begin(),itend=m.end(); 2877 if (it==itend){ 2878 of << "[ ]" << '\n'; 2879 return; 2880 } 2881 of << "[" << string2gen(it->first,false) ; 2882 of << "," << it->second ; 2883 ++it; 2884 for (;it!=itend;++it){ 2885 of << "," << '\n' ; 2886 of << string2gen(it->first,false) ; 2887 of << "," << it->second ; 2888 } 2889 of << "]" << '\n'; 2890 #endif 2891 } _Archive(const gen & g,GIAC_CONTEXT)2892 gen _Archive(const gen & g,GIAC_CONTEXT){ 2893 if ( g.type==_STRNG && g.subtype==-1) return g; 2894 sym_string_tab arc(read_ti_archive("archive",contextptr)); 2895 if (g.type==_IDNT) 2896 arc[g.print(contextptr)]=eval(g,eval_level(contextptr),contextptr); 2897 else { 2898 if (g.type!=_VECT) 2899 return gensizeerr(contextptr); 2900 const_iterateur it=g._VECTptr->begin(),itend=g._VECTptr->end(); 2901 for (;it!=itend;++it){ 2902 if (it->type==_IDNT) 2903 arc[it->print(contextptr)]=eval(*it,eval_level(contextptr),contextptr); 2904 } 2905 } 2906 print_ti_archive("archive",arc); 2907 return 1; 2908 } 2909 static const char _Archive_s[]="Archive"; 2910 static define_unary_function_eval2_quoted (__Archive,&_Archive,_Archive_s,&printastifunction); 2911 define_unary_function_ptr5( at_Archive ,alias_at_Archive,&__Archive,_QUOTE_ARGUMENTS,T_RETURN); 2912 _Unarchiv(const gen & g,GIAC_CONTEXT)2913 gen _Unarchiv(const gen & g,GIAC_CONTEXT){ 2914 if ( g.type==_STRNG && g.subtype==-1) return g; 2915 sym_string_tab arc(read_ti_archive("archive",contextptr)); 2916 gen tmpsto; 2917 if (g.type==_IDNT) 2918 return sto(arc[g.print(contextptr)],g,contextptr); 2919 else { 2920 if (g.type!=_VECT) 2921 return gensizeerr(contextptr); 2922 const_iterateur it=g._VECTptr->begin(),itend=g._VECTptr->end(); 2923 for (;it!=itend;++it){ 2924 if (it->type==_IDNT){ 2925 sto(arc[it->print(contextptr)],*it,contextptr); 2926 if (is_undef(tmpsto)) return tmpsto; 2927 } 2928 } 2929 } 2930 return 1; 2931 } 2932 static const char _Unarchiv_s[]="Unarchiv"; 2933 static define_unary_function_eval2_quoted (__Unarchiv,&_Unarchiv,_Unarchiv_s,&printastifunction); 2934 define_unary_function_ptr5( at_Unarchiv ,alias_at_Unarchiv,&__Unarchiv,_QUOTE_ARGUMENTS,T_RETURN); 2935 2936 static const char _ti_then_s[]="ti_then"; 2937 static define_unary_function_eval (__ti_then,0,_ti_then_s); // never evaled 2938 define_unary_function_ptr( at_ti_then ,alias_at_ti_then ,&__ti_then); 2939 2940 static const char _ti_elseif_s[]="ti_elseif"; 2941 static define_unary_function_eval (__ti_elseif,0,_ti_elseif_s); // never evaled 2942 define_unary_function_ptr( at_ti_elseif ,alias_at_ti_elseif ,&__ti_elseif); 2943 2944 static const char _ti_else_try_s[]="ti_else_try"; 2945 static define_unary_function_eval (__ti_else_try,0,_ti_else_try_s); // never evaled 2946 define_unary_function_ptr( at_ti_else_try ,alias_at_ti_else_try ,&__ti_else_try); 2947 2948 static const char _ti_else_s[]="ti_else"; 2949 static define_unary_function_eval (__ti_else,0,_ti_else_s); // never evaled 2950 define_unary_function_ptr( at_ti_else ,alias_at_ti_else ,&__ti_else); 2951 ti_stop(const gen & g,GIAC_CONTEXT)2952 static gen ti_stop(const gen & g,GIAC_CONTEXT){ 2953 return gensizeerr(gettext("TI stop")); 2954 } 2955 static const char _ti_stop_s[]="ti_stop"; 2956 static define_unary_function_eval (__ti_stop,&ti_stop,_ti_stop_s); // never evaled 2957 define_unary_function_ptr( at_ti_stop ,alias_at_ti_stop ,&__ti_stop); 2958 2959 2960 // French structure keywords printassialorssinon(const gen & feuille,const char * sommetstr,GIAC_CONTEXT)2961 static string printassialorssinon(const gen & feuille,const char * sommetstr,GIAC_CONTEXT){ 2962 if (xcas_mode(contextptr)==3 || python_compat(contextptr)) 2963 return printasifte(feuille,sommetstr,contextptr); 2964 int l=language(contextptr); 2965 if ( (feuille.type!=_VECT) || (feuille._VECTptr->size()!=3) ) 2966 return localize("sialorssinon",l)+"("+feuille.print(contextptr)+')'; 2967 const_iterateur it=feuille._VECTptr->begin(); // ,itend=feuille._VECTptr->end(); 2968 string res(localize("si",l)+' '); 2969 res += sametoequal(*it).print(contextptr); 2970 ++it; 2971 res += ' '; 2972 res += localize("alors",l); 2973 res += ' '; 2974 debug_ptr(contextptr)->indent_spaces +=2; 2975 if ((it->type==_SYMB) && (it->_SYMBptr->sommet==at_bloc)) 2976 res += printasinnerbloc(it->_SYMBptr->feuille,contextptr); 2977 else 2978 res += it->print(contextptr) ; 2979 debug_ptr(contextptr)->indent_spaces -=2; 2980 res += ' '; 2981 res += localize("sinon",l); 2982 res += ' '; 2983 ++it; 2984 debug_ptr(contextptr)->indent_spaces +=2; 2985 if ( (it->type==_SYMB) && (it->_SYMBptr->sommet==at_bloc)) 2986 res += printasinnerbloc(it->_SYMBptr->feuille,contextptr); 2987 else 2988 res += it->print(contextptr) ; 2989 debug_ptr(contextptr)->indent_spaces -=2; 2990 res += indent(contextptr)+ localize("fsi",l); 2991 return res; 2992 } 2993 _sialorssinon(const gen & g,GIAC_CONTEXT)2994 gen _sialorssinon(const gen & g,GIAC_CONTEXT){ 2995 if ( g.type==_STRNG && g.subtype==-1) return g; 2996 return _ifte(g,contextptr); 2997 } 2998 static const char _sialorssinon_s[]="sialorssinon"; 2999 static define_unary_function_eval2_quoted (__sialorssinon,&_ifte,_sialorssinon_s,&printassialorssinon); 3000 define_unary_function_ptr5( at_sialorssinon ,alias_at_sialorssinon,&__sialorssinon,_QUOTE_ARGUMENTS,T_IFTE); 3001 3002 static const char _si_s[]="si"; 3003 static define_unary_function_eval2_quoted (__si,&_ifte,_si_s,&printassialorssinon); 3004 define_unary_function_ptr5( at_si ,alias_at_si,&__si,_QUOTE_ARGUMENTS,T_IF); 3005 3006 static const char _alors_s[]="alors"; 3007 static define_unary_function_eval_quoted (__alors,&_ifte,_alors_s); 3008 define_unary_function_ptr5( at_alors ,alias_at_alors,&__alors,_QUOTE_ARGUMENTS,T_THEN); 3009 3010 static const char _sinon_s[]="sinon"; 3011 static define_unary_function_eval_quoted (__sinon,&_ifte,_sinon_s); 3012 define_unary_function_ptr5( at_sinon ,alias_at_sinon,&__sinon,_QUOTE_ARGUMENTS,T_ELSE); 3013 printaspour(const gen & feuille,const char * sommetstr,GIAC_CONTEXT)3014 static string printaspour(const gen & feuille,const char * sommetstr,GIAC_CONTEXT){ 3015 if (xcas_mode(contextptr)==3 || python_compat(contextptr)) 3016 return printasfor(feuille,sommetstr,contextptr); 3017 if ( (feuille.type!=_VECT) || (feuille._VECTptr->size()!=4) ) 3018 return string(sommetstr)+('('+feuille.print(contextptr)+')'); 3019 int l=language(contextptr); 3020 const_iterateur it=feuille._VECTptr->begin(); //,itend=feuille._VECTptr->end(); 3021 string res; 3022 if (is_zero(*it,contextptr) && is_zero(*(it+2),contextptr)){ 3023 ++it; 3024 res += localize("tantque",l); 3025 res += ' '; 3026 res += sametoequal(*it).print(contextptr) + ' '; 3027 res += localize("faire",l); 3028 res += ' '; 3029 ++it; 3030 ++it; 3031 debug_ptr(contextptr)->indent_spaces += 2; 3032 if ((it->type==_SYMB) && (it->_SYMBptr->sommet==at_bloc)) 3033 res += printasinnerbloc(it->_SYMBptr->feuille,contextptr); 3034 else 3035 res += it->print(contextptr) ; 3036 debug_ptr(contextptr)->indent_spaces -= 2; 3037 return res+indent(contextptr)+' '+localize("ftantque",l)+';'; 3038 } 3039 else { 3040 if ( (it->type!=_SYMB) || (it->_SYMBptr->sommet!=at_sto) || ((it+2)->type!=_SYMB) || ((it+2)->_SYMBptr->sommet!=at_sto) || (it->_SYMBptr->feuille._VECTptr->back()!=(it+2)->_SYMBptr->feuille._VECTptr->back()) ){ 3041 res=localize("pour",l)+" ("; 3042 res += it->print(contextptr) + ';'; 3043 ++it; 3044 res += it->print(contextptr) + ';'; 3045 ++it; 3046 res += it->print(contextptr) + ") "; 3047 ++it; 3048 debug_ptr(contextptr)->indent_spaces += 2; 3049 res += it->print(contextptr) ; 3050 debug_ptr(contextptr)->indent_spaces -= 2; 3051 } 3052 else { 3053 gen var_name=it->_SYMBptr->feuille._VECTptr->back(); 3054 gen step=normal((it+2)->_SYMBptr->feuille._VECTptr->front()-var_name,contextptr); 3055 gen condition=*(it+1),limite; 3056 bool simple_loop=false,strict=true,ascending=true; 3057 if (condition.type==_SYMB){ 3058 const unary_function_ptr op=condition._SYMBptr->sommet; 3059 if (condition._SYMBptr->feuille.type==_VECT){ 3060 if (op==at_inferieur_strict) 3061 simple_loop=true; 3062 if (op==at_inferieur_egal){ 3063 strict=false; 3064 simple_loop=true; 3065 } 3066 if (op==at_superieur_strict){ 3067 simple_loop=(xcas_mode(contextptr)==2); 3068 ascending=false; 3069 } 3070 if (op==at_superieur_egal){ 3071 simple_loop=(xcas_mode(contextptr)==2); 3072 ascending=false; 3073 strict=false; 3074 } 3075 } 3076 if (simple_loop){ 3077 simple_loop=(condition._SYMBptr->feuille._VECTptr->front()==var_name); 3078 limite=condition._SYMBptr->feuille._VECTptr->back(); 3079 } 3080 } 3081 res =localize("pour",l)+' '; 3082 res += var_name.print(contextptr); 3083 res += ' '+localize("de",l)+' '; 3084 res += it->_SYMBptr->feuille._VECTptr->front().print(contextptr); 3085 if (simple_loop){ 3086 step = abs(step,contextptr); 3087 if (ascending) 3088 res += ' '+localize("jusque",l)+' '; 3089 else 3090 res += ' '+localize("downto",l)+' '; 3091 res += limite.print(contextptr); 3092 if (strict){ 3093 if (ascending) 3094 res +="+"; 3095 else 3096 res += "-"; 3097 res += step.print(contextptr); 3098 res += "/2"; 3099 } 3100 } 3101 if (!is_one(step)){ 3102 res += ' '+localize("by",l)+' '; 3103 res += step.print(contextptr); 3104 } 3105 if (!simple_loop){ 3106 res += ' '+localize("tantque",l)+' '; 3107 res += (it+1)->print(contextptr); 3108 } 3109 res += ' '+localize("faire",l)+' '; 3110 it += 3; 3111 if ((it->type==_SYMB) && (it->_SYMBptr->sommet==at_bloc)) 3112 res += printasinnerbloc(it->_SYMBptr->feuille,contextptr); 3113 else 3114 res += it->print(contextptr) ; 3115 return res + indent(contextptr)+' '+localize("fpour",l)+';'; 3116 } 3117 } 3118 if (res[res.size()-1]!='}') 3119 res += "; "; 3120 return res; 3121 } _pour(const gen & g,GIAC_CONTEXT)3122 gen _pour(const gen & g,GIAC_CONTEXT){ 3123 if ( g.type==_STRNG && g.subtype==-1) return g; 3124 return _for(g,contextptr); 3125 } 3126 static const char _pour_s[]="pour"; 3127 static define_unary_function_eval2_quoted (__pour,&_for,_pour_s,&printaspour); 3128 define_unary_function_ptr5( at_pour ,alias_at_pour,&__pour,_QUOTE_ARGUMENTS,T_FOR); 3129 3130 static const char _de_s[]="de"; 3131 static define_unary_function_eval_quoted (__de,&_for,_de_s); 3132 define_unary_function_ptr5( at_de ,alias_at_de,&__de,_QUOTE_ARGUMENTS,T_FROM); 3133 3134 static const char _faire_s[]="faire"; 3135 static define_unary_function_eval_quoted (__faire,&_for,_faire_s); 3136 define_unary_function_ptr5( at_faire ,alias_at_faire,&__faire,_QUOTE_ARGUMENTS,T_DO); 3137 3138 static const char _pas_s[]="pas"; 3139 static define_unary_function_eval_quoted (__pas,&_for,_pas_s); 3140 define_unary_function_ptr5( at_pas ,alias_at_pas,&__pas,_QUOTE_ARGUMENTS,T_BY); 3141 3142 static const char _jusque_s[]="jusque"; 3143 static define_unary_function_eval_quoted (__jusque,&_for,_jusque_s); 3144 define_unary_function_ptr5( at_jusque ,alias_at_jusque,&__jusque,_QUOTE_ARGUMENTS,T_TO); 3145 3146 static const char _tantque_s[]="tantque"; 3147 static define_unary_function_eval2_quoted (__tantque,&_for,_tantque_s,&printaspour); 3148 define_unary_function_ptr5( at_tantque ,alias_at_tantque,&__tantque,_QUOTE_ARGUMENTS,T_MUPMAP_WHILE); 3149 3150 static const char _et_s[]="et"; 3151 static define_unary_function_eval4_quoted (__et,&_and,_et_s,&printasand,&texprintasand); 3152 define_unary_function_ptr5( at_et ,alias_at_et,&__et,_QUOTE_ARGUMENTS,T_AND_OP); 3153 3154 static const char _oufr_s[]="ou"; 3155 static define_unary_function_eval4_quoted (__oufr,&_ou,_oufr_s,&printasor,&texprintasor); 3156 define_unary_function_ptr5( at_oufr ,alias_at_oufr,&__oufr,_QUOTE_ARGUMENTS,T_AND_OP); 3157 3158 static const char _non_s[]="non"; 3159 static define_unary_function_eval (__non,&_not,_non_s); 3160 define_unary_function_ptr5( at_non ,alias_at_non,&__non,0,T_NOT); 3161 3162 /* 3163 static const char _resultat_s[]="resultat"; 3164 static define_unary_function_eval_quoted (__resultat,&_nop,_resultat_s); 3165 define_unary_function_ptr5( at_resultat ,alias_at_resultat,&__resultat,_QUOTE_ARGUMENTS,T_RETURN); 3166 */ 3167 3168 static const char _fonction_s[]="fonction"; 3169 static define_unary_function_eval_quoted (__fonction,&_for,_fonction_s); 3170 define_unary_function_ptr5( at_fonction ,alias_at_fonction,&__fonction,_QUOTE_ARGUMENTS,T_PROC); 3171 3172 #if defined RTOS_THREADX || defined BESTA_OS || defined EMCC || defined __MINGW_H || defined KHICAS 3173 _unarchive_ti(const gen & g,GIAC_CONTEXT)3174 gen _unarchive_ti(const gen & g,GIAC_CONTEXT){ 3175 return undef; 3176 } 3177 3178 #else 3179 ti_decode_unsigned(octet * & ptr,GIAC_CONTEXT)3180 static gen ti_decode_unsigned(octet * & ptr,GIAC_CONTEXT){ 3181 short l=(*ptr); 3182 --ptr; 3183 // Horner 3184 gen res; 3185 for (short i=0;i<l;++i,--ptr) 3186 res=256*res+int(*ptr); 3187 return res; 3188 } 3189 ti_decode_double(octet * & ptr,GIAC_CONTEXT)3190 static double ti_decode_double(octet * & ptr,GIAC_CONTEXT){ 3191 ptr -= 8; 3192 octet c1=*ptr,c2=*(ptr+1); 3193 unsigned int c=c1*256+c2; 3194 int mantissa=c-4*16*16*16-13; 3195 octet * q=ptr+2; 3196 --ptr; 3197 double d=0; 3198 for (int i=0;i<7;++i,++q){ 3199 // now read quartet by quartet in BCD 3200 c1=(*q) & 0xF0; 3201 c1=c1 >> 4; 3202 d=d*10+c1; 3203 c2=(*q) & 0x0F; 3204 d=d*10+c2; 3205 } 3206 // multiply by 10^-mantissa 3207 d=d*std::pow(10.0,double(mantissa)); 3208 return d; 3209 } 3210 ti_decode_fraction(octet * & ptr,GIAC_CONTEXT)3211 static gen ti_decode_fraction(octet * & ptr,GIAC_CONTEXT){ 3212 --ptr; 3213 gen num=ti_decode_unsigned(ptr,contextptr); 3214 gen den=ti_decode_unsigned(ptr,contextptr); 3215 return fraction(num,den); 3216 } 3217 make_symbol(const string & s,GIAC_CONTEXT)3218 gen make_symbol(const string & s,GIAC_CONTEXT){ 3219 gen res; 3220 if (find_or_make_symbol(s,res,0,false,contextptr)==T_SYMBOL) 3221 return res; 3222 else 3223 return make_symbol("_"+s,contextptr); 3224 } 3225 ti_decode_identificateur(octet * & ptr,GIAC_CONTEXT)3226 static gen ti_decode_identificateur(octet * &ptr,GIAC_CONTEXT){ 3227 string s; 3228 octet c; 3229 for (;(c=*ptr)!=VAR_NAME_TAG;--ptr){ 3230 if (c>0x7f){ 3231 s="Z"+print_INT_(-char(c))+s; 3232 } 3233 else 3234 s = (char) c+s; 3235 } 3236 --ptr; 3237 int pos=int(s.find('\\')); 3238 int l=int(s.size()); 3239 gen res; 3240 if (pos>0 && pos+1<l){ 3241 string s1=s.substr(0,pos); 3242 string s2=s.substr(pos+1,l-pos-1); 3243 res=symb_double_deux_points(makevecteur(make_symbol(s1,contextptr),make_symbol(s2,contextptr))); 3244 } 3245 else 3246 res=make_symbol(s,contextptr); 3247 return res; 3248 } 3249 3250 // Also used for variable arguments functions ti_decode_list(octet * & ptr,octet end,GIAC_CONTEXT)3251 static vecteur ti_decode_list(octet * & ptr,octet end,GIAC_CONTEXT){ 3252 vecteur res; 3253 for (;(*ptr)!=end;) 3254 res.push_back(ti_decode_tag(ptr,contextptr)); 3255 --ptr; 3256 return res; 3257 } 3258 3259 // true if it's a newline or nextexp ti_decode_newline(octet * & ptr,GIAC_CONTEXT)3260 static bool ti_decode_newline(octet * & ptr,GIAC_CONTEXT){ 3261 if (*ptr==NEWLINE_TAG || *ptr==NEXTEXPR_TAG){ 3262 --ptr; 3263 if (!*ptr) 3264 --ptr; 3265 ti_decode_newline(ptr,contextptr); 3266 return true; 3267 } 3268 return false; 3269 } ti_decode_list(octet * & ptr,octet end1,octet end2,GIAC_CONTEXT)3270 static vecteur ti_decode_list(octet * & ptr,octet end1,octet end2,GIAC_CONTEXT){ 3271 vecteur res; 3272 for (;;){ 3273 ti_decode_newline(ptr,contextptr); 3274 if (*(ptr-1)==end1 && *ptr==end2) 3275 break; 3276 res.push_back(ti_decode_tag(ptr,contextptr)); 3277 } 3278 ptr -=2 ; 3279 return res; 3280 } 3281 ti_decode_string(octet * & ptr,GIAC_CONTEXT)3282 static string ti_decode_string(octet * & ptr,GIAC_CONTEXT){ 3283 string s; 3284 char c; 3285 for (; (c=(*ptr)) ;--ptr){ 3286 switch (c){ 3287 case '\\': 3288 s="::"+s; 3289 default: 3290 s=c+s; 3291 } 3292 } 3293 --ptr; 3294 return s; 3295 } 3296 ti_decode_function(octet * & ptr,GIAC_CONTEXT)3297 static gen ti_decode_function(octet * & ptr,GIAC_CONTEXT){ 3298 octet flag1=*ptr; 3299 if (!(flag1 &0x08)){ 3300 ptr -=3; 3301 vecteur param; 3302 // decode parameter list 3303 for (;*ptr!=END_TAG;){ // END_TAG==0xE5 3304 param.push_back(ti_decode_tag(ptr,contextptr)); 3305 } 3306 --ptr; 3307 // now either it's a function like x->sin(x) 3308 // or a bloc function/program with local var 3309 // in the second case we will have FUNC_ITAG 0x17 or PRGM_ITAG 0x19 0xE4 3310 // if local var are there we will in addition have LOCAL_ITAG 0xE4 etc. 3311 vecteur prog; 3312 for (;*ptr!=END_OF_SEGMENT;) 3313 prog.push_back(ti_decode_tag(ptr,contextptr)); 3314 --ptr; 3315 if (prog.size()==1) 3316 return symb_program(gen(param,_SEQ__VECT),param*zero,prog.front(),contextptr); 3317 else 3318 return symb_program(gen(param,_SEQ__VECT),param*zero,prog,contextptr); 3319 } 3320 return gensizeerr(gettext("Can't find length of non tokenized programs")); 3321 } ti_decode_sysvar_tag(octet * & ptr,GIAC_CONTEXT)3322 static gen ti_decode_sysvar_tag(octet * & ptr,GIAC_CONTEXT){ 3323 gen res; 3324 switch (*ptr){ 3325 case X_BAR_TAG: 3326 res=make_symbol("xmean",contextptr); 3327 break; case Y_BAR_TAG: 3328 res=make_symbol("ymean",contextptr); 3329 break; case SIGMA_X_TAG: 3330 res=make_symbol("Sx",contextptr); 3331 break; case SIGMA_X2_TAG: 3332 res=make_symbol("Sx2",contextptr); 3333 break; case SIGMA_Y_TAG: 3334 res=make_symbol("Sy",contextptr); 3335 break; case SIGMA_Y2_TAG: 3336 res=make_symbol("Sy2",contextptr); 3337 break; case SIGMA_XY_TAG: 3338 res=make_symbol("Sxy",contextptr); 3339 break; case SX_TAG: 3340 res=make_symbol("Sx",contextptr); 3341 break; case SY_TAG: 3342 res=make_symbol("Sy",contextptr); 3343 break; case SMLSIGMA_X_TAG: 3344 res=make_symbol("sx",contextptr); 3345 break; case SMLSIGMA_Y_TAG: 3346 res=make_symbol("sy",contextptr); 3347 break; case NSTAT_TAG: 3348 res=make_symbol("nStat",contextptr); 3349 break; case MINX_TAG: 3350 res=make_symbol("minX",contextptr); 3351 break; case MINY_TAG: 3352 res=make_symbol("minY",contextptr); 3353 break; case Q1_TAG: 3354 res=make_symbol("q1",contextptr); 3355 break; case MEDSTAT_TAG: 3356 res=make_symbol("medStat",contextptr); 3357 break; case Q3_TAG: 3358 res=make_symbol("q3",contextptr); 3359 break; case MAXX_TAG: 3360 res=make_symbol("maxX",contextptr); 3361 break; case MAXY_TAG: 3362 res=make_symbol("maxY",contextptr); 3363 break; case CORR_TAG: 3364 res=make_symbol("corr",contextptr); 3365 break; case R2_TAG: 3366 res=make_symbol("R2",contextptr); 3367 break; case MEDX1_TAG: 3368 res=make_symbol("mdex1",contextptr); 3369 break; case MEDX2_TAG: 3370 res=make_symbol("medx2",contextptr); 3371 break; case MEDX3_TAG: 3372 res=make_symbol("medx3",contextptr); 3373 break; case MEDY1_TAG: 3374 res=make_symbol("medy1",contextptr); 3375 break; case MEDY2_TAG: 3376 res=make_symbol("medy2",contextptr); 3377 break; case MEDY3_TAG: 3378 res=make_symbol("medy3",contextptr); 3379 break; case XC_TAG: 3380 res=make_symbol("xc",contextptr); 3381 break; case YC_TAG: 3382 res=make_symbol("yc",contextptr); 3383 break; case ZC_TAG: 3384 res=make_symbol("zc",contextptr); 3385 break; case TC_TAG: 3386 res=make_symbol("tc",contextptr); 3387 break; case RC_TAG: 3388 res=make_symbol("rc",contextptr); 3389 break; case THETA_C_TAG: 3390 res=make_symbol("qc",contextptr); 3391 break; case NC_TAG: 3392 res=make_symbol("nc",contextptr); 3393 break; case XFACT_TAG: 3394 res=make_symbol("xfact",contextptr); 3395 break; case YFACT_TAG: 3396 res=make_symbol("yfact",contextptr); 3397 break; case ZFACT_TAG: 3398 res=make_symbol("zfact",contextptr); 3399 break; case XMIN_TAG: 3400 res=make_symbol("xmin",contextptr); 3401 break; case XMAX_TAG: 3402 res=make_symbol("xmax",contextptr); 3403 break; case XSCL_TAG: 3404 res=make_symbol("xscl",contextptr); 3405 break; case YMIN_TAG: 3406 res=make_symbol("ymin",contextptr); 3407 break; case YMAX_TAG: 3408 res=make_symbol("ymax",contextptr); 3409 break; case YSCL_TAG: 3410 res=make_symbol("yscl",contextptr); 3411 break; case DELTA_X_TAG: 3412 res=make_symbol("Dx",contextptr); 3413 break; case DELTA_Y_TAG: 3414 res=make_symbol("Dy",contextptr); 3415 break; case XRES_TAG: 3416 res=make_symbol("xres",contextptr); 3417 break; case XGRID_TAG: 3418 res=make_symbol("xgrid",contextptr); 3419 break; case YGRID_TAG: 3420 res=make_symbol("ygrid",contextptr); 3421 break; case ZMIN_TAG: 3422 res=make_symbol("zmin",contextptr); 3423 break; case ZMAX_TAG: 3424 res=make_symbol("zmax",contextptr); 3425 break; case ZSCL_TAG: 3426 res=make_symbol("zscl",contextptr); 3427 break; case EYE_THETA_TAG: 3428 res=make_symbol("eyeq",contextptr); 3429 break; case EYE_PHI_TAG: 3430 res=make_symbol("eyeF",contextptr); 3431 break; case THETA_MIN_TAG: 3432 res=make_symbol("qmin",contextptr); 3433 break; case THETA_MAX_TAG: 3434 res=make_symbol("qmax",contextptr); 3435 break; case THETA_STEP_TAG: 3436 res=make_symbol("qstep",contextptr); 3437 break; case TMIN_TAG: 3438 res=make_symbol("tmin",contextptr); 3439 break; case TMAX_TAG: 3440 res=make_symbol("tmax",contextptr); 3441 break; case TSTEP_TAG: 3442 res=make_symbol("tstep",contextptr); 3443 break; case NMIN_TAG: 3444 res=make_symbol("nmin",contextptr); 3445 break; case NMAX_TAG: 3446 res=make_symbol("nmax",contextptr); 3447 break; case PLOTSTRT_TAG: 3448 res=make_symbol("plotStrt",contextptr); 3449 break; case PLOTSTEP_TAG: 3450 res=make_symbol("plotStep",contextptr); 3451 break; case ZXMIN_TAG: 3452 res=make_symbol("zxmin",contextptr); 3453 break; case ZXMAX_TAG: 3454 res=make_symbol("zxmax",contextptr); 3455 break; case ZXSCL_TAG: 3456 res=make_symbol("zxscl",contextptr); 3457 break; case ZYMIN_TAG: 3458 res=make_symbol("zymin",contextptr); 3459 break; case ZYMAX_TAG: 3460 res=make_symbol("zymax",contextptr); 3461 break; case ZYSCL_TAG: 3462 res=make_symbol("zyscl",contextptr); 3463 break; case ZXRES_TAG: 3464 res=make_symbol("zxres",contextptr); 3465 break; case Z_THETA_MIN_TAG: 3466 res=make_symbol("zqmin",contextptr); 3467 break; case Z_THETA_MAX_TAG: 3468 res=make_symbol("zqmax",contextptr); 3469 break; case Z_THETA_STEP_TAG: 3470 res=make_symbol("zqstep",contextptr); 3471 break; case ZTMIN_TAG: 3472 res=make_symbol("ztmin",contextptr); 3473 break; case ZTMAX_TAG: 3474 res=make_symbol("ztmax",contextptr); 3475 break; case ZTSTEP_TAG: 3476 res=make_symbol("ztsep",contextptr); 3477 break; case ZXGRID_TAG: 3478 res=make_symbol("zxgrid",contextptr); 3479 break; case ZYGRID_TAG: 3480 res=make_symbol("zygrid",contextptr); 3481 break; case ZZMIN_TAG: 3482 res=make_symbol("zzmin",contextptr); 3483 break; case ZZMAX_TAG: 3484 res=make_symbol("zzmax",contextptr); 3485 break; case ZZSCL_TAG: 3486 res=make_symbol("zzscl",contextptr); 3487 break; case ZEYE_THETA_TAG: 3488 res=make_symbol("zeyeq",contextptr); 3489 break; case ZEYE_PHI_TAG: 3490 res=make_symbol("zeyeF",contextptr); 3491 break; case ZNMIN_TAG: 3492 res=make_symbol("znmin",contextptr); 3493 break; case ZNMAX_TAG: 3494 res=make_symbol("znmax",contextptr); 3495 break; case ZPLTSTEP_TAG: 3496 res=make_symbol("zpltstep",contextptr); 3497 break; case ZPLTSTRT_TAG: 3498 res=make_symbol("zpltstrt",contextptr); 3499 break; case SEED1_TAG: 3500 res=make_symbol("seed1",contextptr); 3501 break; case SEED2_TAG: 3502 res=make_symbol("seed2",contextptr); 3503 break; case OK_TAG: 3504 res=make_symbol("ok",contextptr); 3505 break; case ERRORNUM_TAG: 3506 res=make_symbol("errornum",contextptr); 3507 break; case SYSMATH_TAG: 3508 res=make_symbol("sysMath",contextptr); 3509 break; case SYSDATA_TAG: 3510 res=make_symbol("sysData",contextptr); 3511 break; case REGEQ_TAG: 3512 res=make_symbol("regEq",contextptr); 3513 break; case REGCOEF_TAG: 3514 res=make_symbol("regCoef",contextptr); 3515 break; case TBLINPUT_TAG: 3516 res=make_symbol("tblInput",contextptr); 3517 break; case TBLSTART_TAG: 3518 res=make_symbol("tblStart",contextptr); 3519 break; case DELTA_TBL_TAG: 3520 res=make_symbol("Dtbl",contextptr); 3521 break; case FLDPIC_TAG: 3522 res=make_symbol("fldpic",contextptr); 3523 break; case EYE_PSI_TAG: 3524 res=make_symbol("eyeY",contextptr); 3525 break; case TPLOT_TAG: 3526 res=make_symbol("tplot",contextptr); 3527 break; case DIFTOL_TAG: 3528 res=make_symbol("diftol",contextptr); 3529 break; case ZEYE_PSI_TAG: 3530 res=make_symbol("zeyeY",contextptr); 3531 break; case T0_TAG: 3532 res=make_symbol("t0",contextptr); 3533 break; case DTIME_TAG: 3534 res=make_symbol("dtime",contextptr); 3535 break; case NCURVES_TAG: 3536 res=make_symbol("ncurves",contextptr); 3537 break; case FLDRES_TAG: 3538 res=make_symbol("fldres",contextptr); 3539 break; case ESTEP_TAG: 3540 res=make_symbol("Estep",contextptr); 3541 break; case ZT0DE_TAG: 3542 res=make_symbol("zt0de",contextptr); 3543 break; case ZTMAXDE_TAG: 3544 res=make_symbol("ztmaxde",contextptr); 3545 break; case ZTSTEPDE_TAG: 3546 res=make_symbol("ztstepde",contextptr); 3547 break; case ZTPLOTDE_TAG: 3548 res=make_symbol("ztplotde",contextptr); 3549 break; case NCONTOUR_TAG: 3550 res=make_symbol("ncontout",contextptr); 3551 default: 3552 return gensizeerr(gettext("Unknown sysvar tag")+print_INT_(*ptr)); 3553 } 3554 --ptr; 3555 return res; 3556 } 3557 ti_decode_unary(octet * & ptr,const unary_function_ptr * u,GIAC_CONTEXT)3558 static gen ti_decode_unary(octet * & ptr,const unary_function_ptr * u,GIAC_CONTEXT){ 3559 --ptr; 3560 gen g=ti_decode_tag(ptr,contextptr); 3561 return symbolic(u,g); 3562 } 3563 ti_decode_binary(octet * & ptr,const unary_function_ptr * u,bool normal_order=true,GIAC_CONTEXT=0)3564 static gen ti_decode_binary(octet * & ptr,const unary_function_ptr * u,bool normal_order=true,GIAC_CONTEXT=0){ 3565 --ptr; 3566 gen g1=ti_decode_tag(ptr,contextptr); 3567 gen g2=ti_decode_tag(ptr,contextptr); 3568 if (normal_order) 3569 return symbolic(u,makesequence(g1,g2)); 3570 else 3571 return symbolic(u,makesequence(g2,g1)); 3572 } 3573 ti_decode_nary(octet * & ptr,const unary_function_ptr * u,int n,GIAC_CONTEXT)3574 static gen ti_decode_nary(octet * & ptr,const unary_function_ptr * u,int n,GIAC_CONTEXT){ 3575 --ptr; 3576 vecteur arg; 3577 for (;*ptr!=END_TAG;) 3578 arg.push_back(ti_decode_tag(ptr,contextptr)); 3579 --ptr; 3580 return symbolic(u,gen(arg,_SEQ__VECT)); 3581 } 3582 ti_decode_arb_real(octet * & ptr,bool real,GIAC_CONTEXT)3583 static gen ti_decode_arb_real(octet * & ptr,bool real,GIAC_CONTEXT){ 3584 unsigned int i=*ptr; 3585 --ptr; 3586 string s; 3587 gen res; 3588 if (real) 3589 s="at_"; 3590 else 3591 s="at_n"; 3592 s += print_INT_(i); 3593 find_or_make_symbol(s,res,0,false,contextptr); 3594 return res; 3595 } 3596 ti_decode_not_implemented(octet * & ptr,const string & s,int i,GIAC_CONTEXT)3597 static gen ti_decode_not_implemented(octet * & ptr,const string & s,int i,GIAC_CONTEXT){ 3598 gen gs(string2gen(s,false)); 3599 gen g; 3600 if (i==1) 3601 g=ti_decode_unary(ptr,at_ti_not_implemented,contextptr); 3602 else { 3603 if (i==2) 3604 g=ti_decode_binary(ptr,at_ti_not_implemented,true,contextptr); 3605 else 3606 g=ti_decode_nary(ptr,at_ti_not_implemented,-i,contextptr); 3607 } 3608 gen gf=g._SYMBptr->feuille; 3609 if (gf.type==_VECT) 3610 gf.subtype=_SEQ__VECT; 3611 return symbolic(at_ti_not_implemented,makesequence(gs,gf)); 3612 } 3613 3614 // secondary or extension tag ti_secondary_tag(octet * & ptr,GIAC_CONTEXT)3615 static gen ti_secondary_tag(octet * & ptr,GIAC_CONTEXT){ 3616 switch (*ptr){ 3617 case INDIR_TAG: 3618 return ti_decode_unary(ptr,at_hash,contextptr); 3619 case GETKEY_TAG: 3620 return ti_decode_not_implemented(ptr,"getKey",-0,contextptr); 3621 // --ptr; 3622 // return symbolic(at_getKey,vecteur(0)); 3623 case GETFOLD_TAG: 3624 return ti_decode_not_implemented(ptr,"getFold",-0,contextptr); 3625 // --ptr; 3626 // return symbolic(at_GetFold,vecteur(0)); 3627 case SWITCH_TAG: 3628 return ti_decode_nary(ptr,at_window_switch,0,contextptr); 3629 case UNITCONV_TAG: 3630 return ti_decode_not_implemented(ptr,"UnitConv",2,contextptr); 3631 case ORD_TAG: 3632 return ti_decode_unary(ptr,at_ord,contextptr); 3633 case EXPR_TAG: 3634 return ti_decode_unary(ptr,at_expr,contextptr); 3635 case CHAR_TAG: 3636 return ti_decode_unary(ptr,at_char,contextptr); 3637 case STRING_TAG: 3638 return ti_decode_unary(ptr,at_string,contextptr); 3639 case SETFOLD_TAG: 3640 return ti_decode_unary(ptr,at_SetFold,contextptr); 3641 case GETTYPE_TAG: 3642 return ti_decode_unary(ptr,at_getType,contextptr); 3643 case GETMODE_TAG: 3644 return ti_decode_not_implemented(ptr,"getMode",1,contextptr); 3645 case PTTEST_TAG: 3646 return ti_decode_not_implemented(ptr,"ptTest",2,contextptr); 3647 case PXLTEST_TAG: 3648 return ti_decode_not_implemented(ptr,"PxlTest",2,contextptr); 3649 case SETGRAPH_TAG: 3650 return ti_decode_not_implemented(ptr,"setGraph",2,contextptr); 3651 case SETTABLE_TAG: 3652 return ti_decode_not_implemented(ptr,"setTable",2,contextptr); 3653 case SETMODE_TAG: 3654 return ti_decode_not_implemented(ptr,"setMode",-1,contextptr); 3655 case FORMAT_TAG: 3656 return ti_decode_nary(ptr,at_format,1,contextptr); 3657 case INSTRING_TAG: 3658 return ti_decode_nary(ptr,at_inString,2,contextptr); 3659 case APPEND_TAG: 3660 return ti_decode_binary(ptr,at_append,false,contextptr); 3661 case DD_TAG: 3662 return ti_decode_not_implemented(ptr,"DD",1,contextptr); 3663 case EXPR2DMS_TAG: 3664 return ti_decode_not_implemented(ptr,"->DMS",1,contextptr); 3665 case VEC2RECT_TAG: 3666 return ti_decode_not_implemented(ptr,">Rect",1,contextptr); 3667 case VEC2POLAR_TAG: 3668 return ti_decode_not_implemented(ptr,">Polar",1,contextptr); 3669 case VEC2CYLIND_TAG: 3670 return ti_decode_not_implemented(ptr,">Cylind",1,contextptr); 3671 case VEC2SPHERE_TAG: 3672 return ti_decode_not_implemented(ptr,">Sphere",1,contextptr); 3673 case PARENTH_START_TAG: 3674 case PARENTH_END_TAG: 3675 case MAT_START_TAG: 3676 case MAT_END_TAG: 3677 case LIST_START_TAG: 3678 case LIST_END_TAG: 3679 case COMMA_TAG: 3680 case SEMICOLON_TAG: 3681 case COMPLEX_ANGLE_TAG: 3682 case SINGLE_QUOTE_TAG: 3683 case QUOTE_TAG: 3684 return gensizeerr(gettext("Parser internal token")); 3685 case POLCPLX_TAG: // FIXME not clear if 2 or (2 or more args) 3686 return ti_decode_not_implemented(ptr,"polCplx",-2,contextptr); 3687 // return ti_decode_not_implemented(ptr,"polCplx",2,contextptr); 3688 case TMPCNV_TAG: 3689 return ti_decode_not_implemented(ptr,"tmpCnv",2,contextptr); 3690 case DELTA_TMPCNV_TAG: 3691 return ti_decode_not_implemented(ptr,"DtmpCnv",2,contextptr); 3692 case GETUNITS_TAG: 3693 return ti_decode_not_implemented(ptr,"getUnits",-0,contextptr); 3694 // --ptr; 3695 // return string2gen("getUnits",false); 3696 case SETUNITS_TAG: 3697 return ti_decode_not_implemented(ptr,"setUnits",1,contextptr); 3698 case BIN_TAG: 3699 return ti_decode_not_implemented(ptr,"0b",1,contextptr); 3700 case HEX_TAG: 3701 return ti_decode_not_implemented(ptr,"0h",1,contextptr); 3702 case INT2BIN_TAG: 3703 return ti_decode_not_implemented(ptr,">Bin",1,contextptr); 3704 case INT2DEC_TAG: 3705 return ti_decode_not_implemented(ptr,">Dec",1,contextptr); 3706 case INT2HEX_TAG: 3707 return ti_decode_not_implemented(ptr,">Hex",1,contextptr); 3708 case DET_TOL_TAG: 3709 return ti_decode_binary(ptr,at_det,true,contextptr); 3710 case REF_TOL_TAG: 3711 return ti_decode_binary(ptr,at_ref,true,contextptr); 3712 case RREF_TOL_TAG: 3713 return ti_decode_binary(ptr,at_rref,true,contextptr); 3714 case SIMULT_TOL_TAG: 3715 return ti_decode_nary(ptr,at_simult,3,contextptr); 3716 case GETCONFG_TAG: 3717 return ti_decode_not_implemented(ptr,"getConfg",-0,contextptr); 3718 // --ptr; 3719 // return string2gen("getConfg",false); 3720 case V_AUGMENT_TAG: 3721 return ti_decode_binary(ptr,at_semi_augment,true,contextptr); 3722 case VARIANCE_TWOARG_TAG: 3723 return ti_decode_binary(ptr,at_variance,true,contextptr); 3724 default: 3725 return gensizeerr(gettext("Unknown secondary tag")+print_INT_(*ptr)); 3726 } 3727 return 0; 3728 } 3729 ti_decode_ifthen(const vecteur & arg0,GIAC_CONTEXT)3730 static gen ti_decode_ifthen(const vecteur & arg0,GIAC_CONTEXT){ 3731 vecteur arg(arg0); 3732 gen gif,gthen,gelse; 3733 int i=equalposcomp(arg,at_ti_then); 3734 if (!i){ 3735 gif=arg.front(); 3736 arg=vecteur(arg.begin()+1,arg.end()); 3737 } 3738 else { 3739 gif=symb_bloc(vecteur(arg.begin(),arg.begin()+i-1)); 3740 arg=vecteur(arg.begin()+i,arg.end()); 3741 } 3742 // elseif? 3743 i=equalposcomp(arg,at_ti_elseif); 3744 if (i){ 3745 gthen=symb_bloc(vecteur(arg.begin(),arg.begin()+i-1)); 3746 arg=vecteur(arg.begin()+i,arg.end()); 3747 return symb_ifte(gif,gthen,ti_decode_ifthen(arg,contextptr)); 3748 } 3749 // no more elseif found, search for else 3750 i=equalposcomp(arg,at_ti_else); 3751 if (!i) 3752 gelse=undef; 3753 else { 3754 gelse=symb_bloc(vecteur(arg.begin()+i,arg.end())); 3755 arg=vecteur(arg.begin(),arg.begin()+i-1); 3756 } 3757 gthen=symb_bloc(arg); 3758 return symb_ifte(gif,gthen,gelse); 3759 } 3760 ti_decode_ifthen(octet * & ptr,GIAC_CONTEXT)3761 static gen ti_decode_ifthen(octet * & ptr,GIAC_CONTEXT){ 3762 vecteur arg(ti_decode_list(ptr,ENDIF_ITAG,COMMAND_TAG,contextptr)); 3763 return ti_decode_ifthen(arg,contextptr); 3764 } 3765 ti_decode_if(octet * & ptr,GIAC_CONTEXT)3766 static gen ti_decode_if(octet * & ptr,GIAC_CONTEXT){ 3767 gen test(ti_decode_tag(ptr,contextptr)); 3768 ti_decode_newline(ptr,contextptr); 3769 gen ifclause(ti_decode_tag(ptr,contextptr)); 3770 ti_decode_newline(ptr,contextptr); 3771 return symb_ifte(test,ifclause,undef); 3772 } 3773 ti_decode_loop(octet * & ptr,GIAC_CONTEXT)3774 static gen ti_decode_loop(octet * & ptr,GIAC_CONTEXT){ 3775 vecteur arg(ti_decode_list(ptr,ENDLOOP_ITAG,COMMAND_TAG,contextptr)); 3776 ptr -= 2; // skip size 3777 return symb_for(zero,plus_one,zero,symb_bloc(arg)); 3778 } 3779 ti_decode_for(octet * & ptr,GIAC_CONTEXT)3780 static gen ti_decode_for(octet * & ptr,GIAC_CONTEXT){ 3781 gen gcompteur(ti_decode_tag(ptr,contextptr)); 3782 gen gdebut(ti_decode_tag(ptr,contextptr)); 3783 gen gfin(ti_decode_tag(ptr,contextptr)); 3784 gen gstep(plus_one); 3785 if (*ptr==END_TAG) 3786 --ptr; 3787 else { 3788 if (!ti_decode_newline(ptr,contextptr)){ 3789 gstep=ti_decode_tag(ptr,contextptr); 3790 if (*ptr==END_TAG) 3791 --ptr; 3792 } 3793 } 3794 ti_decode_newline(ptr,contextptr); 3795 vecteur arg(ti_decode_list(ptr,ENDFOR_ITAG,COMMAND_TAG,contextptr)); 3796 ptr -= 2; // skip size 3797 if (ck_is_strictly_positive(gstep,contextptr)) 3798 return symb_for(symb_sto(gdebut,gcompteur),symb_inferieur_egal(gcompteur,gfin),symb_sto(gcompteur+gstep,gcompteur),symb_bloc(arg)); 3799 else 3800 return symb_for(symb_sto(gdebut,gcompteur),symb_superieur_egal(gcompteur,gfin),symb_sto(gcompteur+gstep,gcompteur),symb_bloc(arg)); 3801 } 3802 ti_decode_while(octet * & ptr,GIAC_CONTEXT)3803 static gen ti_decode_while(octet * & ptr,GIAC_CONTEXT){ 3804 gen test(ti_decode_tag(ptr,contextptr)); 3805 ti_decode_newline(ptr,contextptr); 3806 vecteur arg(ti_decode_list(ptr,ENDWHILE_ITAG,COMMAND_TAG,contextptr)); 3807 ptr -= 2; // skip size 3808 return symb_for(zero,test,zero,symb_bloc(arg)); 3809 } 3810 ti_decode_try(octet * & ptr,GIAC_CONTEXT)3811 static gen ti_decode_try(octet * & ptr,GIAC_CONTEXT){ 3812 vecteur arg(ti_decode_list(ptr,ENDTRY_ITAG,COMMAND_TAG,contextptr)); 3813 ptr -= 2; // skip size 3814 int i=equalposcomp(arg,at_ti_else_try); 3815 gen gtry=symb_bloc(vecteur(arg.begin()+i,arg.end())); 3816 gen gelse=symb_bloc(vecteur(arg.begin(),arg.begin()+i-1)); 3817 return symb_try_catch(makevecteur(gtry,at_break,gelse)); 3818 } 3819 ti_decode_func(octet * & ptr,octet end,GIAC_CONTEXT)3820 static gen ti_decode_func(octet * & ptr,octet end,GIAC_CONTEXT){ 3821 vecteur localvar; 3822 ti_decode_newline(ptr,contextptr); 3823 if (*ptr==COMMENT_TAG){ // skip comment 3824 --ptr; 3825 while (!*ptr) --ptr; 3826 ti_decode_string(ptr,contextptr); 3827 ti_decode_newline(ptr,contextptr); 3828 } 3829 if (*(ptr-1)==LOCAL_ITAG && *ptr==COMMAND_TAG){ // check local 3830 ptr -=2; 3831 localvar=ti_decode_list(ptr,END_TAG,contextptr); 3832 } 3833 vecteur arg(ti_decode_list(ptr,end,COMMAND_TAG,contextptr)); 3834 if (localvar.empty()) 3835 return symb_bloc(arg); 3836 else 3837 return symb_local(localvar,arg,contextptr); 3838 } 3839 ti_decode_dialog(octet * & ptr,GIAC_CONTEXT)3840 static gen ti_decode_dialog(octet * & ptr,GIAC_CONTEXT){ 3841 vecteur arg(ti_decode_list(ptr,ENDDLOG_ITAG,COMMAND_TAG,contextptr)); 3842 return symbolic(at_Dialog,arg); 3843 } 3844 ti_decode_custom(octet * & ptr,GIAC_CONTEXT)3845 static gen ti_decode_custom(octet * & ptr,GIAC_CONTEXT){ 3846 vecteur arg(ti_decode_list(ptr,ENDCUSTM_ITAG,COMMAND_TAG,contextptr)); 3847 return symbolic(at_ti_not_implemented,arg); 3848 } 3849 ti_decode_toolbar(octet * & ptr,GIAC_CONTEXT)3850 static gen ti_decode_toolbar(octet * & ptr,GIAC_CONTEXT){ 3851 vecteur arg(ti_decode_list(ptr,ENDTBAR_ITAG,COMMAND_TAG,contextptr)); 3852 return symbolic(at_ti_not_implemented,arg); 3853 } 3854 ti_decode_local(octet * & ptr,GIAC_CONTEXT)3855 static gen ti_decode_local(octet * & ptr,GIAC_CONTEXT){ 3856 // decode list until ENDFUNC or ENDPRGM COMMAND_TAG 3857 vecteur res; 3858 for (;;){ 3859 ti_decode_newline(ptr,contextptr); 3860 if ( (*(ptr-1)==ENDPRGM_ITAG || *(ptr-1)==ENDFUNC_ITAG) && 3861 *ptr==COMMAND_TAG) 3862 break; 3863 res.push_back(ti_decode_tag(ptr,contextptr)); 3864 } 3865 // do not decrement ptr, keep the end tags for func_itag or prgm_itag 3866 // split res using first end_tag 3867 int i=equalposcomp(res,at_ti_endtag); 3868 if (!i) 3869 return gensizeerr(gettext("empty local declaration")); 3870 gen gloc=vecteur(res.begin(),res.begin()+i-1); 3871 gen gbloc=vecteur(res.begin()+i,res.end()); 3872 return symb_local(gloc,gbloc,contextptr); 3873 } 3874 3875 // command or instruction tag ti_command_tag(octet * & ptr,GIAC_CONTEXT)3876 static gen ti_command_tag(octet * & ptr,GIAC_CONTEXT){ 3877 switch (*ptr){ 3878 case CLRDRAW_ITAG: 3879 --ptr; 3880 return symbolic(at_ClrDraw,vecteur(0)); 3881 case CLRGRAPH_ITAG: 3882 --ptr; 3883 return symbolic(at_ClrGraph,vecteur(0)); 3884 case CLRIO_ITAG: 3885 --ptr; 3886 return symbolic(at_ClrIO,vecteur(0)); 3887 case CLRHOME_ITAG: // FIXME 3888 --ptr; 3889 return symbolic(at_ti_not_implemented,string2gen("ClrHome",false)); 3890 case CLRTABLE_ITAG: 3891 --ptr; 3892 return symbolic(at_ti_not_implemented,string2gen("ClrTable",false)); 3893 case DISPG_ITAG: 3894 --ptr; 3895 return symbolic(at_DispG,vecteur(0)); 3896 case DISPTBL_ITAG: 3897 --ptr; 3898 return symbolic(at_ti_not_implemented,string2gen("DispTbl",false)); 3899 case CYCLE_ITAG: 3900 --ptr; // maybe ptr -= 3 to skip offset 3901 return symbolic(at_continue,zero); 3902 case CUSTOM_ITAG: 3903 --ptr; 3904 return ti_decode_custom(ptr,contextptr); 3905 case DIALOG_ITAG: 3906 --ptr; 3907 return ti_decode_dialog(ptr,contextptr); 3908 case TOOLBAR_ITAG: 3909 --ptr; 3910 return ti_decode_toolbar(ptr,contextptr); 3911 case ELSE_ITAG: 3912 --ptr; 3913 return at_ti_else; 3914 case ENDCUSTM_ITAG: 3915 case ENDDLOG_ITAG: 3916 case ENDFOR_ITAG: 3917 case ENDFUNC_ITAG: 3918 case ENDIF_ITAG: 3919 case ENDLOOP_ITAG: 3920 case ENDPRGM_ITAG: 3921 case ENDTBAR_ITAG: 3922 case ENDTRY_ITAG: 3923 case ENDWHILE_ITAG: 3924 return gensizeerr(gettext("End structure ")+print_INT_(*ptr)+" "+print_INT_(*(ptr-2))+" "+print_INT_(*(ptr-1))); 3925 case EXIT_ITAG: 3926 ptr -=3 ; // skip offset 3927 return symbolic(at_break,zero); 3928 case FUNC_ITAG: 3929 --ptr; 3930 return ti_decode_func(ptr,ENDFUNC_ITAG,contextptr); 3931 case PRGM_ITAG: 3932 --ptr; 3933 return ti_decode_func(ptr,ENDPRGM_ITAG,contextptr); 3934 case LOOP_ITAG: 3935 --ptr; 3936 return ti_decode_loop(ptr,contextptr); 3937 case STOP_ITAG: 3938 --ptr; // maybe ptr -=3 to skip itag 3939 return at_ti_stop; 3940 case THEN_ITAG: 3941 --ptr; 3942 return at_ti_then; 3943 case TRY_ITAG: 3944 --ptr; 3945 return ti_decode_try(ptr,contextptr); 3946 case SHOWSTAT_ITAG: 3947 --ptr; 3948 return string2gen("showStat",false); 3949 case TRACE_ITAG: 3950 --ptr; 3951 return string2gen("Trace",false); 3952 case ZOOMBOX_ITAG: 3953 --ptr; 3954 return string2gen("ZoomBox",false); 3955 case ZOOMDATA_ITAG: 3956 --ptr; 3957 return string2gen("ZoomData",false); 3958 case ZOOMDEC_ITAG: 3959 --ptr; 3960 return string2gen("ZoomDec",false); 3961 case ZOOMFIT_ITAG: 3962 --ptr; 3963 return string2gen("ZoomFit",false); 3964 case ZOOMIN_ITAG: 3965 --ptr; 3966 return string2gen("ZoomIn",false); 3967 case ZOOMINT_ITAG: 3968 --ptr; 3969 return string2gen("ZoomInt",false); 3970 case ZOOMOUT_ITAG: 3971 --ptr; 3972 return string2gen("ZoomOut",false); 3973 case ZOOMPREV_ITAG: 3974 --ptr; 3975 return string2gen("ZoomPrev",false); 3976 case ZOOMRCL_ITAG: 3977 --ptr; 3978 return string2gen("ZoomRcl",false); 3979 case ZOOMSQR_ITAG: 3980 --ptr; 3981 return string2gen("ZoomSqr",false); 3982 case ZOOMSTD_ITAG: 3983 --ptr; 3984 return string2gen("ZoomStd",false); 3985 case ZOOMSTO_ITAG: 3986 --ptr; 3987 return string2gen("ZoomSto",false); 3988 case ZOOMTRIG_ITAG: // FIXME 3989 --ptr; 3990 return string2gen("ZoomTrig",false); 3991 case DRAWFUNC_ITAG: 3992 return ti_decode_unary(ptr,at_plotfunc,contextptr); 3993 case DRAWINV_ITAG: // FIXME 3994 return ti_decode_unary(ptr,at_DrawInv,contextptr); 3995 // return ti_decode_unary(ptr,at_ti_drawinv,contextptr); 3996 case GOTO_ITAG: 3997 return ti_decode_unary(ptr,at_goto,contextptr); 3998 case LBL_ITAG: 3999 return ti_decode_unary(ptr,at_label,contextptr); 4000 case GET_ITAG: 4001 return ti_decode_unary(ptr,at_Get,contextptr); 4002 case SEND_ITAG: 4003 return ti_decode_not_implemented(ptr,"Send",1,contextptr); 4004 case GETCALC_ITAG: 4005 return ti_decode_unary(ptr,at_GetCalc,contextptr); 4006 case SENDCALC_ITAG: 4007 return ti_decode_not_implemented(ptr,"SendCalc",1,contextptr); 4008 case NEWFOLD_ITAG: 4009 return ti_decode_unary(ptr,at_NewFold,contextptr); 4010 case PRINTOBJ_ITAG: //FIXME 4011 return ti_decode_not_implemented(ptr,"printObj",1,contextptr); 4012 case RCLGDB_ITAG: 4013 return ti_decode_not_implemented(ptr,"RclGDB",1,contextptr); 4014 case STOGDB_ITAG: 4015 return ti_decode_not_implemented(ptr,"StoGDB",1,contextptr); 4016 case ELSEIF_ITAG: 4017 --ptr; 4018 return at_ti_elseif; 4019 case IF_ITAG: 4020 --ptr; 4021 return ti_decode_if(ptr,contextptr); 4022 case IFTHEN_ITAG: 4023 --ptr; 4024 return ti_decode_ifthen(ptr,contextptr); 4025 case WHILE_ITAG: 4026 --ptr; 4027 return ti_decode_while(ptr,contextptr); 4028 case RANDSEED_ITAG: 4029 return ti_decode_unary(ptr,at_srand,contextptr); 4030 case COPYVAR_ITAG: 4031 return ti_decode_binary(ptr,at_CopyVar,true,contextptr); 4032 case RENAME_ITAG: 4033 return ti_decode_not_implemented(ptr,"Rename",2,contextptr); 4034 case STYLE_ITAG: 4035 return ti_decode_not_implemented(ptr,"Style",2,contextptr); 4036 case LINETAN_ITAG: 4037 return ti_decode_binary(ptr,at_LineTan,true,contextptr); 4038 case FILL_ITAG: 4039 return ti_decode_not_implemented(ptr,"Fill",2,contextptr); 4040 case REQUEST_ITAG: 4041 return ti_decode_binary(ptr,at_Request,true,contextptr); 4042 case POPUP_ITAG: 4043 return ti_decode_binary(ptr,at_PopUp,true,contextptr); 4044 case PTCHG_ITAG: 4045 return ti_decode_not_implemented(ptr,"PtChg",2,contextptr); 4046 case PTOFF_ITAG: 4047 return ti_decode_binary(ptr,at_PtOff,true,contextptr); 4048 case PTON_ITAG: 4049 return ti_decode_binary(ptr,at_PtOn,true,contextptr); 4050 case PXLCHG_ITAG: 4051 return ti_decode_not_implemented(ptr,"PxlChg",2,contextptr); 4052 case PXLOFF_ITAG: 4053 return ti_decode_binary(ptr,at_PxlOff,true,contextptr); 4054 case PXLON_ITAG: 4055 return ti_decode_binary(ptr,at_PxlOn,true,contextptr); 4056 case MOVEVAR_ITAG: 4057 return ti_decode_not_implemented(ptr,"MoveVar",-3,contextptr); 4058 case DROPDOWN_ITAG: 4059 return ti_decode_nary(ptr,at_DropDown,3,contextptr); 4060 case OUTPUT_ITAG: 4061 return ti_decode_nary(ptr,at_Output,3,contextptr); 4062 case PTTEXT_ITAG: 4063 return ti_decode_nary(ptr,at_PtText,3,contextptr); 4064 case PXLTEXT_ITAG: 4065 return ti_decode_not_implemented(ptr,"PxlText",-3,contextptr); 4066 case DRAWSLP_ITAG: 4067 return ti_decode_nary(ptr,at_DrawSlp,3,contextptr); 4068 case PAUSE_ITAG: 4069 return ti_decode_nary(ptr,at_Pause,0,contextptr); 4070 case RETURN_ITAG: 4071 return ti_decode_nary(ptr,at_return,0,contextptr); 4072 case INPUT_ITAG: 4073 return ti_decode_nary(ptr,at_Input,2,contextptr); 4074 case PLOTSOFF_ITAG: 4075 return ti_decode_not_implemented(ptr,"PlotsOff",-0,contextptr); 4076 case PLOTSON_ITAG: 4077 return ti_decode_not_implemented(ptr,"PlotsOn",-0,contextptr); 4078 case ONEVAR_ITAG: 4079 return ti_decode_not_implemented(ptr,"OneVar",-1,contextptr); 4080 case TITLE_ITAG: 4081 return ti_decode_nary(ptr,at_Title,1,contextptr); 4082 case ITEM_ITAG: 4083 return ti_decode_not_implemented(ptr,"Item",-1,contextptr); 4084 case INPUTSTR_ITAG: 4085 return ti_decode_nary(ptr,at_InputStr,3,contextptr); 4086 case LINEHORZ_ITAG: 4087 return ti_decode_nary(ptr,at_LineHorz,4,contextptr); 4088 case LINEVERT_ITAG: 4089 return ti_decode_nary(ptr,at_LineVert,4,contextptr); 4090 case PXLHORZ_ITAG: 4091 return ti_decode_not_implemented(ptr,"PxlHorz",-1,contextptr); 4092 case PXLVERT_ITAG: 4093 return ti_decode_not_implemented(ptr,"PxlVert",-1,contextptr); 4094 case ANDPIC_ITAG: 4095 return ti_decode_not_implemented(ptr,"AndPic",-1,contextptr); 4096 case XORPIC_ITAG: 4097 return ti_decode_not_implemented(ptr,"XorPic",-1,contextptr); 4098 case DRAWPOL_ITAG: 4099 return ti_decode_not_implemented(ptr,"DrawPol",-1,contextptr); 4100 case TABLE_ITAG: 4101 return ti_decode_not_implemented(ptr,"Table",-1,contextptr); 4102 case RCLPIC_ITAG: 4103 return ti_decode_nary(ptr,at_RclPic,1,contextptr); 4104 case RPLCPIC_ITAG: 4105 return ti_decode_nary(ptr,at_RplcPic,1,contextptr); 4106 case TEXT_ITAG: 4107 return ti_decode_nary(ptr,at_Text,1,contextptr); 4108 case STOPIC_ITAG: 4109 return ti_decode_nary(ptr,at_StoPic,1,contextptr); 4110 case GRAPH_ITAG: 4111 return ti_decode_nary(ptr,at_Graph,1,contextptr); 4112 case NEWPIC_ITAG: 4113 return ti_decode_nary(ptr,at_NewPic,1,contextptr); 4114 case DRAWPARM_ITAG: 4115 return ti_decode_nary(ptr,at_DrawParm,2,contextptr); 4116 case CYCLEPIC_ITAG: 4117 return ti_decode_nary(ptr,at_CyclePic,2,contextptr); 4118 case CUBICREG_ITAG: 4119 return ti_decode_not_implemented(ptr,"CubicReg",-2,contextptr); 4120 case EXPREG_ITAG: 4121 return ti_decode_not_implemented(ptr,"ExpReg",-2,contextptr); 4122 case LINREG_ITAG: 4123 return ti_decode_not_implemented(ptr,"LinReg",-2,contextptr); 4124 case LNREG_ITAG: 4125 return ti_decode_not_implemented(ptr,"LnReg",-2,contextptr); 4126 case MEDMED_ITAG: 4127 return ti_decode_not_implemented(ptr,"MedMed",-2,contextptr); 4128 case POWERREG_ITAG: 4129 return ti_decode_not_implemented(ptr,"PowerReg",-2,contextptr); 4130 case QUADREG_ITAG: 4131 return ti_decode_not_implemented(ptr,"QuadReg",-2,contextptr); 4132 case QUARTREG_ITAG: 4133 return ti_decode_not_implemented(ptr,"QuartReg",-2,contextptr); 4134 case SINREG_ITAG: 4135 return ti_decode_not_implemented(ptr,"SinReg",-2,contextptr); 4136 case LOGISTIC_ITAG: 4137 return ti_decode_not_implemented(ptr,"Logistic",-2,contextptr); 4138 case TWOVAR_ITAG: 4139 return ti_decode_not_implemented(ptr,"TwoVar",-2,contextptr); 4140 case SHADE_ITAG: 4141 return ti_decode_not_implemented(ptr,"Shade",-2,contextptr); 4142 case FOR_ITAG: 4143 --ptr; 4144 return ti_decode_for(ptr,contextptr); 4145 case CIRCLE_ITAG: 4146 return ti_decode_nary(ptr,at_Circle,2,contextptr); 4147 case LINE_ITAG: 4148 return ti_decode_nary(ptr,at_Line,2,contextptr); 4149 case DISP_ITAG: 4150 return ti_decode_nary(ptr,at_print,1,contextptr); 4151 case PXLCRCL_ITAG: 4152 return ti_decode_not_implemented(ptr,"PxlCrcl",-3,contextptr); 4153 case NEWPLOT_ITAG: 4154 return ti_decode_not_implemented(ptr,"NewPlot",-0,contextptr); 4155 case PXLLINE_ITAG: 4156 return ti_decode_not_implemented(ptr,"PxlLine",-4,contextptr); 4157 case FNOFF_ITAG: 4158 return ti_decode_not_implemented(ptr,"FnOff",-0,contextptr); 4159 case FNON_ITAG: 4160 return ti_decode_not_implemented(ptr,"FnOn",-0,contextptr); 4161 case LOCAL_ITAG: 4162 --ptr; 4163 return ti_decode_local(ptr,contextptr); 4164 case DELFOLD_ITAG: // FIXME might be nary or unary!!! 4165 return ti_decode_unary(ptr,at_DelFold,contextptr); 4166 case DELVAR_ITAG: 4167 return ti_decode_nary(ptr,at_DelVar,0,contextptr); 4168 case PROMPT_ITAG: 4169 return ti_decode_nary(ptr,at_Prompt,0,contextptr); 4170 case SORTA_ITAG: 4171 return ti_decode_nary(ptr,at_SortA,1,contextptr); 4172 case SORTD_ITAG: 4173 return ti_decode_nary(ptr,at_SortD,1,contextptr); 4174 case LOCK_ITAG: 4175 return ti_decode_not_implemented(ptr,"Lock",-1,contextptr); 4176 case UNLOCK_ITAG: // FIXME maybe unary op 4177 return ti_decode_not_implemented(ptr,"Unlock",-1,contextptr); 4178 case NEWDATA_ITAG: 4179 return ti_decode_not_implemented(ptr,"NewData",-2,contextptr); 4180 case DEFINE_ITAG: 4181 return _Define(ti_decode_binary(ptr,at_nop,true,contextptr)._SYMBptr->feuille,contextptr); 4182 case ELSE_TRY_ITAG: 4183 --ptr; 4184 return at_ti_else_try; 4185 case CLRERR_ITAG: 4186 --ptr; 4187 return string2gen("ClrErr",false); 4188 case PASSERR_ITAG: 4189 --ptr; 4190 return string2gen("PassErr",false); 4191 case DISPHOME_ITAG: 4192 --ptr; 4193 return symbolic(at_DispHome,vecteur(0)); 4194 case EXEC_ITAG: 4195 return ti_decode_nary(ptr,at_Exec,0,contextptr); 4196 case ARCHIVE_ITAG: 4197 return ti_decode_nary(ptr,at_Archive,1,contextptr); 4198 case UNARCHIV_ITAG: 4199 return ti_decode_nary(ptr,at_Unarchiv,1,contextptr); 4200 case LU_ITAG: 4201 return ti_decode_nary(ptr,at_LU,4,contextptr); 4202 case QR_ITAG: 4203 return ti_decode_nary(ptr,at_QR,4,contextptr); 4204 case BLDDATA_ITAG: 4205 return ti_decode_not_implemented(ptr,"BldData",-1,contextptr); 4206 case DRWCTOUR_ITAG: 4207 return ti_decode_unary(ptr,at_DrwCtour,contextptr); 4208 case NEWPROB_ITAG: 4209 --ptr; 4210 return string2gen("NewProb",false); 4211 case CUSTMON_ITAG: 4212 --ptr; 4213 return string2gen("CustmOn",false); 4214 case CUSTMOFF_ITAG: 4215 --ptr; 4216 return string2gen("CustmOff",false); 4217 case SENDCHAT_ITAG: 4218 return ti_decode_not_implemented(ptr,"SendChat",1,contextptr); 4219 default: 4220 return gensizeerr(gettext("Unknown instruction tag:")+print_INT_(*ptr)); 4221 } 4222 return 0; 4223 } 4224 4225 // convert a TI9x object to a gen 4226 // ptr points to the tag of the structure (at the end) 4227 // after the call ptr points to the address previous beginning of object ti_decode_tag(octet * & ptr,GIAC_CONTEXT)4228 gen ti_decode_tag(octet * & ptr,GIAC_CONTEXT){ 4229 // unsigned short l; 4230 gen res; 4231 switch (*ptr){ 4232 case COMPLEX_TAG: // FIXME 4233 res=cst_i*ti_decode_tag(ptr,contextptr); 4234 return ti_decode_tag(ptr,contextptr)+res; 4235 // return ti_decode_not_implemented(ptr,"ComplexTag",2,contextptr); 4236 case NONNEGATIVE_INTEGER_TAG: 4237 --ptr; 4238 return ti_decode_unsigned(ptr,contextptr); 4239 case NEGATIVE_INTEGER_TAG: 4240 --ptr; 4241 return -ti_decode_unsigned(ptr,contextptr); 4242 case POSITIVE_FRACTION_TAG: 4243 --ptr; 4244 return ti_decode_fraction(ptr,contextptr); 4245 case NEGATIVE_FRACTION_TAG: 4246 --ptr; 4247 return -ti_decode_fraction(ptr,contextptr); 4248 case FLOAT_TAG: 4249 --ptr; 4250 return ti_decode_double(ptr,contextptr); 4251 case STR_DATA_TAG: 4252 ptr-=2; 4253 return string2gen(ti_decode_string(ptr,contextptr),false); 4254 case LIST_TAG: 4255 --ptr; 4256 return ti_decode_list(ptr,END_TAG,contextptr); 4257 case MATRIX_TAG: 4258 --ptr; 4259 res=ti_decode_list(ptr,END_TAG,contextptr); 4260 res.subtype=_MATRIX__VECT; 4261 return res; 4262 case USER_DEF_TAG: 4263 --ptr; 4264 return ti_decode_function(ptr,contextptr); 4265 case DATA_VAR_TAG: 4266 return gensizeerr(gettext("Data_var_tag not implemented")); 4267 case GDB_VAR_TAG: 4268 return gensizeerr(gettext("Gdb_var_tag not implemented")); 4269 case PIC_VAR_TAG: 4270 return gensizeerr(gettext("Unable to find pic_var_tag length")); 4271 case TEXT_VAR_TAG: 4272 return gensizeerr(gettext("Unable to find text_var_tag length")); 4273 case COMMAND_TAG: // or INSTRUCTION_TAG 4274 --ptr; 4275 return ti_command_tag(ptr,contextptr); 4276 case EXT_TAG: // or SECONDARY_TAG 4277 --ptr; 4278 return ti_secondary_tag(ptr,contextptr); 4279 case END_TAG: 4280 --ptr; 4281 return at_ti_endtag; 4282 case END_OF_SEGMENT: 4283 return gensizeerr(gettext("End_tag/End_of_segment")); 4284 case ASM_PRGM_TAG: 4285 return gensizeerr(gettext("Asm programs not implemented")); 4286 case GEN_DATA_TEG: 4287 return gensizeerr(gettext("3rd party data")); 4288 case VAR_NAME_TAG: 4289 --ptr; 4290 return ti_decode_identificateur(ptr,contextptr); 4291 case VAR_A_TAG: 4292 --ptr; 4293 return a__IDNT_e; 4294 case VAR_B_TAG: 4295 --ptr; 4296 return b__IDNT_e; 4297 case VAR_C_TAG: 4298 --ptr; 4299 return c__IDNT_e; 4300 case VAR_D_TAG: 4301 --ptr; 4302 return d__IDNT_e; 4303 case VAR_E_TAG: 4304 --ptr; 4305 return symbolic(at_exp,1); 4306 case VAR_F_TAG: 4307 --ptr; 4308 return f__IDNT_e; 4309 case VAR_G_TAG: 4310 --ptr; 4311 return g__IDNT_e; 4312 case VAR_H_TAG: 4313 --ptr; 4314 return h__IDNT_e; 4315 case VAR_I_TAG: 4316 --ptr; 4317 return i__IDNT_e; 4318 case VAR_J_TAG: 4319 --ptr; 4320 return j__IDNT_e; 4321 case VAR_K_TAG: 4322 --ptr; 4323 return k__IDNT_e; 4324 case VAR_L_TAG: 4325 --ptr; 4326 return l__IDNT_e; 4327 case VAR_M_TAG: 4328 --ptr; 4329 return m__IDNT_e; 4330 case VAR_N_TAG: 4331 --ptr; 4332 return n__IDNT_e; 4333 case VAR_O_TAG: 4334 --ptr; 4335 return o__IDNT_e; 4336 case VAR_P_TAG: 4337 --ptr; 4338 return p__IDNT_e; 4339 case _VAR_Q_TAG: 4340 CERR << "_var_q_tag" << '\n'; 4341 case VAR_Q_TAG: 4342 --ptr; 4343 return q__IDNT_e; 4344 case VAR_R_TAG: 4345 --ptr; 4346 return r__IDNT_e; 4347 case VAR_S_TAG: 4348 --ptr; 4349 return s__IDNT_e; 4350 case VAR_T_TAG: 4351 --ptr; 4352 return t__IDNT_e; 4353 case VAR_U_TAG: 4354 --ptr; 4355 return u__IDNT_e; 4356 case VAR_V_TAG: 4357 --ptr; 4358 return v__IDNT_e; 4359 case VAR_W_TAG: 4360 --ptr; 4361 return w__IDNT_e; 4362 case VAR_X_TAG: 4363 --ptr; 4364 return x__IDNT_e; 4365 case VAR_Y_TAG: 4366 --ptr; 4367 return y__IDNT_e; 4368 case VAR_Z_TAG: 4369 --ptr; 4370 return z__IDNT_e; 4371 case EXT_SYSTEM_TAG: 4372 --ptr; 4373 return ti_decode_sysvar_tag(ptr,contextptr); 4374 case ARB_REAL_TAG: 4375 --ptr; 4376 return ti_decode_arb_real(ptr,true,contextptr); 4377 case ARB_INT_TAG: 4378 --ptr; 4379 return ti_decode_arb_real(ptr,false,contextptr); 4380 case PI_TAG: 4381 --ptr; 4382 return cst_pi; 4383 case EXP_TAG: 4384 --ptr; 4385 return symbolic(at_exp,1); 4386 case IM_TAG: 4387 --ptr; 4388 return cst_i; 4389 case NEGINFINITY_TAG: 4390 --ptr; 4391 return minus_inf; 4392 case INFINITY_TAG: 4393 --ptr; 4394 return plus_inf; 4395 case PN_INFINITY_TAG: 4396 --ptr; 4397 return unsigned_inf; 4398 case UNDEF_TAG: 4399 --ptr; 4400 return undef; 4401 case FALSE_TAG: 4402 --ptr; 4403 return zero; 4404 case TRUE_TAG: 4405 --ptr; 4406 return plus_one; 4407 case NOTHING_TAG: 4408 return ti_decode_unary(ptr,at_nop,contextptr); 4409 case ACOSH_TAG: 4410 return ti_decode_unary(ptr,at_acosh,contextptr); 4411 case ASINH_TAG: 4412 return ti_decode_unary(ptr,at_asinh,contextptr); 4413 case ATANH_TAG: 4414 return ti_decode_unary(ptr,at_atanh,contextptr); 4415 case COSH_TAG: 4416 return ti_decode_unary(ptr,at_acosh,contextptr); 4417 case SINH_TAG: 4418 return ti_decode_unary(ptr,at_asinh,contextptr); 4419 case TANH_TAG: 4420 return ti_decode_unary(ptr,at_atanh,contextptr); 4421 case ACOS_TAG: 4422 return ti_decode_unary(ptr,at_acos,contextptr); 4423 case ASIN_TAG: 4424 return ti_decode_unary(ptr,at_asin,contextptr); 4425 case ATAN_TAG: 4426 return ti_decode_unary(ptr,at_atan,contextptr); 4427 case RACOS_TAG: 4428 return ti_decode_unary(ptr,at_acos,contextptr); 4429 case RASIN_TAG: 4430 return ti_decode_unary(ptr,at_asin,contextptr); 4431 case RATAN_TAG: 4432 return ti_decode_unary(ptr,at_atan,contextptr); 4433 case COS_TAG: 4434 return ti_decode_unary(ptr,at_cos,contextptr); 4435 case SIN_TAG: 4436 return ti_decode_unary(ptr,at_sin,contextptr); 4437 case TAN_TAG: 4438 return ti_decode_unary(ptr,at_tan,contextptr); 4439 case 0x47: // FIXME!! where is 10^x? 4440 return ti_decode_unary(ptr,at_nop,contextptr); 4441 case ITAN_TAG: 4442 return ti_decode_unary(ptr,at_tan,contextptr); 4443 case ABS_TAG: 4444 return ti_decode_unary(ptr,at_abs,contextptr); 4445 case ANGLE_TAG: 4446 return ti_decode_unary(ptr,at_arg,contextptr); 4447 case CEILING_TAG: 4448 return ti_decode_unary(ptr,at_ceil,contextptr); 4449 case FLOOR_TAG: 4450 return ti_decode_unary(ptr,at_floor,contextptr); 4451 case INT_TAG: 4452 return ti_decode_unary(ptr,at_floor,contextptr); 4453 case SIGN_TAG: 4454 return ti_decode_unary(ptr,at_sign,contextptr); 4455 case SQRT_TAG: 4456 return ti_decode_unary(ptr,at_sqrt,contextptr); 4457 case EXPF_TAG: 4458 return ti_decode_unary(ptr,at_exp,contextptr); 4459 case LN_TAG: 4460 return ti_decode_unary(ptr,at_ln,contextptr); 4461 case LOG_TAG: 4462 return ti_decode_unary(ptr,at_log10,contextptr); 4463 case FPART_TAG: 4464 return ti_decode_unary(ptr,at_fPart,contextptr); 4465 case IPART_TAG: 4466 return ti_decode_unary(ptr,at_iPart,contextptr); 4467 case CONJ_TAG: 4468 return ti_decode_unary(ptr,at_conj,contextptr); 4469 case IMAG_TAG: 4470 return ti_decode_unary(ptr,at_im,contextptr); 4471 case REAL_TAG: 4472 return ti_decode_unary(ptr,at_re,contextptr); 4473 case APPROX_TAG: 4474 return ti_decode_unary(ptr,at_evalf,contextptr); 4475 case TEXPAND_TAG: 4476 return ti_decode_unary(ptr,at_texpand,contextptr); 4477 case TCOLLECT_TAG: 4478 return ti_decode_unary(ptr,at_tcollect,contextptr); 4479 case GETDENOM_TAG: 4480 return ti_decode_unary(ptr,at_getDenom,contextptr); 4481 case GETNUM_TAG: 4482 return ti_decode_unary(ptr,at_getNum,contextptr); 4483 case CUMSUM_TAG: 4484 return ti_decode_unary(ptr,at_cumSum,contextptr); 4485 case DET_TAG: 4486 return ti_decode_unary(ptr,at_det,contextptr); 4487 case COLNORM_TAG: 4488 return ti_decode_unary(ptr,at_colNorm,contextptr); 4489 case ROWNORM_TAG: 4490 return ti_decode_unary(ptr,at_rowNorm,contextptr); 4491 case NORM_TAG: 4492 return ti_decode_unary(ptr,at_l2norm,contextptr); 4493 case MEAN_TAG: 4494 return ti_decode_unary(ptr,at_mean,contextptr); 4495 case MEDIAN_TAG: 4496 return ti_decode_unary(ptr,at_median,contextptr); 4497 case PRODUCT_TAG: 4498 return ti_decode_unary(ptr,at_product,contextptr); 4499 case STDDEV_TAG: 4500 return ti_decode_unary(ptr,at_stddev,contextptr); 4501 case SUM_TAG: 4502 return ti_decode_unary(ptr,at_sum,contextptr); 4503 case VARIANCE_TAG: 4504 return ti_decode_unary(ptr,at_variance,contextptr); 4505 case UNITV_TAG: 4506 return ti_decode_unary(ptr,at_unitV,contextptr); 4507 case DIM_TAG: 4508 return ti_decode_unary(ptr,at_dim,contextptr); 4509 case MAT2LIST_TAG: 4510 return ti_decode_unary(ptr,at_mat2list,contextptr); 4511 case NEWLIST_TAG: 4512 return ti_decode_unary(ptr,at_newList,contextptr); 4513 case RREF_TAG: 4514 return ti_decode_unary(ptr,at_rref,contextptr); 4515 case REF_TAG: 4516 return ti_decode_unary(ptr,at_ref,contextptr); 4517 case IDENTITY_TAG: 4518 return ti_decode_unary(ptr,at_identity,contextptr); 4519 case DIAG_TAG: 4520 return ti_decode_unary(ptr,at_diag,contextptr); 4521 case COLDIM_TAG: 4522 return ti_decode_unary(ptr,at_colDim,contextptr); 4523 case ROWDIM_TAG: 4524 return ti_decode_unary(ptr,at_rowDim,contextptr); 4525 case TRANSPOSE_TAG: 4526 return ti_decode_unary(ptr,at_transpose,contextptr); 4527 case FACTORIAL_TAG: 4528 return ti_decode_unary(ptr,at_factorial,contextptr); 4529 case PERCENT_TAG: 4530 return ti_decode_not_implemented(ptr,"percent",1,contextptr); 4531 case RADIANS_TAG: 4532 return ti_decode_not_implemented(ptr,"radians",1,contextptr); 4533 case NOT_TAG: 4534 return ti_decode_unary(ptr,at_not,contextptr); 4535 case MINUS_TAG: 4536 return ti_decode_unary(ptr,at_neg,contextptr); 4537 case VEC_POLAR_TAG: 4538 return ti_decode_not_implemented(ptr,">Polar",1,contextptr); 4539 case VEC_CYLIND_TAG: 4540 return ti_decode_not_implemented(ptr,">Cylind",1,contextptr); 4541 case VEC_SPHERE_TAG: 4542 return ti_decode_not_implemented(ptr,">Sphere",1,contextptr); 4543 case START_TAG: // internal tag 4544 return gensizeerr(gettext("start tag")); 4545 case ISTORE_TAG: 4546 return ti_decode_binary(ptr,at_sto,false,contextptr); 4547 case STORE_TAG: 4548 return ti_decode_binary(ptr,at_sto,false,contextptr); 4549 case WITH_TAG: 4550 return ti_decode_binary(ptr,at_tilocal,true,contextptr); 4551 case XOR_TAG: 4552 return ti_decode_binary(ptr,at_xor,true,contextptr); 4553 case OR_TAG: 4554 return ti_decode_binary(ptr,at_ou,true,contextptr); 4555 case AND_TAG: 4556 return ti_decode_binary(ptr,at_and,true,contextptr); 4557 case LT_TAG: 4558 return ti_decode_binary(ptr,at_inferieur_strict,true,contextptr); 4559 case LE_TAG: 4560 return ti_decode_binary(ptr,at_inferieur_egal,true,contextptr); 4561 case EQ_TAG: 4562 return ti_decode_binary(ptr,at_equal,true,contextptr); 4563 case GE_TAG: 4564 return ti_decode_binary(ptr,at_superieur_strict,true,contextptr); 4565 case GT_TAG: 4566 return ti_decode_binary(ptr,at_superieur_egal,true,contextptr); 4567 case NE_TAG: 4568 return ti_decode_binary(ptr,at_different,true,contextptr); 4569 case ADD_TAG: 4570 return ti_decode_binary(ptr,at_plus,false,contextptr); 4571 case ADDELT_TAG: 4572 return ti_decode_binary(ptr,at_plus,false,contextptr); 4573 case SUB_TAG: 4574 res=ti_decode_binary(ptr,at_minus,false,contextptr); 4575 res=*res._SYMBptr->feuille._VECTptr; 4576 res._VECTptr->back()=-res._VECTptr->back(); 4577 return symbolic(at_plus,res); 4578 case SUBELT_TAG: 4579 return ti_decode_binary(ptr,at_minus,false,contextptr); 4580 case MUL_TAG: 4581 return ti_decode_binary(ptr,at_prod,false,contextptr); 4582 case MULELT_TAG: 4583 return ti_decode_binary(ptr,at_pointprod,false,contextptr); 4584 case DIV_TAG: 4585 return ti_decode_binary(ptr,at_division,false,contextptr); 4586 case DIVELT_TAG: 4587 return ti_decode_binary(ptr,at_pointdivision,false,contextptr); 4588 case POW_TAG: 4589 return ti_decode_binary(ptr,at_pow,true,contextptr); 4590 case POWELT_TAG: 4591 return ti_decode_binary(ptr,at_pointpow,true,contextptr); 4592 case SINCOS_TAG: 4593 return gensizeerr(gettext("Internal sincos token")); 4594 case SOLVE_TAG: 4595 return ti_decode_binary(ptr,at_solve,true,contextptr); 4596 case CSOLVE_TAG: 4597 return ti_decode_binary(ptr,at_cSolve,true,contextptr); 4598 case NSOLVE_TAG: 4599 return ti_decode_binary(ptr,at_nSolve,true,contextptr); 4600 case ZEROS_TAG: 4601 return ti_decode_binary(ptr,at_zeros,true,contextptr); 4602 case CZEROS_TAG: 4603 return ti_decode_binary(ptr,at_cZeros,true,contextptr); 4604 case FMIN_TAG: 4605 return ti_decode_binary(ptr,at_fMin,true,contextptr); 4606 case FMAX_TAG: 4607 return ti_decode_binary(ptr,at_fMax,true,contextptr); 4608 case POLYEVAL_TAG: 4609 return ti_decode_binary(ptr,at_polyEval,true,contextptr); 4610 case RANDPOLY_TAG: 4611 return ti_decode_binary(ptr,at_randPoly,true,contextptr); 4612 case CROSSP_TAG: 4613 return ti_decode_binary(ptr,at_crossP,true,contextptr); 4614 case DOTP_TAG: 4615 return ti_decode_binary(ptr,at_dotP,true,contextptr); 4616 case GCD_TAG: 4617 return ti_decode_binary(ptr,at_gcd,true,contextptr); 4618 case LCM_TAG: 4619 return ti_decode_binary(ptr,at_lcm,true,contextptr); 4620 case MOD_TAG: 4621 return ti_decode_binary(ptr,at_irem,true,contextptr); 4622 case INTDIV_TAG: 4623 return ti_decode_binary(ptr,at_intDiv,true,contextptr); 4624 case REMAIN_TAG: 4625 return ti_decode_binary(ptr,at_remain,true,contextptr); 4626 case NCR_TAG: 4627 return ti_decode_binary(ptr,at_nCr,true,contextptr); 4628 case NPR_TAG: 4629 return ti_decode_binary(ptr,at_nPr,true,contextptr); 4630 case P2RX_TAG: 4631 return ti_decode_not_implemented(ptr,"P->Rx",2,contextptr); 4632 case P2RY_TAG: 4633 return ti_decode_not_implemented(ptr,"P->Ry",2,contextptr); 4634 case P2PTHETA_TAG: 4635 return ti_decode_not_implemented(ptr,"R->Pq",2,contextptr); 4636 case P2PR_TAG: 4637 return ti_decode_not_implemented(ptr,"R->Pr",2,contextptr); 4638 case AUGMENT_TAG: 4639 return ti_decode_binary(ptr,at_augment,true,contextptr); 4640 case NEWMAT_TAG: 4641 return ti_decode_binary(ptr,at_newMat,true,contextptr); 4642 case RANDMAT_TAG: 4643 return ti_decode_binary(ptr,at_randMat,true,contextptr); 4644 case SIMULT_TAG: 4645 return ti_decode_binary(ptr,at_simult,true,contextptr); 4646 case PART_TAG: 4647 return ti_decode_nary(ptr,at_part,1,contextptr); 4648 case EXP2LIST_TAG: 4649 return ti_decode_binary(ptr,at_exp2list,true,contextptr); 4650 case RANDNORM_TAG: 4651 return ti_decode_binary(ptr,at_randNorm,true,contextptr); 4652 case MROW_TAG: 4653 return ti_decode_nary(ptr,at_mRow,3,contextptr); 4654 case ROWADD_TAG: 4655 return ti_decode_nary(ptr,at_rowAdd,4,contextptr); 4656 case ROWSWAP_TAG: 4657 return ti_decode_nary(ptr,at_rowSwap,3,contextptr); 4658 case ARCLEN_TAG: 4659 return ti_decode_nary(ptr,at_arcLen,4,contextptr); 4660 case NINT_TAG: 4661 return ti_decode_nary(ptr,at_nInt,4,contextptr); 4662 case PI_PRODUCT_TAG: 4663 return ti_decode_nary(ptr,at_product,1,contextptr); 4664 case SIGMA_SUM_TAG: 4665 return ti_decode_nary(ptr,at_sum,4,contextptr); 4666 case MROWADD_TAG: 4667 return ti_decode_nary(ptr,at_mRowAdd,4,contextptr); 4668 case ANS_TAG: 4669 return ti_decode_nary(ptr,at_ans,0,contextptr); 4670 case ENTRY_TAG: 4671 return ti_decode_nary(ptr,at_entry,0,contextptr); 4672 case EXACT_TAG: 4673 return ti_decode_nary(ptr,at_exact,1,contextptr); 4674 case LOGB_TAG: 4675 return ti_decode_binary(ptr,at_logb,true,contextptr); 4676 case COMDENOM_TAG: 4677 return ti_decode_nary(ptr,at_comDenom,1,contextptr); 4678 case EXPAND_TAG: 4679 return ti_decode_nary(ptr,at_expand,1,contextptr); 4680 case FACTOR_TAG: 4681 return ti_decode_nary(ptr,at_factor,1,contextptr); 4682 case CFACTOR_TAG: 4683 return ti_decode_nary(ptr,at_cFactor,1,contextptr); 4684 case INTEGRATE_TAG: 4685 return ti_decode_nary(ptr,at_integrate,2,contextptr); 4686 case DIFFERENTIATE_TAG: 4687 return ti_decode_nary(ptr,at_derive,2,contextptr); 4688 case AVGRC_TAG: 4689 return ti_decode_nary(ptr,at_avgRC,2,contextptr); 4690 case NDERIV_TAG: 4691 return ti_decode_nary(ptr,at_nDeriv,2,contextptr); 4692 case TAYLOR_TAG: 4693 return ti_decode_nary(ptr,at_taylor,3,contextptr); 4694 case LIMIT_TAG: 4695 return ti_decode_nary(ptr,at_limit,3,contextptr); 4696 case PROPFRAC_TAG: 4697 return ti_decode_nary(ptr,at_propFrac,1,contextptr); 4698 case WHEN_TAG: 4699 return ti_decode_nary(ptr,at_when,3,contextptr); 4700 case ROUND_TAG: 4701 return ti_decode_nary(ptr,at_round,1,contextptr); 4702 case DMS_TAG: // FIXME not clear 4703 return ti_decode_not_implemented(ptr,"DMS",1,contextptr); 4704 // return ti_decode_not_implemented(ptr,"DMS",-1,contextptr); 4705 case LEFT_TAG: 4706 return ti_decode_nary(ptr,at_left,1,contextptr); 4707 case RIGHT_TAG: 4708 return ti_decode_nary(ptr,at_right,1,contextptr); 4709 case MID_TAG: 4710 return ti_decode_nary(ptr,at_mid,2,contextptr); 4711 case SHIFT_TAG: 4712 return ti_decode_nary(ptr,at_shift,1,contextptr); 4713 case SEQ_TAG: 4714 return ti_decode_nary(ptr,at_seq,4,contextptr); 4715 case LIST2MAT_TAG: 4716 return ti_decode_nary(ptr,at_list2mat,1,contextptr); 4717 case SUBMAT_TAG: 4718 return ti_decode_nary(ptr,at_subMat,1,contextptr); 4719 case SUBSCRIPT_TAG: 4720 res=ti_decode_nary(ptr,at_at,2,contextptr); 4721 if (res.type!=_SYMB || res._SYMBptr->feuille.type!=_VECT) 4722 return gensizeerr(contextptr); 4723 res=res._SYMBptr->feuille; 4724 if (res._VECTptr->size()==2) 4725 return symbolic(at_at,makesequence(res._VECTptr->front(),(res._VECTptr->back()-plus_one))); 4726 else 4727 return symbolic(at_at,makesequence(res._VECTptr->front(),gen(vecteur(res._VECTptr->begin()+1,res._VECTptr->end()),_SEQ__VECT)-gen(vecteur(res._VECTptr->size()-1,plus_one),_SEQ__VECT))); 4728 case RAND_TAG: 4729 return ti_decode_nary(ptr,at_rand,0,contextptr); 4730 case MIN_TAG: 4731 return ti_decode_nary(ptr,at_min,1,contextptr); 4732 case MAX_TAG: 4733 return ti_decode_nary(ptr,at_max,1,contextptr); 4734 case USERFUNC_TAG: 4735 res=ti_decode_nary(ptr,at_of,0,contextptr); 4736 if (res.type!=_SYMB || res._SYMBptr->feuille.type!=_VECT) 4737 return gensizeerr(contextptr); 4738 res=res._SYMBptr->feuille; 4739 return symbolic(at_of,makesequence(res._VECTptr->front(),gen(vecteur(res._VECTptr->begin()+1,res._VECTptr->end()),_SEQ__VECT))); 4740 case FIG_TAG: 4741 return gensizeerr(gettext("fig_tag")); 4742 case MAC_TAG: 4743 return gensizeerr(gettext("mac_tag")); 4744 case COMMENT_TAG: 4745 ptr -=2; 4746 while (!*ptr) --ptr; 4747 return string2gen(ti_decode_string(ptr,contextptr),false); 4748 case NEXTEXPR_TAG: case NEWLINE_TAG: // ":" or "\n" inside a prog 4749 ti_decode_newline(ptr,contextptr); 4750 return at_nop; 4751 case PN1_TAG: 4752 return ti_decode_unary(ptr,at_neg,contextptr); 4753 case PN2_TAG: 4754 CERR << "pn2_tag" << '\n'; 4755 return ti_decode_binary(ptr,at_neg,true,contextptr); 4756 case ERROR_MSG_TAG: 4757 return ti_decode_not_implemented(ptr,"ErrorMsg",1,contextptr); 4758 case EIGVC_TAG: 4759 return ti_decode_unary(ptr,at_eigVc,contextptr); 4760 case EIGVL_TAG: 4761 return ti_decode_unary(ptr,at_eigVl,contextptr); 4762 case DASH_TAG: 4763 return ti_decode_unary(ptr,at_derive,contextptr); 4764 case LOCALVAR_TAG: 4765 --ptr; 4766 return ti_decode_tag(ptr,contextptr); 4767 case DESOLVE_TAG: 4768 return ti_decode_nary(ptr,at_deSolve,3,contextptr); 4769 case FDASH_TAG: 4770 return ti_decode_binary(ptr,at_derive,true,contextptr); 4771 case ISPRIME_TAG: 4772 return ti_decode_unary(ptr,at_isprime,contextptr); 4773 case ROTATE_TAG: 4774 return ti_decode_nary(ptr,at_rotate,1,contextptr); 4775 default: 4776 return gensizeerr(gettext("Unknown tag ")+print_INT_(*ptr)); 4777 } 4778 --ptr; 4779 return res; 4780 } 4781 4782 // convert a TI9x object to a gen 4783 // ptr points to the beginning of the structure ti2gen(octet * ptr,GIAC_CONTEXT)4784 gen ti2gen(octet * ptr,GIAC_CONTEXT){ 4785 /* 4786 if (numeric_limits<unsigned char>::Digits!=8){ 4787 return gensizeerr(gettext("Must recompile with a typedef for octet as 8-bit data")); 4788 } 4789 */ 4790 int offset= ptr[0]*256+ptr[1]; 4791 octet * tag = ptr + (offset +1); 4792 // Check here for text, non tokenized progs, 3rd party data 4793 // since length must be known 4794 if (*tag==TEXT_VAR_TAG){ 4795 char * ptrs=(char *)ptr+4; 4796 return string2gen(tiasc_translate(ptrs),false); 4797 } 4798 if (*tag==USER_DEF_TAG && (*(tag-1) & 0x08)){ 4799 ptr +=2; // point to argument list 4800 string s(":tmpfunc"); 4801 char c; 4802 tag -= 8; 4803 for (;ptr!=tag;++ptr){ 4804 c=*ptr; 4805 if (*ptr>0x7F){ 4806 if (-c==87){ // must skip until end of line 4807 for (;ptr!=tag;++ptr){ 4808 if (*ptr=='\r') 4809 break; 4810 } 4811 } 4812 else 4813 s += "Z"+print_INT_(-c); 4814 } 4815 else { 4816 switch(c){ 4817 case 0: 4818 continue; 4819 case '\r': 4820 s = (s+'\n')+':'; 4821 break; 4822 case '\026': 4823 s += "=>"; 4824 break; 4825 default: 4826 s += c; 4827 } 4828 } 4829 } 4830 s=tiasc_translate(s); 4831 CERR << s << '\n'; 4832 int save_maple_mode=xcas_mode(contextptr); 4833 xcas_mode(contextptr)=3; 4834 gen res(s,contextptr); 4835 xcas_mode(contextptr)=save_maple_mode; 4836 return res; 4837 } 4838 return ti_decode_tag(tag,contextptr); 4839 } 4840 decode_name(octet * buf,GIAC_CONTEXT)4841 static gen decode_name(octet * buf,GIAC_CONTEXT){ 4842 string lu; 4843 char c; 4844 for (int i=0;i<8 && (c=buf[i]);++i) 4845 lu += c; 4846 gen gname(lu,contextptr); 4847 if (gname.type!=_IDNT) 4848 gname=gen("_"+lu,contextptr); 4849 return gname; 4850 } 4851 4852 // FIXME SECURITY 4853 // Format [length 2 bytes] 0xE9 prgm 0x19 or 0x13 0xE5 ... 0x0 0x0 0x0 0xDC 4854 // length is at offset 0x56 in a program file, name at 0x40 _unarchive_ti(const gen & g,GIAC_CONTEXT)4855 gen _unarchive_ti(const gen & g,GIAC_CONTEXT){ 4856 if ( g.type==_STRNG && g.subtype==-1) return g; 4857 if (g.type!=_STRNG) 4858 return gensizeerr(contextptr); 4859 #if defined NSPIRE || defined FXCG || defined GIAC_HAS_STO_38 4860 return gensizeerr(contextptr); 4861 #else 4862 if (access(g._STRNGptr->c_str(),R_OK)) 4863 return gensizeerr(gettext("Unable to open ")+g.print(contextptr)); 4864 ifstream is(g._STRNGptr->c_str()); 4865 string lu; 4866 char c; 4867 for (;!is.eof();){ 4868 is.get(c); 4869 lu += c; 4870 } 4871 unsigned int s=unsigned(lu.size()); 4872 if (s<0x60) 4873 return gensizeerr(gettext("Too short for a TI archive")); 4874 #ifdef VISUALC 4875 octet *buf=new octet[s]; // FIXME VISUALC delete 4876 #else 4877 octet buf[s]; 4878 #endif 4879 memcpy(buf,lu.c_str(),s); 4880 if (lu[6]=='P'){ // package/group file 4881 unsigned int t=buf[0x3e]*65536+buf[0x3d]*256+buf[0x3c]; 4882 if (s<t) 4883 return gensizeerr(gettext("Not long enough")); 4884 unsigned int nprogs=(t-0x52)/0x10; 4885 if (!nprogs){ 4886 gen res(undef); 4887 // single program 4888 gen gname(decode_name(&buf[0x40],contextptr)); 4889 CERR << "Fonction " << gname << '\n'; 4890 parser_filename(gname.print(contextptr),contextptr); 4891 unsigned int tt=buf[0x3e]*65536+buf[0x3d]*256+buf[0x3c]+4; 4892 if (tt>s) 4893 return res; 4894 unsigned int ttt=buf[tt]*256+buf[tt+1]; 4895 if (s<ttt+tt+2) 4896 return res; 4897 gen gval; 4898 #ifdef NO_STDEXCEPT 4899 gval=ti2gen(&buf[tt],contextptr); 4900 #else 4901 try { 4902 gval=ti2gen(&buf[tt],contextptr); 4903 } 4904 catch (std::runtime_error & e){ 4905 last_evaled_argptr(contextptr)=NULL; 4906 CERR << gname << ":" << e.what(); 4907 gval=string2gen(e.what(),false); 4908 } 4909 #endif 4910 if (gval.is_symb_of_sommet(at_sto)) 4911 res=symb_sto(gval._SYMBptr->feuille[0],gname); 4912 else 4913 res=symb_sto(gval,gname); 4914 return res; 4915 } 4916 // Group file format 4917 // First name is folder at 0x40 offset 0x4c (dir name) 4918 // List of names 0x50, 0x60, ... offsets 0x5c 0x6c etc. 4919 // offset + 4 = begin of func/prog, ex. offset=0x1322, length at 0x1326 4920 gen gfoldername(decode_name(&buf[0x40],contextptr)); 4921 vecteur res; 4922 if (gfoldername.print(contextptr)!="main"){ 4923 CERR << "Degrouping in folder " << gfoldername << '\n'; 4924 res.push_back(symbolic(at_NewFold,gfoldername)); 4925 res.push_back(symbolic(at_SetFold,gfoldername)); 4926 } 4927 // decode each prog 4928 for (unsigned int i=0;i<nprogs;++i){ 4929 gen gname(decode_name(&buf[0x50+0x10*i],contextptr)); 4930 CERR << "Fonction " << gname << '\n'; 4931 parser_filename(gname.print(contextptr),contextptr); 4932 unsigned int tt=buf[0x4e +0x10*i]*65536+buf[0x4d+0x10*i]*256+buf[0x4c+0x10*i]+4; 4933 if (tt>s) 4934 return res; 4935 unsigned int ttt=buf[tt]*256+buf[tt+1]; 4936 if (s<ttt+tt+2) 4937 return res; 4938 gen gval; 4939 #ifdef NO_STDEXCEPT 4940 gval=ti2gen(&buf[tt],contextptr); 4941 #else 4942 try { 4943 gval=ti2gen(&buf[tt],contextptr); 4944 } 4945 catch (std::runtime_error & e){ 4946 last_evaled_argptr(contextptr)=NULL; 4947 CERR << gname << ":" << e.what(); 4948 gval=string2gen(e.what(),false); 4949 } 4950 #endif 4951 if (gval.is_symb_of_sommet(at_sto)) 4952 res.push_back(symb_sto(gval._SYMBptr->feuille[0],gname)); 4953 res.push_back(symb_sto(gval,gname)); 4954 } 4955 return res; 4956 } 4957 unsigned int t=buf[0x56]*256+buf[0x57]; 4958 if (s<t+0x56+2) 4959 return gensizeerr(gettext("Not a TI89/92 program/function/group file")); 4960 gen gname(decode_name(&buf[0x40],contextptr)); 4961 gen gval(ti2gen(&buf[0x56],contextptr)); 4962 if (gval.is_symb_of_sommet(at_sto)) 4963 return symb_sto(gval._SYMBptr->feuille[0],gname); 4964 return symb_sto(gval,gname); 4965 #endif 4966 } 4967 #endif //RTOS_THREADX 4968 static const char _unarchive_ti_s[]="unarchive_ti"; 4969 static define_unary_function_eval (__unarchive_ti,&_unarchive_ti,_unarchive_ti_s); 4970 define_unary_function_ptr5( at_unarchive_ti ,alias_at_unarchive_ti,&__unarchive_ti,0,true); 4971 4972 #ifdef GIAC_HAS_STO_38 4973 static const char _fsi_s[]="fsi"; 4974 static define_unary_function_eval_quoted (__fsi,&_ifte,_fsi_s); 4975 define_unary_function_ptr5( at_fsi ,alias_at_fsi,&__fsi,_QUOTE_ARGUMENTS,T_BLOC_END); 4976 4977 static const char _ffaire_s[]="ffaire"; 4978 static define_unary_function_eval_quoted (__ffaire,&_for,_ffaire_s); 4979 define_unary_function_ptr5( at_ffaire ,alias_at_ffaire,&__ffaire,_QUOTE_ARGUMENTS,T_BLOC_END); 4980 4981 static const char _fpour_s[]="fpour"; 4982 static define_unary_function_eval_quoted (__fpour,&_for,_fpour_s); 4983 define_unary_function_ptr5( at_fpour ,alias_at_fpour,&__fpour,_QUOTE_ARGUMENTS,T_BLOC_END); 4984 4985 static const char _ftantque_s[]="ftantque"; 4986 static define_unary_function_eval_quoted (__ftantque,&_for,_ftantque_s); 4987 define_unary_function_ptr5( at_ftantque ,alias_at_ftantque,&__ftantque,_QUOTE_ARGUMENTS,T_BLOC_END); 4988 4989 static const char _ffonction_s[]="ffonction"; 4990 static define_unary_function_eval_quoted (__ffonction,&_for,_ffonction_s); 4991 define_unary_function_ptr5( at_ffonction ,alias_at_ffonction,&__ffonction,_QUOTE_ARGUMENTS,T_BLOC_END); 4992 #endif 4993 4994 #ifndef NO_NAMESPACE_GIAC 4995 } // namespace giac 4996 #endif // ndef NO_NAMESPACE_GIAC 4997