home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser-CD 2000 January / LCD_01_2000.iso / anwend / mathari / mathari.doc next >
Encoding:
Text File  |  1998-05-01  |  19.4 KB  |  459 lines
  1.             Mathari : des 'maths' sur ATARI !!
  2.             --------------------------------
  3.                 by The Removers .
  4.  
  5.  
  6. ( Compatible STF/STacy/STE/TT/Falcon 030/MEDUSA/MILAN/HADES/Magic )
  7. ( Testé    sur : - ATARI 1040 STF
  8.               - STacy 1 Mo/20 Mo
  9.               - Falcon 030
  10.               - Falcon 030 + CenTurbo 1
  11.               - Falcon 030 + Nemesis
  12.               - Falcon 030 + AfterBurner 040 [ + Nemesis ] = Falcon 040
  13.               - PC avec la démo de MagicPC
  14.                               avec succès à chaque fois !!! )
  15. ( Matériel conseillé : 
  16. machine avec processeur rapide pour calculer rapidement !!
  17. ( un Falcon 040  ou un Hadès étant l'idéal ;-)))))) )
  18. NVDI quasi-indispensable ( surtout sur machines lentes !! )
  19. Les flags sont configurés prêts à l'emploi ...
  20. Notez que la présence d'un copro est détecté au démarrage pour
  21. ceux qui en possèdent un ( conseillé mais non obligatoire ! )  )
  22.  
  23.         
  24. La renaissance de Mathari
  25. -------------------------
  26.     Mathari est né le jour où j'ai voulu me faire des belles fiches 
  27. pour réviser mes colles de maths portant entre autres sur les fonctions 
  28. circulaires réciproques ( Arcsin, Arccos et Arctan ) . Alors, je me suis 
  29. dit : il faudrait avoir un logiciel permettant de tracer n'importe quelle
  30. fonction et ensuite permettant de la sauver comme image . Et puis, 
  31. évidemment, un tel logiciel, à ma connaissance n'existe pas sur ATARI .
  32. Donc j'ai commencé à écrire un petit programme capable de tracer beaucoup
  33. de fonctions ne contenant que des produits et n'importe quelle fonction
  34. usuelle : en effet, les sommes me posait des petits problèmes ( priorité 
  35. de * par rapport à + ) . Cela ne pouvait donc me satisfaire . J'ai donc 
  36. réfléchi un lundi matin en cours de f......s ( à vous de deviner sachant 
  37. que j'étais en MPSI et maintenant en MP* ) à une procédure permettant 
  38. d'analyser une expression mathématique aussi compliqué soit elle et de
  39. la comprendre, ie pour ceux qui n'aurait pas tout compris :
  40. analyser une expression du type :    arcsin(√((1+sin(x))/2))
  41. et puis évidemment, après quelques instants de réflexion intense, j'ai 
  42. trouvé la solution ( du moins en partie parce que ce n'est pas si facile 
  43. que cela ) . Le soir même ( ou bien le lendemain ), j'écrivais donc LA
  44. fonction 'evaluate' qui marchait bien et même très bien . Et puis j'ai 
  45. donc voulu aller plus loin et faire un grapheur utilisant évidemment cette 
  46. fonction : ainsi naquit Mathari v 1.00ß . En fait Mathari existait déjà 
  47. car c'est Stabylo qui le premier a commencé à essayer de faire faire des 
  48. maths à son ATARI ( calcul de factorielles jusqu'à 5000! voire plus ) . 
  49. J'ai donc repiqué le nom mais du même coup, Mathari est devenu un projet 
  50. commun donc si il a envie de prendre la parole au cours de cette doc ou de 
  51. rajouter des fonctions à Mathari, qu'il le fasse !! ( ok, en spé il n'a pas 
  52. trop le temps de programmer, et alors ??? cependant, maintenant que je suis
  53. en spé moi aussi je n'ai plus trop le temps ) De toute façon, même si 
  54. Stabylo n'a pas réellement programmé Mathari, il m'a donné des idées et 
  55. des solutions aux problèmes que je rencontrais donc il a bien participé à 
  56. la réalisation de Mathari .
  57.                                                              
  58. Comprendre Mathari pour ne pas faire d'erreurs
  59. ----------------------------------------------
  60.     Mathari n'est pas à l'abri d'une erreur . Normalement, la fonction 
  61. 'evaluate' est prévu pour analyser et comprendre n'importe quelle 
  62. expression mathématique aussi compliquée que l'on veut mais cette fonction 
  63. n'est peut être pas parfaite ( disons que c'est pas facile à débugguer 
  64. étant donné qu'il y a une infinité d'expressions mathématiques possibles 
  65. et que j'aurais plutot tendance à ne pas toutes les essayer ... ) mais 
  66. normalement cela marche très bien .
  67.     Mathari connait les 4 opérations usuelles dans R : +,-,*,/
  68. (R,+,*) est un corps ainsi + et * sont associatives, commutatives, admettent
  69. comme neutre respectivement 0 et 1 .
  70. Pour tout xεR , x admet un unique symétrique pour + : -x
  71. Pour tout xεR\{0}, x admet un unique symétrique pour * : 1/x
  72. '-' et '/' ne sont ni associatives ni commutatives :
  73. en effet 1/2<>2/1 , (1/2)/3<>1/(2/3) , 1-2<>2-1 , (1-2)-3<>1-(2-3)
  74. A noter que les premières versions de Mathari se plantait totalement lors 
  75. de l'évaluation de 1-2-3 qui renvoyaient bêtement 0 à la place de -4 .
  76. De même pour / .
  77. Attention : des expressions du type 2*-3 n'ont aucun sens en mathématiques
  78. donc pour Mathari, la formule correcte étant 2*(-3) ( ou plus simplement
  79. par commutativité -3*2 !! )
  80.     Mathari connait quand même autre chose que cela :
  81.         - π ou Pi ou pi ou PI : π !!
  82.         - e ou E : exp(1)=e
  83.         - j : exp(2*i*π/3) ( 1+j+j²=0 )
  84.         - ½ : 1/2
  85.         - ¼ : 1/4
  86.         - √ : renvoie la racine carré d'un nombre positif
  87.         - ^ : élève à la puissance un nombre positif strictement .
  88.         cependant si l'exposant est un entier relatif, ^ est
  89.         prolongé sur R, privé de 0 si l'exposant est négatif .
  90.         si l'exposant s'écrit 1/n avec nεN, n impair, ^ est 
  91.         prolongé sur R .
  92.         sinon ^ est prolongé sur R+ .
  93.         - et la plupart des fonctions usuelles :
  94.             sqrt : racine carré ( n'est pas la même que √ )
  95.             abs : valeur absolue
  96.             exp
  97.             ln
  98.             log : logarithme décimal
  99.             log2 : logarithme en base 2
  100.             sin
  101.             cos
  102.             tan
  103.             cotan
  104.             sh
  105.             ch
  106.             th
  107.             coth
  108.             Arcsin
  109.             Arccos
  110.             Arctan
  111.             Argsh
  112.             Argch
  113.             Argth
  114.             inv : inverse
  115.             E : partie entière à ne pas confondre avec exp ou e
  116.             Γ : pour l'instant, n'existe que pour les réels 
  117.             ( non entiers négatifs bien sur ).
  118.             Attention, pour coincider avec factorielle pour 
  119.             les entiers, j'ai translaté volontairement Γ d'une 
  120.             unité... Si cela gêne trop de gens, je suis près à 
  121.             changer cela !!!
  122.             ( pour ceux qui ne le sauraient pas :
  123.                      ⌠+▀
  124.                 Γ(x)=|exp(-t)*t^(x-1).dt, x>0
  125.                      ⌡0
  126.                     =lim n^x*n!/(x*(x+1)*...*(x+n)), [n->+▀] 
  127.                                                     xεR\(-N)
  128.             )
  129.             Remarque pour sqrt et √ : le symbole √ ( ainsi que ^ ) est
  130.         reconnu par Mathari comme un opérateur 'au même titre que
  131.         les 4 opérateurs traditionnels +,-,*,/' alors que sqrt est 
  132.         reconnu par Mathari comme une fonction usuelle : cela a 
  133.         son importance pour la suite ...
  134.     Mais jusque là, Mathari n'est pas vraiment d'un grand intérêt car 
  135. il ne fait pas mieux qu'une bête calculatrice ...
  136.     Mathari peut donc être enrichi avec des fonctions utilisateurs .
  137.     Toujours rien de vraiment foudroyant par rapport à une 
  138. calculatrice, me direz-vous .
  139.     En effet, cependant lorsque vous aurez lu ce qui suit, vous ne 
  140. direz plus la même chose .
  141.     Mathari peut composer des applications . Le symbole 'ronde' 
  142. n'existant pas dans les caractères ASCII, Mathari utilise le symbole @
  143. ( utilisé également par Maple ) .
  144.     Imaginez que vous ayez à étudier f@f où f est défini par :
  145.         f: R  -> R
  146.            x |-> x^2+1
  147.     Mathari vous offre trois solutions :
  148.         1) développer bêtement f@f,
  149.         ainsi pour tout xεR, f@f(x)=x^4+2*x^2+2
  150.         vous pouvez alors demander à Mathari de tracer cette 
  151.         fonction polynomiale 
  152.         2) créer une fonction utilisateur f telle que pour tout 
  153.         xεR, f(x)=x^2+1 puis demander à Mathari de tracer f@f(x)
  154.         3) demander directement à Mathari de tracer l'expression
  155.         (x^2+1)@(x^2+1)    
  156.     La troisième solution étant la plus rapide pour vous mais 
  157. également pour Mathari .
  158.  
  159. Exemples
  160. --------
  161. Tracer l'identité :
  162.     Demandez à Mathari de tracer :
  163.         x
  164.         x@x
  165.         x@...@x
  166. Tracer la fonction usuelle sin(x) :
  167.     Demandez à Mathari de tracer :
  168.         sin(x)
  169.         sin@x
  170.         x@sin@x
  171.         x@...@sin@x@...@x
  172. Tracer la fonction Arcsin(√((1+sin(x))/2))
  173.     Demandez à Mathari de tracer :
  174.         arcsin(√((1+sin(x))/2))
  175.         arcsin@sqrt((1+sin(x))/2)
  176.         arcsin@sqrt@((1+x)/2)@sin(x)
  177.         arcsin@(√x)@((1+x)/2)@sin@x
  178.  
  179. Okay, ca ne vous suffit pas : vous ne trouvez pas ça assez fort ???
  180. Tout d'abord, je parie qu'il y a plein de personnes qui ont déjà arrêté
  181. de lire pour essayer ces fonctions sur Mathari : et évidemment, l'effet 
  182. Bonaldi a fait que cela n'a pas marché ( bien fait, ils n'avaient qu'à 
  183. lire la doc jusqu'au bout !!! )
  184. Pourquoi cela n'a-t-il pas fonctionné ??
  185. Parce que Mathari ne sait tracer que des fonctions à valeurs complexes !!
  186. En effet, j'ai oublié de mentionner que Mathari connaissait i ( tel que 
  187. i²=-1 ) . Pour travailler avec, il suffit de taper i ( dingue !! )
  188. Mathari connait donc logiquement quelques fonctions de plus :
  189.             Re  : partie réelle
  190.             Im  : partie imaginaire
  191.             Arg : renvoie l'argument principal du complexe
  192.             ( si différent de 0 )
  193. A noter :
  194. 1) ABS ne renvoie pas la valeur absolue mais le module ( ce qui est 
  195. la même chose pour les réels )
  196. 2) E renvoie la partie entière de la partie réelle d'un complexe + i fois
  197. la partie entière de la partie imaginaire du complexe
  198. 3) Γ travaille pour l'instant uniquement avec la partie réelle d'un complexe
  199. ( ce qui implique que Γ(<imaginaire pur>)=Γ(0)=1 )
  200. Mathari trace la partie réelle en abscisse et la partie imaginaire en 
  201. ordonnée ; donc pour tracer la fonction f: R  -> R    il faut indiquer à 
  202.                                            t |-> f(t)
  203. Mathari de tracer la fonction : t+i*f(t) 
  204. ( Au fait, Mathari utilise t pour le nom de la variable pour ne pas faire 
  205. de confusions avec les abscisses )
  206. Ainsi vous pouvez évidemment tracer des fonctions à valeurs réelles .
  207. Mais, plus fort, vous pouvez également tracer des paramétriques en mettant
  208. l'équation pour les abscisses en partie réelle et l'équation pour les 
  209. ordonnées en partie imaginaire .
  210.     ex : pour tracer :
  211.         x: R  -> R
  212.            t |-> x(t)
  213.         y: R  -> R
  214.            t |->y(t)
  215. indiquez à Mathari l'expression : x(t)+i*y(t)
  216. Vous pouvez aussi tracer des fonctions polaires en multipliant par 
  217. l'exponentielle complexe d'un imaginaire pur ( ce qui revient à projeter
  218. sur les axes ) .
  219.     ex : pour tracer :
  220.         r: R  -> R
  221.            t |-> r(t)
  222. indiquez à Mathari l'expression : r(t)*exp(i*t)
  223.  
  224.     Je crois qu'à partir de ce point votre calculatrice commence à ne
  225. plus suivre mais attendez, vous n'avez pas tout vu :
  226.     Vous pouvez définir des fonctions par intervalle à l'aide des 
  227. opérateurs de comparaison et des opérateurs logiques .
  228.     Aucune relation d'ordre n'existant sur C, Mathari, lors de la 
  229. comparaison de 2 complexes donne priorité à la partie réelle ( simili 
  230. ordre lexicographique )
  231.     Attention 'inférieur ou égal' n'est pas noté <= ou =< ( comme dans
  232. beaucoup de logiciels ) mais tout simplement ≤ ( ASC 243 ) .
  233.     idem pour 'supérieur ou égal' : ≥ ( ASC 242 ) .
  234.     'égal' est noté = ( et non pas == comme en C ) .
  235.     Les opérateurs logiques sont :
  236.         & : AND
  237.         | : OR
  238.         ¬ : NOT ( ASC 170 )
  239.     La valeur de VRAI ( TRUE en Anglais ) est 1 ( pour Mathari ) .
  240.     La valeur de FAUX ( FALSE --------- ) est 0 .
  241.     Il suffit donc de multiplier par une condition pour annuler ou non 
  242. un terme .
  243.     ex : 
  244. entrez l'expression suivante :
  245.     t+i*t*(t≥0)-i*t*(t<0)
  246. vous reconnaitrez ainsi la fonction valeur absolue .
  247.  
  248. D'autres fonctions reconnues par Mathari :
  249.         - Re : renvoie partie réelle du complexe
  250.         - Im : ---------------imaginaire -------
  251.         - Arg : renvoie l'argument principal du complexe
  252.         - Rand : renvoie un nombre entier aléatoire
  253.         - Random : presque pareil ( mais plus lent )
  254.         - A : nombre d'arrangements  , syntaxe : A(n+i*p) ( p≤n )
  255.         - C : nombre de combinaisons , syntaxe : C(n+i*p) ( p≤n )
  256.         - pgcd : calcule pgcd(a,b)   , syntaxe : pgcd(a+i*b)
  257.         - ppcm : calcule ppcm(a,b)   , syntaxe : ppcm(a+i*b)
  258.         - sinc : sinus cardinal   ( ie x|->sin(x)/x )
  259.         - csgn : signe complexe
  260.             Si zεC, csgn(z) renvoie :
  261.               * 1  si Re(z)>0 ou (Re(z)=0 et Im(z)>0)
  262.               * 0  si z=0
  263.               * -1 sinon
  264.         - min : min(z) renvoie min(re(z),im(z)) pour zεC
  265.         - max : max(z) renvoie max(re(z),im(z)) pour zεC
  266.         - sort: sort(z) renvoie min(z)+i*max(z) pour zεC
  267.         ( où min et max sont les fonctions définies juste 
  268.         ci-dessus )
  269.         - div : div(z) renvoie le quotient de la division 
  270.         euclidienne de re(z) par im(z) quand zεZ+i(Z\{0})
  271.         - mod : mod(z) renvoie le reste de la division 
  272.         euclidienne de re(z) par im(z) quand zεZ+i(Z\{0})
  273.         - ediv : ediv(z) renvoie div(z)+i*mod(z) pour zεZ+i(Z\{0})
  274.         ( où div et mod sont les fonctions définies juste 
  275.         ci-dessus )
  276.  
  277. Mathari peut aussi travailler avec des constantes utilisateurs ( ie 'des 
  278. lettres prenant la valeur complexe que vous souhaitez' : par exemple, vous 
  279. avez à étudier une famille de fonctions dépendant d'un paramètre a
  280.     par exemple :     f:|->a*x²    ( genre exemple bateau on ne fait 
  281.                     pas mieux )
  282. plutot que de changer 'manuellement' la valeur de a vous pouvez très bien 
  283. créer une constante 'a' ( avec a:=NEW ) puis travailler avec des 
  284. expressions contenant la lettre 'a', vous pourrez étudiez le comportement 
  285. de ces expressions suivant la valeur de 'a' en faisant a:<nouvelle valeur> )
  286. Et donc, vous l'avez très bien compris, l'opérateur d'affectation d'une 
  287. constante est donc ':' ( cet opérateur ne détruit pas la valeur sur la 
  288. pile mais assigne cette valeur à la variable dont le nom se trouve à 
  289. gauche de l'opérateur )
  290.     exemple :
  291.         a:=NEW        ( pour créer 'a' )
  292.         2*(a:10)    renvoie 20 : en effet, cette instruction 
  293.         assigne à 'a' la valeur 10 puis effectue la multiplication 
  294.         2*a ( où a=10 ) ce qui fait bien 20 .
  295. Notez bien que des expressions du type :
  296.         a:b:c:d:2713
  297. ont un sens pour Mathari ( ce qui le rapproche du C ) . Ainsi Mathari
  298. met 2713 dans d, puis d dans c, puis c dans b et enfin b dans a ; a valant
  299. finalement 2713 !!!
  300.  
  301. Ne trouvez-vous pas que Mathari commence à ne plus être ridicule ???!!!!
  302. Moi, en tout cas, j'en suis convaincu ; d'ailleurs j'ai un exemple pour 
  303. vous le prouver :
  304.     Tapez
  305.         connect:0    ; Tracé discontinu
  306.         point:5000    ; 5000 points
  307.         xmin:ymin:-10    ; intervalle
  308.         xmax:ymax:10    ; visible
  309.         x1:=NEW        ; on crée quelques 'constantes'
  310.         x2:=NEW        ;
  311.         x3:=NEW        ;
  312.         y1:=NEW        ;
  313.         y2:=NEW        ;
  314.         y3:=NEW        ;
  315.         x:=NEW        ;
  316.         y:=NEW        ;
  317.         n:=NEW        ;
  318.         x1:0        ; puis on les
  319.         y1:x3:2        ; initialise
  320.         x2:y2:y3:-2    ; ( cool ! )
  321.         plot        ; on va dans le grapheur
  322.         (x:½*(x+x1*((n:rand(3))=1)+x2*(n=2)+x3*(n=3)))+i*(y:½*(y+
  323.            y1*(n=1)+y2*(n=2)+y3*(n=3)))
  324.         patientez quelques minutes et admirez ... le triangle de 
  325.         Sierpinski !!!
  326.     Petite question : votre calculatrice peut-elle le  faire en si peu
  327.     d'instructions ?? ;-)
  328.         
  329. Programmation de Mathari
  330. ------------------------
  331. Attention à tous les matheux, ce qui suit peut nuire gravement à votre 
  332. santé mentale ( disons que c'est plus de la bidouille que des maths ! )
  333.  
  334. Tout d'abord, pour programmer il faut des variables à manipuler : comme je 
  335. l'ai dit plus haut Mathari autorise l'utilisation simultanée de 26 
  336. variables complexes.
  337. Pour en créer une, il faut taper :
  338.                     <nom de la variable>:=NEW
  339. Pour en effacer une, il faut taper :
  340.                     <nom de la variable>:=NULL
  341. A noter que ces instructions ne sont pas reconnus par EVALUATE mais par 
  342. l'éditeur lui-même, elles ne peuvent donc être utilisées au milieu d'une 
  343. expression à évaluer !!
  344.                 
  345. Ensuite, il faut avoir des boucles : MATHARI ne dispose que des boucles 
  346. FOR-NEXT :
  347. ce texte en Basic :
  348.             FOR i=<debut> to <fin> STEP 1
  349.               { corps de la boucle }
  350.             NEXT i
  351. se traduit en Mathari par :
  352.             (<debut>+i*<fin>)$(<corps de la boucle>)
  353. ATTENTION : MATHARI prend en fait la partie réelle présente sur la pile 
  354. pour indice de début et la partie imaginaire pour indice de fin : MATHARI 
  355. compare alors les deux valeurs et les réordonne si elles sont inversées de 
  356. manière à avoir des boucles 'croissantes'.
  357. A noter que début et fin sont des entiers naturels et le pas de la boucle 
  358. est 1.
  359. REMARQUE : on peut récupérer l'indice de boucle en écrivant : ▌ .
  360. En fait ▌ représente le compteur de la boucle en cours ...
  361. ATTENTION : il n'est pas possible de faire varier les indices de début et 
  362. de fin en cours de boucle ( ni même le compteur de boucle ) ie on ne peut 
  363. pas faire de EXIT IF ... ou BREAK !!
  364.  
  365. Il faut pouvoir faire des tests !
  366. Les symboles de test sont : <,>,=,≤,≥
  367. Les tests renvoie un booléen : TRUE = 1, FALSE = 0
  368.  
  369. Il faut pouvoir affecter les variables :
  370. La syntaxe est :
  371.                     <nom de la variable>:<valeur>
  372.                     
  373. Il faut pouvoir combiner des conditions :
  374. Les opérateurs de logique sont : &,|,¬
  375.  
  376. Voilà, vous savez tout pour programmer en MATHARI ...
  377.  
  378. Un exemple :
  379. Problème : calculer la somme s des 1/k² pour k=1..n
  380. On crée d'abord une variable n et une variable s que l'on initialise à 0 :
  381.     n:=NEW
  382.     s:=NEW
  383.     s:0
  384.     n:<valeur souhaitée>
  385. On écrit alors une boucle for-next :
  386.     (1+i*n)$(s:s+1/▌²)
  387. On attend l'execution : le résultat se trouve dans s
  388. On le récupère :
  389.     s
  390. On efface n et s :
  391.     n:=NULL
  392.     s:=NULL                                
  393.  
  394. Un autre exemple :    
  395. calculer la somme pour i=1..n de la somme des j=1..i des j²
  396.     s:=NEW
  397.     n:=NEW
  398.     s:0
  399.     n:<valeur ...>
  400.     (1+i*n)$(1+i*▌)$(s:s+▌²)
  401.     s
  402.     n:=NULL
  403.     s:=NULL
  404.  
  405. Trucs & astuces sous Mathari :
  406. ------------------------------
  407. Sympa comme nom de paragraphe, non ??
  408. Je vais y relater toutes les commandes 'cachées' de Mathari :
  409.     - le snapshot est disponible en noir et blanc sous le tracé de 
  410. graphes : appuyer sur S pour appeler cette fonction.
  411.     - la croix permet de se déplacer sur une courbe tout en affichant 
  412. les valeurs (x,y) correspondantes. Dispo pour l'instant dans le tracé de
  413. graphe, appelé par la touche C et désactivé par une pression sur Esc ...
  414.     - quand la croix est activé, si vous appuyez sur F, vous 
  415. ordonnerez à Mathari de considérer la suite récurrente de premier terme le 
  416. point actuel et d'expression u[n+1]=f(u[n]) où f est la fonction 
  417. représentée par le graphe ... pour sortir de cette option : Esc ...
  418.     - la touche I permet, lorsque vous admirez vos courbes, de 
  419. rajouter la courbe de l'identité. ( pratique pour les suites récurrentes )
  420.     - la touche R permet de redessiner l'ensemble. ( redraw ou zoom )
  421.     - la touche T : comme R sauf qu'en plus, elle force la variable t 
  422. à varier entre xmin et xmax ( zoom )
  423.     - les touches ( ) / * 7 8 9 - permettent de recentrer la courbe par 
  424. rapport à l'espace étudié. ( permet de zoomer sur une partie de la courbe 
  425. combiné avec la touche T ou R !!! ) Les variables xmin, xmax, ymin et ymax 
  426. sont réactualisées !!
  427. Un conseil de Stabylo est de créer une fonction DEFAULT, qui initialisera 
  428. tous les paramètres xmin, xmax, ymin, ymax, tmin, tmax comme vous le 
  429. souhaiterez !! Normalement, cela vous fera gagner du temps...
  430. Enfin, ne désesperez pas !! Mathari, sur Falcon de base, sans NVDI, est 
  431. lent, voire très lent : je le sais, moi aussi je l'ai vécu ! Mais si vous 
  432. l'utilisez en réfléchissant suffisamment, vous pourrez vous en servir en 
  433. le faisant travailler le moins possible ; bien sur, il vous faudra un 
  434. temps d'adaptation au produit mais cela, à mon avis, en vaut la chandelle !!
  435. J'ai l'intention de faire un nouveau Mathari en C et Assembleur et sous 
  436. GEM mais pour l'instant, je n'ai vraiment pas le temps, désolé !
  437. Pour les heureux possesseurs d'AfterBurner, de Médusa, d'Hadès ou de 
  438. Milan, voire de TT, Mathari doit être vraiment très rapide, bande de
  439. veinards !!!!!!! ( dont je fais maintenant partie ;-))) )
  440. Mettez tout en TT-Ram si ce n'est déjà fait et préparez-vous à être 
  441. décoiffé(e) !!!!!!!!!
  442.  
  443. Conclusion :
  444. ------------
  445. Comme je l'ai dit plus haut, une nouvelle version de Mathari utilisant le 
  446. GEM est prévu. Cette nouvelle version sera ( en tout cas je le souhaite ) 
  447. capable de faire du calcul formel et tout et tout : ce sera une sorte de 
  448. Maple light ( je ne vais quand meme pas refaire Maple à moi tout seul, ou 
  449. meme avec Stabylo !!! )
  450. Ayant perdu les sources de cette version de Mathari qui est actuellement
  451. entre vos mains, je déclare qu'il s'agit de la dernière évolution de 
  452. Mathari TOS !!!
  453. A bientot sous Mathari GEM !!!
  454. ( laissez-nous du temps, on est en prepa quand meme !!! )
  455.  
  456.  
  457.                 Seb(The Boss)/The Removers
  458.                 Stabylo/The Removers
  459.