Documentation Index Fetch the complete documentation index at: https://mintlify.com/geogebra/giac/llms.txt
Use this file to discover all available pages before exploring further.
Overview Giac provides multiple evaluation functions for different computation modes. The evaluation system handles symbolic expressions, numerical approximations, and various levels of simplification.
Defined in: src/giac/headers/gen.h
Core Evaluation Functions eval() - Symbolic Evaluation gen eval ( const gen & e , int level , const context * contextptr ); gen gen :: eval ( int level , const context * contextptr ) const ;
Performs symbolic evaluation of an expression.
Evaluation depth (typically DEFAULT_EVAL_LEVEL = 25)
Evaluation context (can be NULL for default)
Basic Example
With Variables
context ctx; gen x = gen ( "x" , & ctx); gen expr = x * x + 2 * x + 1 ; // Symbolic evaluation gen result = expr . eval (DEFAULT_EVAL_LEVEL, & ctx); // result: x^2 + 2*x + 1 (symbolic form)
evalf() - Floating-Point Evaluation gen evalf ( const gen & e , int level , const context * contextptr ); gen gen :: evalf ( int level , const context * contextptr ) const ;
Evaluates expression to floating-point approximation.
Evaluation level (controls precision and recursion)
Approximate numerical result
context ctx; gen pi = gen ( "pi" , & ctx); gen approx = pi . evalf ( 1 , & ctx); // approx: 3.14159265359... gen sqrt2 = gen ( "sqrt(2)" , & ctx); gen val = sqrt2 . evalf ( 1 , & ctx); // val: 1.41421356237...
evalf_double() - Force Double Precision gen evalf_double ( const gen & e , int level , const context * contextptr ); gen gen :: evalf_double ( int level , const context * contextptr ) const ;
Forces evaluation to standard double precision (53-bit mantissa).
context ctx; gen expr = gen ( "1/3" , & ctx); gen dbl = expr . evalf_double ( 1 , & ctx); // dbl: 0.333333333333 (double precision)
evalf2double() - Convert to Double gen gen :: evalf2double ( int level , const context * contextptr ) const ;
Evaluates and converts result to double type.
Evaluation Levels The evaluation level controls how deeply nested expressions are evaluated:
Standard evaluation depth (typically 25)
Level 0 : No evaluationLevel 1 : Single evaluation passHigher levels : Recursive evaluation to specified depth
The default DEFAULT_EVAL_LEVEL is usually sufficient for most operations.
gen x = gen ( "x" , contextptr); gen expr = gen ( "eval(x+1)" , contextptr); // Level 0: No evaluation gen r0 = expr . eval ( 0 , contextptr); // Returns "eval(x+1)" unevaluated // Level 1: One evaluation gen r1 = expr . eval ( 1 , contextptr); // Evaluates outer eval() // Default level: Full evaluation gen r_default = expr . eval (DEFAULT_EVAL_LEVEL, contextptr);
Internal Evaluation Functions in_eval() - Internal Evaluation bool gen :: in_eval ( int level , gen & evaled , const context * contextptr ) const ;
Internal evaluation function that returns success status.
true if evaluation changed the expression, false otherwise
Output parameter receiving the evaluated result
in_evalf() - Internal Float Evaluation bool gen :: in_evalf ( int level , gen & evaled , const context * contextptr ) const ;
Internal floating-point evaluation.
Specialized Evaluation eval_VECT() - Vector Evaluation gen eval_VECT ( const vecteur & v , int subtype , int level , const context * contextptr );
Evaluates all elements of a vector.
vecteur v = { gen ( "x+1" , ctx), gen ( "y*2" , ctx), gen ( "z^2" , ctx)}; gen result = eval_VECT (v, 0 , 1 , & ctx);
evalf_VECT() - Vector Float Evaluation gen evalf_VECT ( const vecteur & v , int subtype , int level , const context * contextptr );
Floating-point evaluation of vector elements.
Checking for Numeric Values has_evalf() - Check if Numeric bool has_evalf ( const gen & g , gen & res , int level , const context * contextptr );
Checks if an expression can be converted to a numeric value.
true if expression has a numeric value
The numeric value if conversion succeeds
context ctx; gen expr = gen ( "sin(pi/2)" , & ctx); gen numeric_val; if ( has_evalf (expr, numeric_val, 1 , & ctx)) { // numeric_val contains 1.0 }
Non-Recursive Evaluation nr_eval() - Non-Recursive Eval gen nr_eval ( const gen & g , int level , const context * ct );
Non-recursive evaluation function (defined in symbolic.h).
Useful for avoiding deep recursion in complex expressions.
Evaluation Modes Evaluation behavior is controlled by context settings:
Approximate Mode bool & approx_mode ( GIAC_CONTEXT );
When true, evaluation returns approximate (floating-point) results.
context ctx; approx_mode ( true , & ctx); gen x = gen ( "1/3" , & ctx); gen result = x . eval ( 1 , & ctx); // result: 0.333333... (approximate) approx_mode ( false , & ctx); result = x . eval ( 1 , & ctx); // result: 1/3 (exact)
Complex Mode bool & complex_mode ( GIAC_CONTEXT );
Allows complex results from operations like sqrt(-1).
context ctx; complex_mode ( true , & ctx); gen x = gen ( "sqrt(-1)" , & ctx); gen result = x . eval ( 1 , & ctx); // result: i (complex number)
Evaluation Level Setting int & eval_level ( GIAC_CONTEXT );
Get current evaluation level in context.
Error Handling Evaluation functions may return error gen objects:
bool is_undef ( const gen & e );
Check if evaluation resulted in an undefined value (error).
context ctx; gen expr = gen ( "1/0" , & ctx); gen result = expr . eval ( 1 , & ctx); if ( is_undef (result)) { // Handle division by zero error }
Evaluation Depth Lower evaluation levels are faster but may not fully simplify:
// Fast but possibly incomplete gen quick = expr . eval ( 1 , contextptr); // Thorough but slower gen complete = expr . eval (DEFAULT_EVAL_LEVEL, contextptr);
Approximate vs Exact Approximate mode is generally faster:
context ctx; // Exact (slower, symbolic) approx_mode ( false , & ctx); gen exact = expr . eval ( 1 , & ctx); // Approximate (faster, numeric) approx_mode ( true , & ctx); gen approx = expr . eval ( 1 , & ctx);
Context Evaluation Helper gen no_context_evalf ( const gen & e );
Evaluate to float without context (uses default settings).
Common Patterns Parse and Evaluate context ctx; std ::string input = "x^2 + 2*x + 1" ; // Parse gen expr ( input , & ctx ); // Set variable ( * ctx . tabptr )[ "x" ] = gen ( 5 ); // Evaluate gen result = expr . eval ( 1 , & ctx); // result: 36
Numeric Approximation context ctx; gen pi = gen ( "pi" , & ctx); // Get approximation gen approx = pi . evalf ( 1 , & ctx); double value = approx . to_double ( & ctx); // value: 3.14159265359
Safe Evaluation gen safe_eval ( const gen & expr , GIAC_CONTEXT ) { gen result = expr . eval (DEFAULT_EVAL_LEVEL, contextptr); if ( is_undef (result)) { // Handle error return gen ( 0 ); // Default value } return result; }
See Also 