Sujet : Pari/gp et fonction

Ce sujet contient 8 réponses, 3 participants et a été mis à jour pour la dernière fois par bernadette, le il y a 4 années et 5 mois.

Vous lisez 8 fils de discussion

Auteur

Messages
- 2 novembre 2019 à 18:08 #5308
  Julien
  Modérateur
  Up
  0
  Down
  ::
  Bonjour,
  
  Le code suivant fonctionne dans direct exe :
```
a=10;
f(t)=t^2;
printsep("|",f(a));
```
  Par contre dans un fichier oef, f(t) les parenthèses sont mal interprétées par pari/gp et le code suivant ne fonctionne pas :
```
\text{DD=pari(a=10;
f(t)=t^2;
printsep("|",f(a));
)}
```
  Une idée est la bienvenue.
  - Ce sujet a été modifié le il y a 4 années et 5 mois par Julien.
  - Ce sujet a été modifié le il y a 4 années et 5 mois par Julien.
- 2 novembre 2019 à 21:35 #5313
  byache
  Participant
  Up
  0
  Down
  ::
  Je ne comprend peut-être pas bien le but, mais ce qu’on fait en général c’est une variable wims qui contient a, une autre qui contient f et ensuite pas besoin d’un appel à pari-gp…
  
  A la limite un replace…
```
\real{a=10}
\text{f=t^2}
\real{wims(replace internal t by \a in \f)}
```
- 4 novembre 2019 à 00:13 #5317
  
  Julien
  Modérateur
  
  Up
  1
  Down
  ::
  En remplaçant a=10 par a=1/3 tu as la valeur exacte avec pari/gp. En gros tu maîtrises mieux la sortie. Avec Wims tu as juste les valeurs numériques.
- 4 novembre 2019 à 06:59 #5318
  
  byache
  Participant
  
  Up
  0
  Down
  ::
  Dans ce cas, tu as aussi le choix de mettre, après le replace, pari(eval f)
  Ou un truc du genre…
  Bref, l’idée est d’avoir les variables et le gros du code en syntaxe ‘wims’ et de faire appel à pari ou aux autres logiciels disponibles juste pour faire un calcul par ci par là.
  Si tu fais autrement, il faut s’attendre à des problèmes je pense.
- 4 novembre 2019 à 07:07 #5319
  
  byache
  Participant
  
  Up
  0
  Down
  ::
  De plus, tu peux très bien avoir la valeur exacte sans utiliser explicitement pari (en fait je ne crois pas me tromper en disant que wims envoie de toute façon le calcul à pari à un moment).
  Il suffit de déclarer que tu veux une fraction, ou même un texte :
  \rational{image=\f}
  Ou
  \text{image=\f}
  (Non testé car sur mon téléphone c’est galère 🙂
- 4 novembre 2019 à 10:04 #5320
  byache
  Participant
  Up
  0
  Down
  ::
  Là, je suis sur un ordinateur, donc c’est plus pratique.
  Je n’ai pas été très clair ci-dessus. Voilà du code qui fonctionne :
```
\rational{a=2/3}
\rational{f=(\a)^2}
\statement{\f}
```
  Ou alors (plus compliqué et qui fait au final la même chose) :
```
\rational{a=2/3}
\text{f=(t)^2}
\rational{g=wims(replace internal t by \a in \f)}
\statement{\g}
```
  ou encore plus compliqué :
```
\rational{a=2/3}
\text{f=(t)^2}
\text{g=wims(replace internal t by \a in \f)}
\rational{h=pari(eval \g)}
\statement{\h}
```
  Bon, il y a sans doute moyen de faire encore plus compliqué 🙂
- 5 novembre 2019 à 16:47 #5322
  Julien
  Modérateur
  Up
  0
  Down
  ::
  Ok Paul mais je veux pouvoir scripter avec pari sans passer par Wims. Tu as la récursivité et parfois avec Wims tu as un « too many goto ». Il doit bien avoir des caractères d’échappement pour que la déclaration d’un fonction passe.
  Voili voilou
  - Cette réponse a été modifiée le il y a 4 années et 5 mois par Julien.
- 6 novembre 2019 à 23:15 #5326
  Julien
  Modérateur
  Up
  0
  Down
  ::
  J’ai trouvé une solution en effectuant 2 appels à pari.
```
\text{aa=pari(f(t)=t^2;)}
\text{DD=pari(a=10;
printsep("|",f(a));
)}
```
- 8 novembre 2019 à 08:47 #5329
  bernadette
  Maître des clés
  Up
  1
  Down
  ::
  Si je mets ton code directement dans pari/gp, j’obtiens
```
? a=10;f(t)=t^2;printsep("|",f(a));
? a=10;f(t)=t^2;printsep("|",f(a))
%2 = (t)->t^2;printsep("|",f(a))
```
  Donc le problème n’est peut-être pas wims !
```
? a=10;f(t)=t^2;printsep("|",f(a))
%5 = (t)->t^2;printsep("|",f(a))
? f(a)
  ***   [...] at: t^2;printsep("|",f(a))
  ***                              ^-----
  ***   in function f: t^2;printsep("|",f(a))
  ***                                   ^-----
  ***   in function f: t^2;printsep("|",f(a))
  ***                                   ^-----
  ***   in function f: t^2;printsep("|",f(a))
```
```
? a=10;f(t)=t^2;
? printsep("|",f(a))
100
```
  Ta fonction f contient le printsep.
  Cela explique qu’en le faisant en deux fois, ta fonction f contient ce qu’il faut et pas le printsep.
  
  a=10;f=(t->t^2);printsep("|",f(a))
  
  fonctionnera (mais là le printsep ne sert à rien ?).
Auteur

Messages