low level addition, based on HAC pp.594, Algorithm 14.7 */

** About the overflow check: an overflow cannot occur when time ** is represented by a lua_Integer, because either lua_Integer is ** large enough to r

works for continuous functions only

format is currently ignored, keep only 6 digits (round)

a=arguments, b=values, c=program bloc, d=program name

Helper: explicit aliases for vpam factories to avoid name clash with the same-named cas factories in PersistentAST.h

!! Do not call with modpoly slices if new_coord and th/other overlapp

symbolic symb_normal(const gen & args){ return symbolic(at_normal,args); }

greduce(P,[gbasis],[vars])

** Add constant 'v' to prototype's list of constants (field 'k'). ** Use scanner's table to cache position of constants in constant list ** and try to

add a dimension in front of pcur for algebraic extension variable

grad (next few commands

FIXME -> prog.h find extremals values of g should be improved (currently return -1..1 for sin and cos

** Free register 'reg', if it is neither a constant index nor ** a local variable. ) */

True if |a - b| < kEps.

Convenience: is this a SumNode?

vector<unary_function_ptr> inequality_sommets(inequality_tab,inequality_tab+sizeof(inequality_tab)/sizeof(unary_function_ptr));

try to rewrite fu(x), function of x as a fonction of u(x), if possible return fx(x) such that fu(x)=fx(u(x)) FIXME: should detect u=pow(.,inv(n)) with

** Similar to 'luaD_call', but does not allow yields during the call. */

** Finishes a function call: calls hook if necessary, moves current ** number of results to proper place, and returns to previous call ** info. If fun

** set GCdebt to a new value keeping the value (totalbytes + GCdebt) ** invariant (and avoiding underflows in 'totalbytes') */

** Close all upvalues and to-be-closed variables up to the given stack ** level. Return restored 'level'. */

** returns current 'pc' and marks it as a jump target (to avoid wrong ** optimizations with consecutive instructions not in the same basic block). */

** set functions from list 'l' into table at top - 'nup'; each ** function gets the 'nup' elements at the top as upvalues. ** Returns with only the ta

** Finish a table assignment 't[key] = val'. ** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points ** to the entry 't[key]', or to a val

computes a = 2**b * * Simple algorithm which zeroes the int, grows it then just sets one bit * as required. */

Counts the number of lsbs which are zero before the first zero bit */

calculate c = a**b using a square-multiply algorithm */

WARNING