\embed{definition}{&nbsp;}Nous ne parlons ici que de l'utilisation d'un logiciel dans 
un exercice OEF, bien qu'il en soit de mme (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 manire gnrale, 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 linaire.

Pour plus de dtails : \link{pari}.


<h4>Rutiliser des commandes</h4>
Dans un module OEF,
le logiciel reste ouvert entre deux excutions 
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 dfinie par wims, 
<tt class="c">M</tt> un entier dfini 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. 

Rsultats : 
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 appels et de les rutiliser ensuite. 

Voir des exemples dans \link{pari}


<h4>Quelques paramtres par dfaut</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 difficults pouvant tre rencontres</h4>
Chaque logiciel a sa manire de prendre les donnes et 
de les ressortir. WIMS essaie dans la mesure du possible 
de passer de l'un  l'autre. Il y a quand mme quelques petits 
problmes. 

Celui qu'on rencontre en premier est le problme 
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 mme forme, mais pas Octave. Et de toute faon, WIMS enlve 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 lments d'une ligne 
sont spars par des espaces. On peut utiliser un slib
pour la remettre sous forme "normalise" (sans crochets quand
mme). 

\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>
