www.reflex4you.com

Experts, mode d’emploi

Exemples:

Notations

Liste des fonctions utilisées par Reflex par ordre alphabétique.

Scripts utiles

Rajouter des axes gradués sur une fonction

Rajouter une grille sur une fonction

Voir une fonction en perspective comme si on volait au-dessus d’elle

Obtenir un nombre complexe à partir d’une couleur donnée

Remplacer un complexe par un autre en terme de couleurs

Spirale à concaténer à gauche

Experts, mode d’emploi

Reflex possède un langage de programmation propre avec beaucoup de fonctions primitives.

Il est basé sur le principe de composition de fonctions. Chaque expression du programme est une fonction. Les entrées sont z (nombre complexe en cours), x (sa partie réelle), y (sa partie imaginaire). z est équivalent à x + i * y.

Exemples:

z^2-3z+1

let f = sin(z)/2 in f(f(z))

oo(sin(z)/2, 2)

set w = 1;

let f = if w > 0 then

  set w = w + 1 in

  set res = z^2+i*z-2;

  if abs(res) > 10 then

    set w = -w in w

  else

    res

else w;

oo(f, 5)

sum(z^n / prod(i, i, 1, n), n, 1, 15)

comp(x^2+z,x,0,15)

Une fonction polynôme

Définition d’une fonction f appliquée deux fois

Notation abrégée pour appliquer la fonciton deux fois

utilisation d’une variable pour stocker une information (set) et une fonction à variable d’entrée z appliquée 5 fois, qui peut modifier la variable w

Calcul de la série exponentielle à l’ordre 15

Calcul direct de Mandelbrot (calcul répété de x = 0 puis x = x^2 + z 15 fois, et on renvoie x)

Notations

z désigne la fonction identité

f dénote une expression

NAME est un nom [a-zA-Z_$0-9]+ ne commençant pas par un chiffre.

f ::= f+f | f*f | f/f | f-f | f^f | f%f | FLOAT | FLOAT*i

f ::= f <= f | f >= f | f < f | f > f | f <> f | f == f

FLOAT ::= [-]DIGIT[.(DIGIT)*][i] | FLOAT+FLOAT | FLOAT-FLOAT | FLOAT(e|E)FLOAT

Si f=z, on peut enlever les parenthèses, comme par exemple  sin == sin(z)

Liste des fonctions disponibles par ordre alphabétique.

abs(f)

synonyme de module(f)

arcsin(f)

arcsin(f,g)

arccos(f)

arccos(f,g)

arctan(f)

arctan(f,g)

réciproque de sinus en f

Même chose mais en prenant real(g) et imag(g) comme paramètres pour le logarithme et la racine.

arccos pareil

arctan juste real(g) est pris comme paramètre

arg(f)

arg(f,g)

argument entre [-pi et pi] de f
argument entre [-pi+real(g),pi+real(g)] d
e f

argsh(f)

argsh(f,g)

argch(f)

argch(f,g)

argth(f)

argth(f,g)

réciproque de sinus hyperbolique en f

Même chose mais en prenant real(g) et imag(g) comme paramètres pour le logarithme et la racine.

argch pareil

argth juste real(g) est pris comme paramètre

beta(f)

gamma(x)gamma(y)/(gamma(x+y))

fonction bêta d’Euler

carre(f)

synonyme de exposant(f,2)

circle(f)

cercle(f)

o(z-1/conj(z),f) # C’est un cercle noir centré en 0 de rayon 1

colornan(f,g)

synonyme de iferror(f,g)

comp(f,v,start,number)

equivalent à

set v=start in repeat number in set v=f in v

conj(f)

Conjugué de f

cos(f)

Cosinus de f

cosh(f)

Cosinus hyperbolique de f

compose(f,g)

Synonyme de o(f,g)

cube(f)

synonyme de exposant(f,3)

derive(f,g)

synonyme de diff(f,g)

diff(f,g)

Calcule la dérive de f selon g

z -> (f(z+g(z))-f(z))/g(z)

qui est égal à f’(z) si g(z) tend vers zéro.

division(f,g)

f/g

exp(f)

Exponentielle de f

exposant(f,g)

f^g ou encore exp(g*ln(f))

factorial(f)

fact(f)

factorielle(f)

gamma(f+1). Fonction factorielle prise en f

floor(f)

floor(real(f))+floor(imag(f))*i

Partie entière.

fonc NAME = f1 in f2

fonction NAME = f1 in f2

synonyme de let

func NAME = f1 in f2

function NAME = f1 in f2

synonyme de let

gamma(f)

Formule de la fonction gamma d’Euler prise en f

heaviside(f)

heav(f)

1 si real(f) >= 0, et 0 sinon.

iferror(f,g)

calcule f, et si la partie réelle ou imaginaire est NaN ou infinie, calcule g.

if(f,g,h)

ifthenelse(f,g,h)

if f then g else h

si f est différente de zéro, retourne g, sinon h

variante

variante

i

Le nombre complexe i

imag(f)

Partie imaginaire de f

inverse(f)

inv(f)

1/f

j

Le nombre complexe j = -+

let NAME = f1 in f2

let NAME = f1 ; f2

let(f2,NAME,f1)

Remplace toutes les occurences de NAME dans f2 par la fonction f1

ln(f)

ln(f,g)

Logarithme népérien de f avec l’argument

entre [-pi et pi]

Logarithme avec argument entre

 [-pi+real(g),pi+real(g)]

minus(f, g)

synonyme de soustraction(f, g)

modulo(f, g)

Real(f)%Real(g) + Imag(f)%Imag(g) i

module(f)

modulus(f)

Calcule le module sqrt(x²+y²) en f

moins(f, g)

synonyme de soustraction(f, g)

multiplication(f, g)

multiply(f, g)

multiplie(f, g)

Calcule f*g

NAME(f)

synonyme de o(NAME,f)

newton(f)

z-f/f’

Les points fixes de newton(f) sont exactement les zéros de f

o(f1,f2)

Calcule f2 puis f1 au résultat.

oo(f1,Nf)

Compose N fois f par elle-même, où N est la partie entière de la partie réele de Nf

oppose(f)

-f

puissance(f,g)

synonyme de exposant(f,g)

plus(f,g)

calcule f+g

prod(f,v,min,max[,step])

Calcule  avec un pas de step

quotient(f,g)

Synonyme de division(f,g)

racine(f)

racine(f,g)

synonyme de sqrt(f)

synonyme de sqrt(f,g)

real(f)

Partie réelle de f

repeat Nf in f

repete Nf in f

repeat(f,Nf)

repete(f,Nf)

Répète N fois le calcul de f et renvoie la dernière valeur, où N est la partie entière de la partie réelle de Nf et peut être directement donnée comme un entier

set NAME = f1 in f2

set(f2,NAME,f1)

Calcule f1 et affecte le résultat à NAME dans f2

sign(f)

signe(f)

synonyme de unitary(f)

sin(f)

Sinus de f

sinh(f)

sinus hyperbolique de f

soit NAME = f1 in f2

synonymes de set

somme(f,v,min,max[,step])

Calcule  avec un pas de step

Soustraction(f)

calcule f-g

sum(f,v,min,max[,step])

synonyme de somme(f,v,min,max[,step])

sqrt(f)

sqrt(f,g)

Racine carrée de f, avec la racine prise à

partir de la moitié de argument entre [-pi et pi]

Racine carrée de f, avec la racine prise à

 partir de la moitié de argument entre [-pi+real(g) et pi+real(g)]

square(f)

synonyme de exposant(f,2)

tan(f)

tangente de f = sin(f)/cos(f)

tanh(f)

tangente hyperbolique de f = sinh(f)/cosh(f)

unitary(f)

unitaire(f)

unit(f)

valeur unitaire de f = f/module(f)

valabs(f)

synonyme de abs(f)

x

Partie réelle de z

y

Partie imaginaire de z

z

Identité

zeta(f)

Fonction zêta de Riemann

Scripts utiles

Rajouter des axes gradués sur une fonction

Remplacer YOUR_FUNCTION par votre fonction. On peut régler l’épaisseur de l’axe ainsi que le rayon des marques.

let axes = let widthaxes = 0.05 in let circleradius = 0.07 in

(1-heav(widthaxes/2+x)*heav(widthaxes/2-x))*(1-heav(widthaxes/2+y)*heav(widthaxes/2-y))*if(((x < -0.5) + (x > 0.5))*((y < -0.5) + (y > 0.5)),1, heav(abs(z - floor(z+0.5+0.5i))-circleradius)) in

axes * YOUR_FUNCTION

Rajouter une grille sur une fonction

Remplacer YOUR_FUNCTION par votre fonction. On peut modifier l’épaisseur de la grille

let grille = (let width = 0.1 in

heav(x-width/2-floor(x+width/2))*heav(y-width/2-floor(y+width/2))) in

grille*YOUR_FUNCTION

Note: Pour avoir une grille avec un niveau de détail supplémentaire, on peut multiplier par grille * grille(4z)

Voir une fonction en perspective comme si on volait au-dessus d’elle

Remplacer YOUR_FUNCTION par votre fonction. Voici la signification des paramètres:

Les paramètres horizon et angle permettent de régler respectivement la hauteur de l’horizon et l’angle de celui-ci par rapport au centre. Les valeurs par défaut sont normalement suffisantes.

set posxy = 0.5-2i in set rot = 45 in set posz = 8 in set horizon = 2.667 in set angle = 90 in let fp = o(z*exp(i*rot*pi/180)+posxy*i,-4z/posz/(real(z*exp(-i*(angle*pi/180)))/horizon-1)) in o(YOUR_FUNCTION,fp)

Obtenir un nombre complexe à partir d’une couleur donnée

Parfois on aimerait une couleur, mais reflex ne permet pas toujours de l’obtenir. Cependant, voici un script qui peut approximer une couleur donnée. Comme toutes les données sont constantes, le programme sera optimisé et la couleur calculée seulement une fois.

Cette formule garantit à un ordre 4 près que si une couleur donnée C correspondait exactement à un nombre complexe Z , alors cette formule retournera le nombre Z en question. Pour le reste, ce sont des approximations.

let r = 1 in let v = 255 in let b = 0 in if((r == 0)*(v == 0)*(b == 0), 0, let radiusin = 1/(255*3/(r + v + b) - 1) in let angle = if(2*x < y, 1, if(2*y < x, 0, ((ln(y)-ln(x) + ln(2))/(2ln(2))))) * 2pi/3 in if(radiusin <= 1, let d = 2*radiusin/(radiusin+1) in let arg1 = if((r >= b)*(v >= b), angle(r/255/d + i * v/255/d), if((r >= v)*(b >= v), -angle(r/255/d + i * b/255/d), angle(v/255/d + i * b/255/d) + 2pi/3)) in exp(i * arg1) * radiusin, let p = (3-(r+v+b)/255)/1.5 in let radiusout = 2/p - 1 in let rr = (r/255 - (1-p))/p in let vv = (v/255 - (1-p))/p in let bb = (b/255 - (1-p))/p in let arg2 = if((r >= b)*(v >= b), angle(rr + i*vv), if((r >= v)*(b >= v), -angle(rr + i*bb), angle(vv + i*bb) + 2pi/3)) in exp(i * arg2) * radiusout))

Remplacer un complexe par un autre en terme de couleurs

De la même manière qu’on peut tourner une photo, la zoomer et la déplacer, de la même manière on peut faire en sorte que deux nombres complexes donnés soient transformés en deux autres donnés, par exemple pour changer certaines couleurs.

Il suffit de placer votre fonction à la place de YOUR_FUNCTION dans l’expression suivante, où

Pour ne faire qu’une rotation des couleurs et un changement de luminosité, il suffit de mettre debuta et fina à zéro. Attention, debuta doit être différent de debutb.

set debuta = 0 in set fina = 1 in set debutb = i in set finb = -i in

let m = (fina - finb) / (debuta - debutb) in

let n = fina - m * debuta in

let f = m * z + n in

o(f, YOUR_FUNCTION)

Spirale à concaténer à gauche

z*heav(o(arg(z,abs(z)*4)/4-abs(z),z)+0.5)