Mémorisation d'une fonction et utilisation avec icas

[ddorange]

Bonjour,

Pour mémoriser une fonction comme celle définie par f(x)=x^2+1 voici le code que j'utilise dans giac.in :

Code : Tout sélectionner

unarchive("giac.sav");
Resultat:=(f(x):=x^2+1);
Sortie:=fopen("giac.var");
for j in VARS do
  si eval(j,1)!='Resultat' et eval(j,1)!='Sortie' et eval(j,1)!='j' alors
    print(eval(j,1),type(j));
    si type(j)==DOM_FUNC  et eval(j,1)!='Resultat' alors
       fprint(Sortie,Unquoted,eval(j,1));
       fprint(Sortie,Unquoted,"(x):=");
       fprint(Sortie,Unquoted,j[3]);
    sinon
       fprint(Sortie,Unquoted,eval(j,1));
       fprint(Sortie,Unquoted,"=");
       fprint(Sortie,Unquoted,j);
    fsi;
    fprint(Sortie,Unquoted,"\n");
  fsi;
od;
fclose(Sortie);
archive("giac.sav");

Le fichier giac.var généré contient :

Code : Tout sélectionner

Resultat(x):=x**2+1
Sortie=pointer(0x7f6234000fb0,0)
f(x):=x**2+1

1) les deux premières lignes sont "de trop" sous Linux Ubuntu pas Windows. Peut-on l'éviter en modifiant le giac.in ?
2) comment faire pour définir des fonctions écrites en langage Python comme ?

Code : Tout sélectionner

def g(x):
	if x>0:
		return 2*x
	else:
		return 0

Merci par avance pour vos réponses.
Cordialement.

[parisse]

Je viens de tester, je n'ai que la ligne f(x):=x^2+1 dans le fichier giac.var aussi bien sous Linux (debian 11) que windows avec la version mingw de Xcas (i.e. ou xcas et icas sont liés avec giacxcas.dll).
Pour les programmes écrits en syntaxe Python, il faut s'assurer que le mode est Python compatible (python_compat(1)) au moment où ils sont interprétés. Ensuite ils seront sauvegardés, comme un programme écrit en syntaxe Xcas (il n'y a pas deux types de programme, mais un seul, c'est juste l'interpréteur qui peut être dans plusieurs modes).

[ddorange]

Bonjour,

Pour le point 1 pas de problème cela semble limité à Ubuntu 20.04. Le problème n'apparaît pas sous Windows. Je ferai d'autres tests.

Pour le point 2, ma question était peut-être mal posée.
Que devient la ligne Resultat:=(f(x):=x^2+1); avec une fonction en langage Python (voir mon exemple) ?
Ensuite comment s'assure-t-on que le mode est Python compatible (python_compat(1))
- avec le réglage de la configuration de Xcas en choisissant Python ^=** comme "programme style"
- ou bien, il y a un fichier de configuration sur le disque dur que l'on peut modifier par programme
- ou bien en précisant avec une ligne du type "cas_setup(0,0,0,1,0,[1e-12,1e-15],12,[0,100,0,25],0,1,0,1);" tirée de mon giac.in pour calculer f(3).

Code : Tout sélectionner

unarchive("giac.sav");
cas_setup(0,0,0,1,0,[1e-12,1e-15],12,[0,100,0,25],0,1,0,1);
Sortie:=fopen("giac.out");
fprint(Sortie,Unquoted,normal(f(3)));
fclose(Sortie);
archive("giac.sav");

[parisse]

Le mieux je pense est de faire la sauvegarde de toutes les fonctions en syntaxe Xcas, quel que soit le mode ou elles ont ete ecrites, cela devrait assurer qu'on les recupere ensuite.
Donc juste avant de faire des sauvegardes de variables ou de restaurer des variables utiliser la commande xcas_mode(0); python_compat(0);
Et faire python_compat(1) avant chaque parse d'une entree utilisateur si on veut etre en mode compatible Python avec ^=**

[ddorange]

Bonjour,
Merci pour ces éclaircissements.
Reste une question en suspens : comment je remplace Resultat:=(f(x):=x^2+1); avec une fonction du type ?

Code : Tout sélectionner

def g(x):
	if x>0:
		return 2*x
	else:
		return 0

Cordialement.

[parisse]

Si l'utilisateur a déjà rentré la fonction; l'impression par fprint fera automatiquement le travail. Sinon, il faut appeler explicitement le parser en utilisant expr avec en argument la chaine de caractères définissant la fonction.

[ddorange]

Bonjour,

Je ne sais pas si j'ai bien compris.
Voilà ce que j'ai comme giac.in pour définir la fonction :

Code : Tout sélectionner

xcas_mode(0);
python_compat(0);
unarchive("giac.sav");
Resultat:=(def G(x):
	return 2*x+3);
Sortie:=fopen("giac.var");
for j in VARS do
  si eval(j,1)!='Resultat' et eval(j,1)!='Sortie' et eval(j,1)!='j' alors
    print(eval(j,1),type(j));
    si type(j)==DOM_FUNC  et eval(j,1)!='Resultat' alors
       fprint(Sortie,Unquoted,eval(j,1));
       fprint(Sortie,Unquoted,"(x):=");
       fprint(Sortie,Unquoted,j[3]);
    sinon
       fprint(Sortie,Unquoted,eval(j,1));
       fprint(Sortie,Unquoted,"=");
       fprint(Sortie,Unquoted,j);
    fsi;
    fprint(Sortie,Unquoted,"\n");
  fsi;
od;
fclose(Sortie);
archive("giac.sav");

et comme fichier giac.in pour évaluer en 3

Code : Tout sélectionner

python_compat(1);
unarchive("giac.sav");
cas_setup(0,0,0,1,0,[1e-12,1e-15],12,[0,100,0,25],0,1,0,1);
Sortie:=fopen("giac.out");
fprint(Sortie,Unquoted,normal(G(3)));
fclose(Sortie);
archive("giac.sav");

Le giac.out me retourne la chaîne G(3).
Cordialement.

[parisse]

Les 2 lignes

Code : Tout sélectionner

Resultat:=(def G(x):
	return 2*x+3);

vont poser problème, mélange de syntaxes. C'est là qu'on peut utiliser expr

Code : Tout sélectionner

Resultat:=expr("def G(x):
	return 2*x+3);")

[ddorange]

Bonjour,
Cela fonctionne si l'on écrit (ordre des caractères) :

Code : Tout sélectionner

Resultat:=expr("def G(x):
	return x^2");

et aussi avec :

Code : Tout sélectionner

Resultat:=expr("def G(x):
	if x>0:
		return x^2+5
	else:
		return 3*x");

Merci pour votre aide et votre travail.
Commentaire : Je n'ai pas spécialement la religion du Python mais comme dans l'enseignement secondaire on ne jure que par cela ...
Pour le traitement de textes Writer, les utilisateurs de Dmaths peuvent choisir Sympy ou Xcas.
Je l'ai complété en développant pour le tableur une solution inspirée de CmathOOoCas.
Pour des raisons de commodités l'Addin est en Python (LibreOffice embarque un exécutable Python) et le calcul formel pour le tableur se fait avec Sympy.
Le gros avantage c'est que je n'ai pas de problème de compilation puisque les scripts Python s'interprètent dans toutes les plateformes et que la bibliothèque Sympy est identique pour les trois plateformes. Le dossier Sympy de Linux copié dans le bon répertoire sous Windows ou MasOS fonctionne.
Cela ne semble pas le cas avec giacpy.
MAIS, je souhaite que les utilisateurs puissent choisir également Sympy ou Xcas pour le calcul formel dans le tableur Calc. D'où mes questions... Et le fait que je reste sur une écriture disque (giac.in et giac.out). C'est plus lent mais ce n'est pas un gros problème si on ne fait pas plus d'une dizaine de calculs ...
Licence : Dmaths est publié sous licence GPLv3.

Bien cordialement.

[parisse]

Oui, comme sympy est écrit complètement en Python, il fonctionne indépendamment de l'OS, mais à la vitesse d'un langage interprété. Ce n'est pas le cas de giac qui est une interface à du code natif, c'est donc plus complexe à faire fonctionner, c'est le prix à payer pour avoir un système nettement plus rapide. Ca ne doit guère jouer pour les utilisateurs d'un tableur sur un PC moderne bien sur.
Par contre pour une implémentation sur calculatrice, les choses sont différentes! Le système le moins gourmand en énergie pour faire tourner Xcas aujourd'hui, c'est la Casio Graph 35eii. Puissance 6mW, c'est 10 000 fois moins qu'un PC et 200 fois moins qu'un smartphone.

[ddorange]

Bonjour,
Dans Xcas, j'ai défini la fonction :

Code : Tout sélectionner

def f(x):
    if x>=0 and x<=2:
        return -x
    elif x>2 :
        return x*x

f(-5) retourne 0 alors que la réponse attendue est None.

[parisse]

Dans Xcas, un test if sans else correspondant renvoie 0. Ceci s'applique également avec la compatibilité Python de Xcas (qui intervient seulement au moment de l'interprétation).

[parisse]

P.S.: on peut utiliser piecewise pour avoir en réponse "Aucun cas ne s'applique".
Sinon il faut explicitement terminer la fonction par return None. A noter: None n'est pas interprété de manière spéciale, c'est juste un nom de variable.

[ddorange]

Bonjour,
Merci pour toutes ces précisions ...