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
The gen class is the fundamental type in Giac, representing polymorphic algebraic objects. It can hold integers, floating-point numbers, complex numbers, symbolic expressions, vectors, matrices, and more.
Defined in: src/giac/headers/gen.h
Type System
The gen class uses a type field to distinguish between different value types:
class gen {
public:
unsigned char type; // Type identifier
signed char subtype; // Subtype information
unsigned short reserved; // Used for 64-bit pointers
union {
int val; // Immediate integer
double _DOUBLE_val; // Immediate double (if DOUBLEVAL)
// ... pointer types for complex objects
};
};
Type Constants
From dispatch.h:
Integer type (immediate value)
Double-precision floating point
Arbitrary precision integer (GMP mpz_t)
Arbitrary precision real (MPFR)
Rational number (fraction)
Identifier (variable name)
Constructors
Default Constructor
Creates a gen initialized to 0.
Integer Constructors
gen(int i);
gen(long i);
gen(longlong i);
gen(const mpz_t & m);
gen a(42); // int
gen b(1000000000L); // long
gen c("12345678901234567890", contextptr); // Large integer from string
Floating-Point Constructors
gen(double d);
gen(const giac_float & f);
gen x(3.14159);
gen y(2.718281828);
Complex Constructors
gen(int a, int b); // a + bi
gen(double a, double b); // a + bi
gen(const gen & a, const gen & b); // a + bi
gen(const std::complex<double> & c);
gen i(0, 1); // i = sqrt(-1)
gen z(3.0, 4.0); // 3 + 4i
gen w = gen(1, 2); // 1 + 2i
Vector Constructor
gen(const vecteur & v, short int s = 0);
s can specify special vector types.
vecteur v = {gen(1), gen(2), gen(3)};
gen vec(v); // Vector [1, 2, 3]
Symbolic Constructor
Create gen from a symbolic expression.
String Constructor
gen(const std::string & s, GIAC_CONTEXT);
gen(const char * s, GIAC_CONTEXT);
gen expr("x^2 + 2*x + 1", contextptr);
gen val("3.14159", contextptr);
Core Methods
Evaluation
gen eval(int level, const context * contextptr) const;
Evaluation depth (typically DEFAULT_EVAL_LEVEL)
gen x = gen("x", contextptr);
gen expr = x * x + 2 * x + 1;
gen result = expr.eval(DEFAULT_EVAL_LEVEL, contextptr);
Floating-Point Evaluation
gen evalf(int level, const context * contextptr) const;
gen evalf_double(int level, const context * contextptr) const;
evalf() - Returns arbitrary precision if availableevalf_double() - Forces double precision
gen pi = gen("pi", contextptr);
gen approx = pi.evalf(1, contextptr); // 3.14159265359...
Type Conversion
int to_int() const;
double to_double(const context * contextptr) const;
gen x(42);
int n = x.to_int(); // 42
gen y(3.14);
double d = y.to_double(contextptr); // 3.14
Type Checking
bool is_integer() const;
bool is_cinteger() const; // Complex integer
bool is_real(GIAC_CONTEXT) const;
bool is_constant() const;
bool is_approx() const;
gen x(42);
if (x.is_integer()) {
// x is an integer
}
gen y(3.14);
if (y.is_approx()) {
// y is approximate (floating-point)
}
Arithmetic Operators
The gen class overloads standard C++ operators:
gen operator + (const gen & a, const gen & b);
gen operator - (const gen & a, const gen & b);
gen operator - (const gen & a); // Unary minus
gen operator * (const gen & a, const gen & b);
gen operator / (const gen & a, const gen & b);
gen operator % (const gen & a, const gen & b);
gen a(5), b(3);
gen sum = a + b; // 8
gen diff = a - b; // 2
gen prod = a * b; // 15
gen quot = a / b; // 5/3 (rational)
gen neg = -a; // -5
Compound Assignment
gen & operator += (gen & a, const gen & b);
gen & operator -= (gen & a, const gen & b);
Comparison Operators
bool operator == (const gen & a, const gen & b);
bool operator != (const gen & a, const gen & b);
bool operator > (const gen & a, const gen & b);
bool operator < (const gen & a, const gen & b);
gen a(5), b(3);
if (a > b) {
// 5 > 3 is true
}
Complex Number Operations
gen conj(GIAC_CONTEXT) const; // Complex conjugate
gen re(GIAC_CONTEXT) const; // Real part
gen im(GIAC_CONTEXT) const; // Imaginary part
gen squarenorm(GIAC_CONTEXT) const; // |z|^2
gen z(3.0, 4.0); // 3 + 4i
gen conj_z = z.conj(contextptr); // 3 - 4i
gen re_z = z.re(contextptr); // 3
gen im_z = z.im(contextptr); // 4
gen norm = z.squarenorm(contextptr); // 25
Vector/Matrix Operations
Indexing
gen operator [] (int i) const;
gen operator [] (const gen & i) const;
vecteur v = {gen(1), gen(2), gen(3)};
gen vec(v);
gen elem = vec[0]; // 1
Function Application
gen operator () (const gen & i, GIAC_CONTEXT) const;
Advanced Methods
gen inverse(GIAC_CONTEXT) const;
Printing
std::string print(GIAC_CONTEXT) const;
const char * dbgprint() const;
gen x("x^2 + 1", contextptr);
std::string str = x.print(contextptr);
std::cout << str << std::endl; // "x^2+1"
Memory Management
The gen class uses reference counting for heap-allocated types:
volatile ref_count_t & ref_count() const;
- Simple types (integers, doubles) are stored inline
- Complex types use reference-counted pointers
- Copy-on-write semantics for efficiency
Size and Dimensions
bool is_vector_of_size(size_t n) const;
int symb_size() const;
Helper Functions
bool is_zero(const gen & a, GIAC_CONTEXT);
bool is_one(const gen & a);
bool is_minus_one(const gen & a);
bool is_inf(const gen & e);
bool is_undef(const gen & e);
gen x(0);
if (is_zero(x, contextptr)) {
// x is zero
}
See Also
