Home

1. Introduction
2. Syntaxe
3. Fonctions / Paramètres
4. Utilisation
5. Optimisation

1) Introduction

Cette doc n'est utile à comprendre que quand l'on sait déjà fabriquer des images avec le programme AIMFRACT. Elle explique comment écrire de nouvelles formules qui pourront être utilisées par AIMFRACT.

Quand on compile un fichier de formules (avec FORMULE.EXE), il est demandé si l'on veut avec coprocesseur ou sans. Les fichiers compilés pour le coprocesseur ont pour extension cop. Ceux compilés sans ont pour extension emu (émulation).

Pour information, FORMULE.EXE fabrique un véritable programme en langage machine.

2) Syntaxe

Pour écrire un commentaire il faut placer un $ au début de la ligne, ainsi la ligne ne sera pas prise en compte.

Pour chaque algorithme, il y a trois formules :

• la 1ère, F, pour initialiser ;
• la 2ème, G, pour le test de sortie ;
• la 3ème, H, pour l'itération.

Lors du dessin, vos formules sont utilisées ainsi :
z = F
Tant que G(z) <= 0, z = H(z)

Puis le nombre d'itérations effectuées sert à déterminer la couleur du point.

Exemple d'écriture :
$ image de Mandelbrot
2: 0; |z| > 2; z*z+z0;

G = |z| > 2 , la comparaison ">" est vue comme une fonction qui rend 0 ou 1, on a donc bien : arrêt si G > 0. On peut utiliser les autres fonctions de comparaison.
2 est le numéro d'algorithme, il est toujours suivi par ":", puis par F, G et H avec un point-virgule à la fin de chaque formule.

Chaque formule est aussi grande que l'on veut, elle peut être écrite sur plusieurs lignes, comprendre des espaces, mais elle doit absolument finir par ";".
Pour écrire ces formules, vous avez des fonctions, des paramètres et les chiffres.

3) Fonctions / Paramètres

Fonctions :

• fonctions arithmétiques : +, -, *, /,
• cos pour cosinus
• sin pour sinus
• tan pour tangente
• acos pour arccosinus
• asin pour arcsinus
• atan pour arctangente
• logr et logc pour logarithme népérien.
  il faut prendre logr quand l'argument est un réel strictement positif sinon il faut prendre logc. logc est identique à logr sur les réels strictement positifs mais plus lente.
• exp pour exponentielle
• puic et puir pour puissance, s'écrivent : 2 puic 3 ou puic(2,3)
  il faut prendre puir quand le premier argument est un réel strictement positif sinon il faut prendre puic.
• arg pour argument (donne l'angle en radian) :
  ex : arg(1) = 0, arg(-2) = arg(-1) = PI, arg(i) = PI/2
• norme ou valeur absolue, s'écrit norme(2) ou |2|
• sgn pour rendre le signe,
  ex : sgn(0) = 0, sgn(2) = 1, sgn(-4) = -1, sgn(-2+i*3) = -1+i
• conj pour conjugué,
  conj(2) = 2, conj(2+i*3) = 2-3*i
• mod pour modulo (reste de la division du 1er arg par le 2ième), on ne prend en compte que la partie réelle du 2ième argument,
  ex : mod(2,3) = 2, mod(-5.3,3) = 0.7, mod(-5.3+5.3*i,3) = 0.7+2.3*i
• real donne la partie réelle d'un complexe
• imag donne la partie imaginaire d'un complexe
• fonctions booléennes : >=,<=,<,>,=, elles rendent 1 si c'est vrai, 0 sinon. Leur priorité est identique entre elles et est inférieure à celle de tous les autres opérateurs.
  2+3*i > 1+2*i sera vu ainsi : 2>1 et 3>2 donc le résultat est 1
  3+2*i > 1+4*i sera vu ainsi : 3>1 et 2>4 donc le résultat est 0
• max rend le maximum,
  ex : max(2,3)=3, max(2+i*3,i*4)=2+i*4
• min rend le minimum.
• ent rend la partie entière,
  ex : ent(2.45) = 2, ent(-1.25) = -2, ent(2.4+i*8.56) = 2+i*8
• rz(z) est égal à 1 si z nul, sinon est égal à z

Ces fonctions sont valables aussi bien pour les réels que pour les complexes.

Paramètres

• pi pour 3,1415 ...
• i est le complexe tel que i*i=-1
• c = cx+i*cy, cx pour Constante X, cy pour Constante Y
• p = px+i*py, px pour Puissance Réelle, py pour Puissance Imaginaire
• z0 = x0+i*y0, x0 et y0 seront remplacés par les coordonnées du point lors du calcul
• z = x+i*y, x et y seront remplacés par les résultats du calcul pour l'itération suivante, il est conseillé de les avoir dans la formule, autrement à chaque itération le résultat sera le même et si de plus x0 et y0 n'apparaissent pas dans la formule, le résultat sera le même en tout point.
• nor pour Norme
• coor pour Coordonnées
• v0 à v9 : les 10 variables annexes
• Les autres paramètres généraux ainsi que ceux pour écrire du texte seront pris en compte lors du calcul mais n'interviennent pas dans les formules elles-même.

4) Utilisation

Vous pouvez utiliser tous les paramètres comme bon vous semble dans les 3 formules (F, G, H), à part z dans F, en effet F initialise z (=x+i*y), donc on ne doit pas avoir x, y ou z apparaissant dedans.

Attention aux fonctions ayant un domaine de définition restreint (/, logr, puir ...), nous n'avons pas encore implanté de gestion d'erreurs plus sophistiquée que celle du DOS qui fait sortir du logiciel en cas d'erreur (ex : divide error). Pour éviter ces erreurs, vous pouvez utiliser certaines fonctions comme max, min, norme, rz (1/rz(x) au lieu de 1/x).

Une fois vos formules écrites, il faut appeler le programme FORMULE.EXE, suivi du nom du fichier de formules sans l'extension ; ce programme rend les formules assimilables par AIMFRACT, en créant un nouveau fichier de même nom et d'extension cop ou emu. Tous ces fichiers doivent se trouver dans le répertoire d'où est lancé AIMFRACT.

Vous pouvez tester vos formules sur quelques points grâce au logiciel TESTFORM.EXE

5) Optimisation

Ce chapitre n'est pas nécessaire à une utilisation élémentaire des formules.

Le temps de calcul peut être réduit par deux méthodes :

• en utilisant des fonctions rapides à calculer : ce sont celles que l'on arrive à faire à la main : + * - /
  Par ex : comme test de sortie, il vaut mieux écrire x*x+y*y-4 plutôt que |z|>2
• en facilitant le boulot du simplificateur : pour cela, voici les 3 simplifications faites par le programme FORMULE.EXE :
  1. Pour une même formule, si FORMULE.EXE repère que le calcul a déjà été fait, on utilise le résultat déjà obtenu. Par exemple, pour x*x/(x*x+1), x*x ne sera calculé qu'une fois. Autre exemple : cos(sin(y+cx*x+x))+tan(y+cx*x), là y+cx*x ne sera calculé qu'une fois. Le programme ne connaissant pas les lois de commutativité, distributivité et associativité, si on écrit sin(x+y)+cos(y+x), il ne fera aucune simplification.
     Les nombres complexes étant décomposés, le nombre de simplifications indiqué par FORMULE.EXE peut être plus grand que le nombre d'opérateurs que vous avez écrit, ex : z*z/(z*z+1) a 6 simplifications.
  2. FORMULE.EXE utilise le fait que le résultat de certaines fonctions est un réel, si vous pensez qu'il ne peut pas le déduire, vous pouvez le lui indiquer en prenant la partie réelle.
     Exemple : à la place d'écrire cos(z * conj(z)), écrivez cos(real(z * conj(z))), real ne prend pas de temps au moment du calcul et c'est le cos réel qui sera utilisé à la place du cos complexe.
     FORMULE.EXE prend en compte que x,y,cx ... sont des réels, et connait les fonctions rendant un réel (par ex : cos d'un réel est réel et cos d'un complexe est un complexe).
  3. Dans une formule, par exemple z0*z0+cx*cx+z*z, le paramètre cx ne varie pas au cours du calcul de toute l'image, on calcule alors cx*cx une fois par image.
     Chaque formule est divisée en 3 routines : la première s'exécute une fois par image, la deuxième une fois par point et la troisième une fois par itération. Par exemple si cos(sin(cx puic p)) apparait dans une formule, il ne sera calculé qu'une fois par image.
     Pour profiter pleinement de cette simplification, il faut faire gaffe à ceci :
     Dans cx*z0*z, cx*z0 sera calculé une fois par point mais dans z*cx*z0 le calcul se fera à chaque itération car l'analyseur comprend (z*cx)*z0
     Ce qui est constant sur l'image : tout sauf z0, x0, y0, z, x, y
     Ce qui est constant sur un point : tout sauf z, x, y
• En utilisant les fonctions les plus rapides : il y a 2 cas où vous avez le choix,
  1. entre logr et logc : si vous êtes sûr que l'argument est un réel strictement positif utilisez logr.
  2. entre puir et puic : pareil que pour log pour le premier argument.
     FORMULE.EXE ne fait absolument aucune déduction sur le signe des réels, c'est à vous de choisir le bon log et la bonne puissance.

Home