### Navigation

- index
- modules |
- suivant |
- précédent |
- Tutoriel Sage v6.4.1 »

# Interfaces

L’un des aspects essentiels de Sage est qu’il permet d’effectuer des calculs utilisant des objets issus de nombreux systèmes de calcul formel de façon unifiée, avec une interface commune et un langage de programmation sain.

Les méthodes `console` et `interact` d’une interface avec un programme externe font des choses tout-à-fait différentes. Prenons l’exemple de GAP :

1. `gap.console()` : Cette commande ouvre la console GAP. Cela transfère le contrôle à GAP ; Sage n’est dans ce cas qu’un moyen commode de lancer des programmes, un peu comme le shell sous Unix.
2. `gap.interact()` : Cette commande permet d’interagir avec une instance de GAP en cours d’exécution, et éventuellement « remplie d’objets Sage ». Il est possible d’importer des objets Sage dans la session GAP (y compris depuis l’interface interactive), etc.

## GP/PARI

PARI est un programme C compact, mature, fortement optimisé et spécialisé en théorie des nombres. Il possède deux interfaces très différentes utilisables depuis Sage :

- `gp` - l’interpréteur “G o P ARI”, et
- `pari` - la bibliothèque C PARI.

Ainsi, les deux commandes suivantes font le même calcul de deux façons différentes. Les deux sorties ont l’air identiques, mais elles ne le sont pas en réalité, et ce qui ce passe en coulisses est radicalement différent.

    sage: gp('znprimroot(10007)')
    Mod(5, 10007)
    sage: pari('znprimroot(10007)')
    Mod(5, 10007)

Dans le premier exemple, on démarre une instance de l’interpréteur GP et on lui envoie la chaîne `'znprimroot(10007)'`. Il l’évalue, et affecte le résultat à une variable GP (ce qui occupe un espace qui ne sera pas libéré dans la mémoire du processus fils GP). La valeur de la variable est ensuite affichée. Dans le second cas, nul programme séparé n’est démarré, la chaîne `'znprimroot(10007)'` est évaluée par une certaine fonction de la bibliothèque C PARI. Le résultat est stocké sur le tas de l’interpréteur Python, et la zone de mémoire utilisée est libérée lorsque son contenu n’est plus utilisé. Les objets renvoyés par ces deux commandes sont de types différents :

    sage: type(gp('znprimroot(10007)'))
    <class 'sage.interfaces.gp.GpElement'>
    sage: type(pari('znprimroot(10007)'))
    <type 'sage.libs.pari.gen.gen'>

Alors, laquelle des intrefaces utiliser ? Tout dépend de ce que vous cherchez à faire. L’interface GP permet de faire absolument tout ce que vous pourriez faire avec la ligne de commande GP/PARI habituelle, puisqu’elle fait appel à celle-ci. En particulier, vous pouvez l’utiliser pour charger et exécuter des scripts PARI compliqués. L’interface PARI (via la bibliothèque C) est nettement plus restrictive. Tout d’abord, toutes les méthodes ne sont pas implémentées. Deuxièmement, beaucoup de code utilisant par exemple l’intégration numérique ne fonctionne pas via l’interface PARI. Ceci dit, l’interface PARI est souvent considérablement plus rapide et robuste que l’interface GP.

(Si l’interface GP manque de mémoire pour évaluer une ligne d’entrée donnée, elle double silencieusement la taille de la pile et réessaie d’évaluer la ligne. Ainsi votre calcul ne plantera pas même si vous n’avez pas évalué convenablement l’espace qui nécessite. C’est une caractéristique commode que l’interpréteur GP habituel ne semble pas fournir. L’interface PARI, quant à elle, déplace immédiatement les objets créés en-dehors de la pile de PARI, de sorte que celle-ci ne grossit pas. Cependant, la taille de chaque objet est limitée à 100 Mo, sous peine que la pile ne déborde à la création de l’objet. Par ailleurs, cette copie supplémentaire a un léger impact sur les performances.)

En résumé, Sage fait appel à la bibliothèque C PARI pour fournir des fonctionnalités similaires à celle de l’interpréteur PARI/GP, mais depuis le langage Python, et avec un gestionnaire de mémoire plus perfectionné.

Commençons par créer une liste PARI à partir d’une liste Python.

    sage: v = pari([1,2,3,4,5])
    sage: v
    [1, 2, 3, 4, 5]
    sage: type(v)
    <type 'sage.libs.pari.gen.gen'>

En Sage, les objets PARI sont de type `py_pari.gen`. Le type PARI de l’objet sous-jacent est donné par la méthode `type`.

    sage: v.type()
    't_VEC'

Pour créer une courbe elliptique en PARI, on utiliserait `ellinit([1,2,3,4,5])`. La syntaxe Sage est semblable, à ceci près que `ellinit` devient une méthode qui peut être appelée sur n’importe quel objet PARI, par exemle notre `t_VEC v`.

    sage: e = v.ellinit()
    sage: e.type()
    't_VEC'
    sage: pari(e)[:13]
    [1, 2, 3, 4, 5, 9, 11, 29, 35, -183, -3429, -10351, 6128487/10351]

À présent que nous disposons d’une courbe elliptique, faisons quelques calculs avec.

    sage: e.elltors()
    [1, [], []]
    sage: e.ellglobalred()
    [10351, [1, -1, 0, -1], 1, [11, 1; 941, 1], [[1, 5, 0, 1], [1, 5, 0, 1]]]
    sage: f = e.ellchangecurve([1,-1,0,-1])
    sage: f[:5]
    [1, -1, 0, 4, 3]

## GAP

Pour les mathématiques discrètes effectives et principalement la théorie des groupes, Sage utilise GAP 4.4.10.

Voici un exemple d’utilisation de la fonction GAP `IdGroup`, qui nécessite une base de données optionnelle de groupes de petit ordre, à installer séparément comme décrit plus bas.

    sage: G = gap('Group((1,2,3)(4,5), (3,4))')
    sage: G
    Group( [ (1,2,3)(4,5), (3,4) ] )
    sage: G.Center()
    Group( () )
    sage: G.IdGroup()    # optional - database_gap
    [ 120, 34 ]
    sage: G.Order()
    120

On peut faire le même calcul en SAGE sans invoquer explicitement l’interface GAP comme suit :

    sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]])
    sage: G.center()
    Subgroup of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]) generated by [()]
    sage: G.group_id()    # optional - database_gap
    [120, 34]
    sage: n = G.order(); n
    120

(Certaines fonctionnalités de GAP nécessitent l’installation de deux paquets facultatifs. Saisissez `sage -optional` pour consulter la liste des paquets facultatifs, et choisissez celui dont le nom ressemble à `gap\_packages-x.y.z`, puis installez-le par `sage -i gap\_packages-x.y.z`. Faites de même avec `database\_gap-x.y.z`. D’autres paquets GAP, non couverts par la licence GPL, peuvent être téléchargés depuis le site web de GAP [GAPkg] et installés en les désarchivant dans `$SAGE_ROOT/local/lib/gap-4.4.10/pkg`.)

## Singular

Singular fournit une bibliothèque consistante et mature qui permet, entre autres, de calculer des pgcd de polynômes de plusieurs variables, des factorisations, des bases de Gröbner ou encore des bases d’espaces de Riemann-Roch de courbes planes. Considérons la factorisation de polynômes de plusieurs variables à l’aide de l’interface à Singular fournie par Sage (n’entrez pas les `...`) :

    sage: R1 = singular.ring(0, '(x,y)', 'dp')
    sage: R1
    //   characteristic : 0
    //   number of vars : 2
    //        block   1 : ordering dp
    //                  : names    x y
    //        block   2 : ordering C
    sage: f = singular('9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + \
    ...   9*x^6*y^4 + 18*x^7*y^5 + 36*x^8*y^4 + 9*x^10*y^4 - 18*x^11*y^2 - \
    ...   9*x^12*y^3 - 18*x^13*y^2 + 9*x^16')

Maintenant que nous avons défini \(f\), affichons-le puis factorisons-le.

    sage: f
    9*x^16-18*x^13*y^2-9*x^12*y^3+9*x^10*y^4-18*x^11*y^2+36*x^8*y^4+18*x^7*y^5-18*x^5*y^6+9*x^6*y^4-18*x^3*y^6-9*x^2*y^7+9*y^8
    sage: f.parent()
    Singular
    sage: F = f.factorize(); F
    [1]:
       _[1]=9
       _[2]=x^6-2*x^3*y^2-x^2*y^3+y^4
       _[3]=-x^5+y^2
    [2]:
       1,1,2
    sage: F[1][2]
    x^6-2*x^3*y^2-x^2*y^3+y^4

Comme avec GAP dans la section GAP, nous pouvons aussi calculer la factorisation sans utiliser explicitement l’interface Singular (Sage y fera tout de même appel en coulisses pour le calcul).

    sage: x, y = QQ['x, y'].gens()
    sage: f = 9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + 9*x^6*y^4\
    ...   + 18*x^7*y^5 + 36*x^8*y^4 + 9*x^10*y^4 - 18*x^11*y^2 - 9*x^12*y^3\
    ...   - 18*x^13*y^2 + 9*x^16
    sage: factor(f)
    (9) * (-x^5 + y^2)^2 * (x^6 - 2*x^3*y^2 - x^2*y^3 + y^4)

## Maxima

Le système de calcul formel Maxima est fourni avec Sage accompagné d’une implémentation du langage Lisp. Le logiciel gnuplot (que Maxima utilise par défaut pour tracer des graphiques) est disponible comme paquet optionnel. Maxima fournit notamment des routines de calcul sur des expressions formelles. Il permet de calculer des dérivées, primitives et intégrales, de résoudre des équations différentielles d’ordre 1 et souvent d’ordre 2, et de résoudre par transformée de Laplace les équations différentielles linéaires d’ordre quelconque. Maxima dispose aussi d’un grand nombre de fonctions spéciales, permet de tracer des graphes de fonctions via gnuplot, et de manipuler des matrices (réduction en lignes, valeurs propres, vecteurs propres...) ou encore des équations polynomiales.

Utilisons par exemple l’interface Sage/Maxima pour construire la matrice dont le coefficient d’indice \(i,j\) vaut \(i/j\), pour \(i,j=1,\ldots,4\).

    sage: f = maxima.eval('ij_entry[i,j] := i/j')
    sage: A = maxima('genmatrix(ij_entry,4,4)'); A
    matrix([1,1/2,1/3,1/4],[2,1,2/3,1/2],[3,3/2,1,3/4],[4,2,4/3,1])
    sage: A.determinant()
    0
    sage: A.echelon()
    matrix([1,1/2,1/3,1/4],[0,0,0,0],[0,0,0,0],[0,0,0,0])
    sage: A.eigenvalues()
    [[0,4],[3,1]]
    sage: A.eigenvectors()
    [[[0,4],[3,1]],[[[1,0,0,-4],[0,1,0,-2],[0,0,1,-4/3]],[[1,2,3,4]]]]

Un deuxième exemple :

    sage: A = maxima("matrix ([1, 0, 0], [1, -1, 0], [1, 3, -2])")
    sage: eigA = A.eigenvectors()
    sage: V = VectorSpace(QQ,3)
    sage: eigA
    [[[-2,-1,1],[1,1,1]],[[[0,0,1]],[[0,1,3]],[[1,1/2,5/6]]]]
    sage: v1 = V(sage_eval(repr(eigA[1][0][0]))); lambda1 = eigA[0][0][0]
    sage: v2 = V(sage_eval(repr(eigA[1][1][0]))); lambda2 = eigA[0][0][1]
    sage: v3 = V(sage_eval(repr(eigA[1][2][0]))); lambda3 = eigA[0][0][2]

    sage: M = MatrixSpace(QQ,3,3)
    sage: AA = M([[1,0,0],[1, - 1,0],[1,3, - 2]])
    sage: b1 = v1.base_ring()
    sage: AA*v1 == b1(lambda1)*v1
    True
    sage: b2 = v2.base_ring()
    sage: AA*v2 == b2(lambda2)*v2
    True
    sage: b3 = v3.base_ring()
    sage: AA*v3 == b3(lambda3)*v3
    True

Voici enfin quelques exemples de tracés de graphiques avec `openmath` depuis Sage. Un grand nombre de ces exemples sont des adaptations de ceux du manuel de référence de Maxima.

Tracé en 2D de plusieurs fonctions (n’entrez pas les `...`) :

    sage: maxima.plot2d('[cos(7*x),cos(23*x)^4,sin(13*x)^3]','[x,0,1]', # not tested
    ....: '[plot_format,openmath]')

Un graphique 3D interactif, que vous pouvez déplacer à la souris (n’entrez pas les `...`) :

    sage: maxima.plot3d ("2^(-u^2 + v^2)", "[u, -3, 3]", "[v, -2, 2]", # not tested
    ....: '[plot_format, openmath]')
    sage: maxima.plot3d("atan(-x^2 + y^3/4)", "[x, -4, 4]", "[y, -4, 4]", # not tested
    ....: "[grid, 50, 50]",'[plot_format, openmath]')

Le célèbre ruban de Möbius (n’entrez pas les `...`) :

    sage: maxima.plot3d("[cos(x)*(3 + y*cos(x/2)), sin(x)*(3 + y*cos(x/2)), y*sin(x/2)]", # not tested
    ....: "[x, -4, 4]", "[y, -4, 4]",
    ....: '[plot_format, openmath]')

Et la fameuse bouteille de Klein (n’entrez pas les `...`):

    sage: maxima("expr_1: 5*cos(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)\
    ...   - 10.0")
    5*cos(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)-10.0
    sage: maxima("expr_2: -5*sin(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)")
    -5*sin(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)
    sage: maxima("expr_3: 5*(-sin(x/2)*cos(y) + cos(x/2)*sin(2*y))")
    5*(cos(x/2)*sin(2*y)-sin(x/2)*cos(y))
    sage: maxima.plot3d ("[expr_1, expr_2, expr_3]", "[x, -%pi, %pi]", # not tested
    ....: "[y, -%pi, %pi]", "['grid, 40, 40]",
    ....: '[plot_format, openmath]')

### Navigation

- index
- modules |
- suivant |
- précédent |
- Tutoriel Sage v6.4.1 »