!set titb=Utilisation de logiciels
!set keyw=
!set datm=20050625
!set prev=
!set next=
!set upbl=main
!set dat1=19000101
!set dat2=24000101


!if $wims_read_parm!=$empty
 !goto $wims_read_parm
!endif
!exit

:content

!read primitives.phtml 1, 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 

!read primitives.phtml 2, tool, module=tool/directexec 
. 
<p>
<h4>Comment appeler le logiciel</h4>
De manière générale, on appelle un logiciel 
en utilisant la commande $m_exec
à travers <tt class="c">$m_wims</tt>
<pre class="c">
$m_text$m_lbrac a = $m_wims($m_exec povray ...) $m_rbrac
$m_text$m_lbrac a = $m_wims($m_exec octave ...) $m_rbrac </pre>
Ce qui remplace ... sont des commandes du logiciel. 
<p>
Il y a deux cas particuliers &#58; <tt class="c">$m_pari</tt>  et <tt class="c">$m_maxima</tt>.
<pre class="c">
$m_text$m_lbrac a = $m_pari( ...) $m_rbrac
$m_text$m_lbrac a = $m_maxima(....) $m_rbrac </pre>
<p>
<h4> Maxima &#58; </h4>
<a href="http&#58;//michel.gosse.free.fr/index.html"  target=wims_external>Documentation Maxima</a>
<p>
<div class="exemple"><pre class="c">
$m_text$m_lbrac f = sin(x)/x^3 $m_rbrac
$m_text$m_lbrac f = $m_maxima($m_diff(\f,x,2)) $m_rbrac </pre>

!set m_f=sin(x)/x^3



!set tmp=!translate ;";': to $     $ in $m_f,x,2

!set tmp=!lower $tmp
!set tmp0=!exec maxima diff($tmp);
!set t_=!replace internal \( by ( in $(tmp0)
!set tmp1=!exec maxima $t_

!set m_f=$(tmp1)


</div>
<h4> Octave &#58; </h4>
<p>
<a href="http&#58;//www.gnu.org/software/octave/doc/interpreter/" target=wims_external>Documentation Octave</a>
<p>
<div class="exemple">
<pre class="c">
$m_real$m_lbrac a = $m_randint(1<tt class="w">..</tt>10)/10 $m_rbrac
$m_text$m_lbrac fonct = 2*t*x $m_rbrac
$m_text$m_lbrac reponse = $m_wims($m_exec octave 
  function 
   xdot=f(x,t) 
   xdot=\fonct; 
  endfunction; 
  lsode("f",1,(t=[0,\a])) $m_rbrac </pre>

!set m_a=$[$m_randint(1..10)/10]


!set m_fonct=2*t*x



!set tmp0=!exec octave 	   function 	   xdot=f(x,t) 	   xdot=$m_fonct; 	  endfunction; 	  lsode("f",1,(t=[0,$m_a]))

!set m_reponse=$(tmp0)


<p>
$m_reponse
<p>
<h4>GP/PARI &#58; </h4>
<a href="http&#58;//pari.math.u-bordeaux.fr/dochtml/html.stable/" target=wims_external>Documentation GP/Pari</a>
<p>
<div class="exemple"> <pre class="c">
$m_integer$m_lbrac n = $m_randint (20<tt class="w">..</tt>23) $m_rbrac
$m_text$m_lbrac N = $m_pari(factor(\n&#33;+1)) $m_rbrac </pre>

!set tmp0=!randint 20, 23

!set m_n=$(tmp0)



!set t_=!replace internal \( by ( in factor($m_n!+1)
!set tmp0=!exec pari $t_

!set m_N=$(tmp0)


factor($m_n&#33;+1) = $m_N
</div> 
<p> 

!read primitives.phtml 3, 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.
<p>
Pour plus de détails &#58; 
!read primitives.phtml 4, link, pari 
.
<p>
<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 &#58; 
<pre class="c">
$m_text$m_lbrac essai_pari = $m_pari( (f(x) = local(t) ; t=x^2 ; t)) $m_rbrac
$m_text$m_lbrac data_pari = $m_pari(a = 2 ; M = 3)
$m_integer$m_lbrac n = $m_randint(2<tt class="w">..</tt>8) $m_rbrac
$m_text$m_lbrac f1 = $m_pari(f(\n)) $m_rbrac
$m_text$m_lbrac f2 = $m_pari(f(M)) $m_rbrac
$m_text$m_lbrac a = $m_pari(a) $m_rbrac
$m_text$m_lbrac b = \a^2 $m_rbrac
$m_text$m_lbrac c = $m_pari(a^2) $m_rbrac </pre>

!set t_=!replace internal \( by ( in  (f(x) = local(t) ; t=x^2 ; t)
!set tmp0=!exec pari $t_

!set m_essai_pari=$(tmp0)



!set t_=!replace internal \( by ( in a = 2 ; M = 3
!set tmp0=!exec pari $t_

!set m_data_pari=$(tmp0)



!set tmp0=!randint 2, 8

!set m_n=$[rint($(tmp0))]


!set t_=!replace internal \( by ( in f($m_n)
!set tmp0=!exec pari $t_

!set m_f1=$(tmp0)



!set t_=!replace internal \( by ( in f(M)
!set tmp0=!exec pari $t_

!set m_f2=$(tmp0)



!set t_=!replace internal \( by ( in a
!set tmp0=!exec pari $t_

!set m_a=$(tmp0)



!set m_b=$m_a^2



!set t_=!replace internal \( by ( in a^2
!set tmp0=!exec pari $t_

!set m_c=$(tmp0)


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. 
<p>
Résultats &#58; 
essai_pari= $m_essai_pari ; f1 = $m_f1 ;  f2 = $m_f2 ; a = $m_a ; b = $m_b ; 
c = $m_c ; M = $m_M ; f = $m_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. 
<p>
Voir des exemples dans 
!read primitives.phtml 5, link, pari 

<p>
<h4>Quelques paramètres par défaut</h4>
WIMS &#58; 
<pre class="c">
    precision=10000, print_precision=8
</pre>
PARI/GP &#58; 
<pre class="c">
    pari_precision=18
</pre>
<p>
Maxima &#58; 
<pre class="c">
    maxima_precision=print_precision
    expon&#58;0; expop&#58;0; factlim&#58;6; prederror&#58; false;
    maxnegex&#58;20; maxposex&#58;20; ratfac&#58;true; keepfloat&#58;true;
</pre>
<p>
<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. 
<p>
Celui qu'on rencontre en premier est le problème 
des matrices &#58; 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 &#58;

!set m_A=[1,2,3;4,5,6]



!set tmp0=!exec octave [1,2,3;4,5,6]

!set m_Aoct=$(tmp0)



!set tmp0=!exec octave [1,2,3;4,5,6]

!set tmp=!trim $(tmp0) 
!set m_Aoct2=!translate internal $	$ to ; in $tmp


!set t_=!replace internal \( by ( in  [1,2,3;4,5,6]
!set tmp0=!exec pari $t_

!set m_Apari=$(tmp0)


<pre class="c">
$m_text$m_lbrac A = [1,2,3;4,5,6] $m_rbrac
$m_text$m_lbrac Aoct = $m_wims(exec octave [1,2,3;4,5,6]) $m_rbrac
$m_matrix$m_lbrac Aoct2 = $m_wims(exec octave [1,2,3;4,5,6]) $m_rbrac
$m_text$m_lbrac Apari = $m_pari( [1,2,3;4,5,6]) $m_rbrac </pre>
<pre class="d">
Aoct  = $m_Aoct 
Aoct2 = $m_Aoct2
Apari = $m_Apari
</pre>
<p>
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). 
<p>

!readproc slib/text/octavematrix $m_Aoct 
!set tmp0=$slib_out
!set m_Boct=$(tmp0)


<pre class="c">
$m_text$m_lbrac Boct = $m_slib(text/octavematrix \Aoct) $m_rbrac </pre>
<pre class="d">
Boct = $m_Boct
</pre>
<p>
Autre exemple &#58; 

!set tmp0=!exec octave	[5^2 *4 + 5,2,3;5,6,7]

!set m_matrice=$(tmp0)



!readproc slib/text/octavematrix $m_matrice 
!set tmp0=$slib_out
!set m_matrice=$(tmp0)


<pre class="c">
$m_text$m_lbrac matrice = $m_wims($m_exec octave
[5^2 *4 + 5,2,3;5,6,7]) $m_rbrac
$m_text$m_lbrac matrice = $m_slib(text/octavematrix $m_matrice) $m_rbrac </pre>
<pre class="d">matrice = $m_matrice</pre>

