Quick Start

Get up and running with Giac in minutes with this hands-on tutorial

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

Choose Your Platform

Node.js

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

C++

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

1. Start the Interactive Shell

   Launch the Giac REPL:

   Node.js

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

   C++

   cd ~/workspace/source
   ../gradlew run
   
2. Try Basic Arithmetic

   >> 2+2
   << 4
   
   >> 1/3 + 1/6
   << 1/2
   
   >> sqrt(2)
   << sqrt(2)
   
   >> evalf(sqrt(2))
   << 1.41421356237
   
3. 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
   
4. 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
   
5. 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

Node.js

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

Node.js

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

Node.js

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

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

C++

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

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);
}

C++

#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.