\embed{definition}{&nbsp;}Nous ne parlons ici que de l'utilisation d'un logiciel dans 
un exercice OEF, bien qu'il en soit de même (souvent plus simple)
dans un module WIMS. Si vous ne disposez pas de ces logiciels,
vous pouvez les utiliser et faire vos tests à travers 
\tool{module=tool/directexec}. 



<h4>Comment appeler le logiciel</h4>
De manière générale, on appelle un logiciel 
en utilisant la commande \exec
à travers <tt class="c">\wims</tt>
<pre class="c">
\text\lbrac a = \wims(\exec povray ...) \rbrac
\text\lbrac a = \wims(\exec octave ...) \rbrac </pre>
Ce qui remplace ... sont des commandes du logiciel. 

Il y a deux cas particuliers : <tt class="c">\pari</tt>  et <tt class="c">\maxima</tt>.
<pre class="c">
\text\lbrac a = \pari( ...) \rbrac
\text\lbrac a = \maxima(....) \rbrac </pre>


<h4> Maxima : </h4>
<a href="http://michel.gosse.free.fr/index.html"  target=wims_external>Documentation Maxima</a>

<div class="exemple"><pre class="c">
\text\lbrac f = sin(x)/x^3 \rbrac
\text\lbrac f = \maxima(\diff(\\f,x,2)) \rbrac </pre>
\def{text f = sin(x)/x^3}
\def{text f = maxima(diff(\f,x,2))}
</div>
<h4> Octave : </h4>

<a href="http://www.gnu.org/software/octave/doc/interpreter/" target=wims_external>Documentation Octave</a>

<div class="exemple">
<pre class="c">
\real\lbrac a = \randint(1<tt class="w">..</tt>10)/10 \rbrac
\text\lbrac fonct = 2*t*x \rbrac
\text\lbrac reponse = \wims(\exec octave 
  function 
   xdot=f(x,t) 
   xdot=\\fonct; 
  endfunction; 
  lsode("f",1,(t=[0,\\a])) \rbrac </pre>
\def{real a = \randint(1..10)/10}
\def{text fonct = 2*t*x}
\def{text reponse = wims(exec octave 
   function 
   xdot=f(x,t) 
   xdot=\fonct; 
  endfunction; 
  lsode("f",1,(t=[0,\a])))}

\reponse

<h4>GP/PARI : </h4>
<a href="http://pari.math.u-bordeaux.fr/dochtml/html.stable/" target=wims_external>Documentation GP/Pari</a>

<div class="exemple"> <pre class="c">
\integer\lbrac n = \randint (20<tt class="w">..</tt>23) \rbrac
\text\lbrac N = \pari(factor(\\n!+1)) \rbrac </pre>
\def{text n = randint (20..23)}
\def{text N = pari(factor(\n!+1))}
factor(\n!+1) = \N
</div> 
<p> 
\link{matrice}{<img src="gifs/doc/ddroite.gif" alt="exemple" width="20" height="20" border=0 valign=bottom>} Base de l'image d'une application linéaire.

Pour plus de détails : \link{pari}.


<h4>Réutiliser des commandes</h4>
Dans un module OEF,
le logiciel reste ouvert entre deux exécutions 
et l'on peut donc garder des routines ou des variables "ouvertes".
Un exemple : 
<pre class="c">
\text\lbrac essai_pari = \pari( (f(x) = local(t) ; t=x^2 ; t)) \rbrac
\text\lbrac data_pari = \pari(a = 2 ; M = 3)
\integer\lbrac n = \randint(2<tt class="w">..</tt>8) \rbrac
\text\lbrac f1 = \pari(f(\\n)) \rbrac
\text\lbrac f2 = \pari(f(M)) \rbrac
\text\lbrac a = \pari(a) \rbrac
\text\lbrac b = \\a^2 \rbrac
\text\lbrac c = \pari(a^2) \rbrac </pre>
\def{text essai_pari = pari( (f(x) = local(t) ; t=x^2 ; t))}
\def{text data_pari = pari(a = 2 ; M = 3)}
\def{integer n = randint(2..8)}
\def{text f1 = pari(f(\n))}
\def{text f2 = pari(f(M))}
\def{text a = pari(a)}
\def{text b = \a^2}
\def{text c = pari(a^2)}
Ici, <tt class="c">\\n</tt> appelle une variable définie par wims, 
<tt class="c">M</tt> un entier défini dans Pari/GP et appelé par Pari/GP, 
<tt class="c">a</tt> est à la fois une variable de WIMS et de Pari/GP
et donc on l'appelle par <tt class="c">\\a</tt> dans WIMS et par 
<tt class="c">a</tt> dans GP/Pari. 

Résultats : 
essai_pari= \essai_pari ; f1 = \f1 ;  f2 = \f2 ; a = \a ; b = \b ; 
c = \c ; M = \M ; f = \f .
 
<h4>Utilisation de programmes internes aux logiciels de calcul</h4>
Il est possible d'entrer des programmes dans le langage des logiciels appelés et de les réutiliser ensuite. 

Voir des exemples dans \link{pari}


<h4>Quelques paramètres par défaut</h4>
WIMS : 
<pre class="c">
    precision=10000, print_precision=8
</pre>
PARI/GP : 
<pre class="c">
    pari_precision=18
</pre>

Maxima : 
<pre class="c">
    maxima_precision=print_precision
    expon:0; expop:0; factlim:6; prederror: false;
    maxnegex:20; maxposex:20; ratfac:true; keepfloat:true;
</pre>


<h4>Quelques difficultés pouvant être rencontrées</h4>
Chaque logiciel a sa manière de prendre les données et 
de les ressortir. WIMS essaie dans la mesure du possible 
de passer de l'un à l'autre. Il y a quand même quelques petits 
problèmes. 

Celui qu'on rencontre en premier est le problème 
des matrices : Une matrice dans GP/Pari ou Octave est de la forme
<tt class="c">[1,2,3;1,4,5]</tt>. GP/Pari renvoie une matrice sous 
la même forme, mais pas Octave. Et de toute façon, WIMS enlève les 
crochets de la matrice :
\def{text A=[1,2,3;4,5,6]}
\def{text Aoct=wims(exec octave [1,2,3;4,5,6])}
\def{matrix Aoct2=wims(exec octave [1,2,3;4,5,6])}
\def{text Apari=pari( [1,2,3;4,5,6])}
<pre class="c">
\text\lbrac A = [1,2,3;4,5,6] \rbrac
\text\lbrac Aoct = \wims(exec octave [1,2,3;4,5,6]) \rbrac
\matrix\lbrac Aoct2 = \wims(exec octave [1,2,3;4,5,6]) \rbrac
\text\lbrac Apari = \pari( [1,2,3;4,5,6]) \rbrac </pre>
<pre class="d">
Aoct  = \Aoct 
Aoct2 = \Aoct2
Apari = \Apari
</pre>

Octave passe des lignes et  <tt class="d">Aoct</tt>
est formé de lignes et les éléments d'une ligne 
sont séparés par des espaces. On peut utiliser un slib
pour la remettre sous forme "normalisée" (sans crochets quand
même). 

\def{text Boct = slib(text/octavematrix \Aoct)}
<pre class="c">
\text\lbrac Boct = \slib(text/octavematrix \\Aoct) \rbrac </pre>
<pre class="d">
Boct = \Boct
</pre>


Autre exemple : 
\def{text matrice = wims(exec octave
[5^2 *4 + 5,2,3;5,6,7])}
\def{text matrice = slib(text/octavematrix \matrice)}
<pre class="c">
\text\lbrac matrice = \wims(\exec octave
[5^2 *4 + 5,2,3;5,6,7]) \rbrac
\text\lbrac matrice = \slib(text/octavematrix \matrice) \rbrac </pre>
<pre class="d">matrice = \matrice</pre>
