Quick Start

This guide will walk you through your first Giac program and introduce you to essential operations.

Choose Your Platform

Node.js
C++

Installation

First, install the Giac npm package:

npm install giac

Your First Program

Create a file example.js:

example.js

const giac = require('giac');

// Evaluate a simple expression
console.log(giac.evaluate('2+2'));
// Output: 4

// Factor a polynomial
console.log(giac.evaluate('factor(x^4-1)'));
// Output: (x-1)*(x+1)*(x^2+1)

// Compute a derivative
console.log(giac.evaluate('diff(sin(x^2),x)'));
// Output: 2*x*cos(x^2)

Run it:

node example.js

Prerequisites

Make sure you have GMP and MPFR installed:

sudo apt install libgmp-dev libmpfr-dev

Your First Program

Create a file example.cpp:

example.cpp

#include "giac.h"
#include <iostream>

using namespace std;
using namespace giac;

int main() {
    context ct;
    
    // Evaluate a simple expression
    gen result = eval(gen("2+2", &ct), 1, &ct);
    cout << "2+2 = " << result << endl;
    
    // Factor a polynomial
    result = eval(gen("factor(x^4-1)", &ct), 1, &ct);
    cout << "factor(x^4-1) = " << result << endl;
    
    // Compute a derivative
    result = eval(gen("diff(sin(x^2),x)", &ct), 1, &ct);
    cout << "diff(sin(x^2),x) = " << result << endl;
    
    return 0;
}

Compile and run:

g++ -o example example.cpp -lgiac -lgmp -lmpfr
./example

Interactive Shell Tutorial

Start the Interactive Shell

Launch the Giac REPL:

Node.js
C++

npm install -g giac
node -e "require('giac').repl()"

cd ~/workspace/source
../gradlew run

Try Basic Arithmetic

>> 2+2
<< 4

>> 1/3 + 1/6
<< 1/2

>> sqrt(2)
<< sqrt(2)

>> evalf(sqrt(2))
<< 1.41421356237

Work with Polynomials

>> expand((x+1)*(x-1))
<< x^2-1

>> factor(x^4-1)
<< (x-1)*(x+1)*(x^2+1)

>> simplify((x^2-1)/(x-1))
<< x+1

Symbolic Calculus

>> diff(sin(x^2), x)
<< 2*x*cos(x^2)

>> int(x*exp(x), x)
<< (x-1)*exp(x)

>> limit(sin(x)/x, x=0)
<< 1

Solve Equations

>> solve(x^2-5*x+6=0, x)
<< [2, 3]

>> solve([x+y=5, x-y=1], [x,y])
<< [[3, 2]]

Essential Operations

Polynomial Operations

const giac = require('giac');

// Expand
giac.evaluate('expand((x+2)^3)');
// x^3+6*x^2+12*x+8

// Factor
giac.evaluate('factor(x^3+6*x^2+12*x+8)');
// (x+2)^3

// Simplify
giac.evaluate('simplify((x^2-4)/(x+2))');
// x-2

Calculus

const giac = require('giac');

// Differentiation
giac.evaluate('diff(x^3*sin(x), x)');
// 3*x^2*sin(x)+x^3*cos(x)

// Integration
giac.evaluate('int(x*exp(x), x)');
// (x-1)*exp(x)

// Definite integral
giac.evaluate('int(x^2, x, 0, 1)');
// 1/3

// Limits
giac.evaluate('limit(sin(x)/x, x=0)');
// 1

Equation Solving

const giac = require('giac');

// Algebraic equation
giac.evaluate('solve(x^2-5*x+6=0, x)');
// [2, 3]

// System of equations
giac.evaluate('solve([x+y=10, 2*x-y=5], [x,y])');
// [[5, 5]]

// Trigonometric equation
giac.evaluate('solve(sin(x)=1/2, x)');
// [pi/6]

Complete Example Program

Here’s a complete program demonstrating various Giac capabilities:

Node.js
C++

app.js

const giac = require('giac');

console.log('=== Giac Computer Algebra System ===\n');

// Polynomial operations
console.log('Polynomial Operations:');
console.log('factor(x^4-1):', giac.evaluate('factor(x^4-1)'));
console.log('expand((x+1)^4):', giac.evaluate('expand((x+1)^4)'));

// Arbitrary precision arithmetic
console.log('\nArbitrary Precision:');
console.log('factorial(50):', giac.evaluate('factorial(50)'));
console.log('evalf(pi, 50):', giac.evaluate('evalf(pi, 50)'));

// Calculus
console.log('\nCalculus:');
console.log('diff(x^3*sin(x), x):', giac.evaluate('diff(x^3*sin(x), x)'));
console.log('int(x*exp(x), x):', giac.evaluate('int(x*exp(x), x)'));
console.log('int(1/(1+x^2), x, 0, inf):', giac.evaluate('int(1/(1+x^2), x, 0, inf)'));

// Solving equations
console.log('\nEquation Solving:');
console.log('solve(x^3-6*x^2+11*x-6=0, x):', giac.evaluate('solve(x^3-6*x^2+11*x-6=0, x)'));

// Complex numbers
console.log('\nComplex Numbers:');
console.log('(1+2*i)*(3-4*i):', giac.evaluate('(1+2*i)*(3-4*i)'));
console.log('abs(3+4*i):', giac.evaluate('abs(3+4*i)'));

Run it:

node app.js

app.cpp

#include "giac.h"
#include <iostream>

using namespace std;
using namespace giac;

int main() {
    context ct;
    
    cout << "=== Giac Computer Algebra System ===" << endl << endl;
    
    // Polynomial operations
    cout << "Polynomial Operations:" << endl;
    cout << "factor(x^4-1): " << eval(gen("factor(x^4-1)", &ct), 1, &ct) << endl;
    cout << "expand((x+1)^4): " << eval(gen("expand((x+1)^4)", &ct), 1, &ct) << endl;
    
    // Arbitrary precision arithmetic
    cout << endl << "Arbitrary Precision:" << endl;
    cout << "factorial(50): " << eval(gen("factorial(50)", &ct), 1, &ct) << endl;
    
    // Calculus
    cout << endl << "Calculus:" << endl;
    cout << "diff(x^3*sin(x), x): " << eval(gen("diff(x^3*sin(x), x)", &ct), 1, &ct) << endl;
    cout << "int(x*exp(x), x): " << eval(gen("int(x*exp(x), x)", &ct), 1, &ct) << endl;
    
    // Solving equations
    cout << endl << "Equation Solving:" << endl;
    cout << "solve(x^3-6*x^2+11*x-6=0, x): " << eval(gen("solve(x^3-6*x^2+11*x-6=0, x)", &ct), 1, &ct) << endl;
    
    // Complex numbers
    cout << endl << "Complex Numbers:" << endl;
    cout << "(1+2*i)*(3-4*i): " << eval(gen("(1+2*i)*(3-4*i)", &ct), 1, &ct) << endl;
    cout << "abs(3+4*i): " << eval(gen("abs(3+4*i)", &ct), 1, &ct) << endl;
    
    return 0;
}

Compile and run:

g++ -o app app.cpp -lgiac -lgmp -lmpfr
./app

Error Handling

Node.js
C++

const giac = require('giac');

try {
    const result = giac.evaluate('solve(x^2+1=0, x)');
    console.log('Solution:', result);
} catch (err) {
    console.error('Error:', err.message);
}

#include "giac.h"
#include <iostream>

using namespace std;
using namespace giac;

int main() {
    context ct;
    
    try {
        gen result = eval(gen("solve(x^2+1=0, x)", &ct), 1, &ct);
        cout << "Solution: " << result << endl;
    } catch (runtime_error& e) {
        cerr << "Error: " << e.what() << endl;
    }
    
    return 0;
}

Next Steps

Core Concepts

Understand Giac’s architecture and type system

API Reference

Explore the complete API documentation

Platform Guides

Integration guides for different platforms

Building

Build Giac from source

Tips for Success

Use the REPL for exploration

The interactive REPL is the fastest way to experiment with Giac commands and test expressions before integrating them into your code.

Leverage symbolic computation

Unlike numerical libraries, Giac preserves exact symbolic representations. Use evalf() only when you need numerical approximations.

Context management

For multi-threaded applications, create separate contexts for each thread to avoid state conflicts.

Error handling

Always wrap Giac evaluations in try-catch blocks, as invalid expressions or operations can throw runtime errors.

Get Started

Core Concepts

Platform Guides

Building & Compilation

Quick Start

Choose Your Platform

Installation

Your First Program

Prerequisites

Your First Program

Interactive Shell Tutorial

Essential Operations

Polynomial Operations

Calculus

Equation Solving

Complete Example Program

Error Handling

Next Steps

Core Concepts

API Reference

Platform Guides

Building

Tips for Success

Build docs developers (and LLMs) love

Get Started

Core Concepts

Platform Guides

Building & Compilation

​Choose Your Platform

​Installation

​Your First Program

​Prerequisites

​Your First Program

​Interactive Shell Tutorial

​Essential Operations

​Polynomial Operations

​Calculus

​Equation Solving

​Complete Example Program

​Error Handling

​Next Steps

Core Concepts

API Reference

Platform Guides

Building

​Tips for Success

Build docs developers (and LLMs) love

Choose Your Platform

Installation

Your First Program

Prerequisites

Your First Program

Interactive Shell Tutorial

Essential Operations

Polynomial Operations

Calculus

Equation Solving

Complete Example Program

Error Handling

Next Steps

Tips for Success