projet informatique en maths.

Je dois faire un projet en maths en C++. Il consiste globalement à tracer des courbes fractales par itération de polynomes T complexes, du types T:z->z²+c.

Voici un exemple:
si z=x+iy, c=2, a la premiere itération on aura: x²+2ixy-y²-1
Ensuite, on considère le lieu des points qui vérifient |T(z)|=0.1

Lorsque l'on trace l'ensemble des points z qui vérifient cette equation, ca donne des
ensembles de Julia de ce type:

http://claudiusmaximus.goto10.org/im...a/julia--1.jpg

On peut répéter :T(T(T(T(z)))) ce qui donne des ensembles fractals.


Faire des complexes, ca doit etre assez simple,
je pense faire une classe de complexe, et définir les opérations, les parties réelles et imaginaires.
Pour l'itération, il faut que je déclare l'itérée comme un complexe.

Pour calculer le lieu des points z, je pense créer une grille de points de 10000 entre [-1,1] pour x et [-1,1] pour y. (On pourra modifier les bornes)
Comme il y a quand meme tres peu de chance de tomber sur des points qui vérifient l'équation, je compte introduire une marge d'erreur.

Par exemple, je ne conserve que les points qui vérifient |T(z)-0.1|<0.01 ce qui est assez grossier, ou ne prendre que les points : |T(z)-0.1|<0.00001 ce qui est plus fin.


C'est au niveau du code que je ne sais pas quoi prendre, pour le tableau de valeur.
Je pense que la meilleure facon de le faire, c'est de prendre un vector de la STL.

Tous les commentaires sont bons aprendre, au niveau du code, ou de l'algorithme.

Merci

Le C++ dispose déjà d'une classe (std::complex) pour gérer des complexes...

Je n'ai pas trop compris ton histoire de tableaux.

Sache que la STL du C++ met à disposition pas mal d'outils qui risquent de t'être utiles...
Les conteneurs : tu vas devoir choisir celui qui convient le plus pour stocker tes évaluations de polynômes, etc ...
Les algorithmes : ils vont te permettre d'effectuer des opérations sur chaque élément, de trier selon un critère particulier, ...

Dis-nous en plus sur ce que tu as fait en C++ ou ce que tu comptes faire.
J'ai plus ou moins cerné le problème mathématique, mais on doit t'aider à "transcrire" ça en C++.

J'avais fait un début de petit programme qui pouvait dessiner quelques fractales differentes (buddhabrot, mandelbrot, julia, biomorphe, et leurs dérivées...). Si ça t'interesse je poste le code qui permet de les dessiner. ;)

Merci pour les réponses. J'ai utilisé la stl <complex.h>

Voici mon code que j'aimerais améliorer.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

complex<double> T(complex<double> z1,complex<double> c){ return z1*z1+c;   }   int main(){   double n=20000; complex<double> c(0.35,1.28); for(double i=1;i<=n;i++){ for(double j=1;j<=n;j++){ double a=-3+(3+3)*i/n; double b=-3+(3+3)*j/n; complex<double> p(a,b); if(abs(pow(T(T(T(T(p,c),c),c),c).real(),2)+pow(T(T(T(T(p,c),c),c),c).imag(),2)-2)<0.001){ //....//} } } }

---

Voila l'endroit que j'aimerais améliorer:
Soit p un nombre complexe
Comme vous pouvez le constater, la boucle If fait une composition T(T(T(T(p))) de fonctions. Le pb est que c'est tres long.
Voici ce que je voudrais faire:
-C'est dés le début du programme, calculer une fois pour toute la partie réelle et imaginaire de T(T(T(T(p)))),
-de considérer la partie réelle et imaginaire comme deux fonctions de deux varaibles (la premiere variable est la partie réelle et l'autre la partie imaginaire).

et comme ca, je passe en paramètre ces deux varaibles, ca évite de faire la composition..

et je peux vous assurer que ca va bcp plus vite.

Mais comment créer une fonction, issue de composition de fonctions et qui prend des paramètres?

Citation:

---

J'avais fait un début de petit programme qui pouvait dessiner quelques fractales differentes (buddhabrot, mandelbrot, julia, biomorphe, et leurs dérivées...). Si ça t'interesse je poste le code qui permet de les dessiner.

---

Oh oui, pq pas.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

void Julia::dessiner() { C = complex<double> (m_constantReal, m_constantImag); for (int x = 0; x < m_largeur; x++) { double reel = m_xMin + x * ((m_xMax - m_xMin)/m_largeur);   for (int y = 0; y < m_hauteur; y++) { Z = complex<double> (reel, m_yMin + y * ((m_yMax - m_yMin)/m_hauteur));     double n = 0; do { Z = Z*Z + C;   n++; } while (norm(Z) < 4 && n < m_nbIterations);   if (n == m_nbIterations) Image.SetPixel(x, y, sf::Color(0, 0, 0)); else { int R = (int)(n/m_nbIterations * 255); int G = (int)(n/m_nbIterations * 255); int B = (int)(n/m_nbIterations * 255); Image.SetPixel(x, y, sf::Color(R, G, B)); } } }   Image.SaveToFile(string("julia.png")); }

---

Ça c'est la fonction qui dessine une fractale de Julia.
J'ai pas posté le reste de la classe car c'est pas très dur à faire seul. :P

c'est quoi setpixel? c'est une classe, c'est dans quelle libraire? Image.SetPixel

C'est de la SFML.

Gie,

Citation:

---

Envoyé par deubelte

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

complex<double> T(complex<double> z1,complex<double> c){ return z1*z1+c;   }   int main(){   double n=20000; complex<double> c(0.35,1.28); for(double i=1;i<=n;i++){ for(double j=1;j<=n;j++){ double a=-3+(3+3)*i/n; double b=-3+(3+3)*j/n; complex<double> p(a,b); if(abs(pow(T(T(T(T(p,c),c),c),c).real(),2)+pow(T(T(T(T(p,c),c),c),c).imag(),2)-2)<0.001){ //....//} } } }

---

Voila l'endroit que j'aimerais améliorer:

---

Une chose est à améliorer en tout cas, éviter ce genre de boucle:

Code:

---

for(double i=1;i<=n;i++)

---

Le cumul d'additions sur un double a de bonnes chances de dériver suffisamment pour que le test d'arrêt échoue.

D'ailleurs, il est fortement déconseillé de faire de tels tests absolus sur tous les types flottants. :)

Citation:

---

Le cumul d'additions sur un double a de bonnes chances de dériver suffisamment pour que le test d'arrêt échoue.

---

je déclare quoi pour i alors?

Citation:

---

il est fortement déconseillé de faire de tels tests absolus sur tous les types flottants.

---

pourquoi?

Kuo,

Citation:

---

Envoyé par deubelte

je déclare quoi pour i alors?

---

Une valeur scalaire, bien entendu, ce qui évite les approximations.

dans la boucle, rien ne t'interdit d'utiliser une variable supplémentaire de type double, que tu initialiseras avec la valeur de i.

Citation:

---

Envoyé par deubelte

pourquoi?

---

A cause des approximations, justement : pour les types flottants, les approximations sont inévitables.
A dire vrai, les valeurs représentables exactement avec ces formats sont très rares par rapport à la dynamique des valeurs qu'ils autorisent.
De plus, deux calculs équivalents au point de vue mathématique peuvent très bien donner des résultats différents, c'est d'ailleurs le cas général, toujours à cause des approximations.

C'est un sujet récurrent sur le forum. :)

Merci pour toutes vos réponses.
J'ai néanmoins tj un pb pas résolu,
celui de créer des fonctions avec variables symboliques.

cf mon post précédent

Citation:

---

Voila l'endroit que j'aimerais améliorer:
Soit p un nombre complexe
Comme vous pouvez le constater, la boucle If fait une composition T(T(T(T(p))) de fonctions. Le pb est que c'est tres long.
Voici ce que je voudrais faire:
-C'est dés le début du programme, calculer une fois pour toute la partie réelle et imaginaire de T(T(T(T(p)))),
-de considérer la partie réelle et imaginaire comme deux fonctions de deux varaibles (la premiere variable est la partie réelle et l'autre la partie imaginaire).

et comme ca, je passe en paramètre ces deux varaibles, ca évite de faire la composition..

et je peux vous assurer que ca va bcp plus vite.

Mais comment créer une fonction, issue de composition de fonctions et qui prend des paramètres?

---

Citation:

---

Envoyé par deubelte

Merci pour toutes vos réponses.
J'ai néanmoins tj un pb pas résolu,
celui de créer des fonctions avec variables symboliques.

cf mon post précédent

---

Le code que je t'ai montré a le même effet que ce que tu veux, grâce à la boucle (enfin, si j'ai bien compris ce que tu veux).

Mais tu ne peux pas calculer "une bonne fois pour toutes" T(T(T(T(p)))), car p change plusieurs fois, et donc T(T(T(T(p)))), change lui aussi.

Mais c'est sûr que de calculer une fractale de 20000*20000 ça prend du temps...

Citation:

---

ais tu ne peux pas calculer "une bonne fois pour toutes" T(T(T(T(p)))), car p change plusieurs fois, et donc T(T(T(T(p)))), change lui au

---

J'ai pensé m'orienter vers les patrons de fonctions, sans savoir ce que c'était d'ailleurs. Je ne sais pas si c'est la bonne voie.

Citation:

---

Mais c'est sûr que de calculer une fractale de 20000*20000 ça prend du temps...

---

>>oui, as tu une image a m'envoyer du résultat que donne ton prog?

C'est du 800*600, 50 itérations, avec C = 0.382 + 0.147i, dans les intervalles [-1.5; 1.5] et [-1.5; 1.5], calculé en 1 seconde :

http://img507.imageshack.us/img507/519/image3ig3.png
http://img507.imageshack.us/img507/5...2e392de4b6.jpg

On peut obtenir beaucoup plus estéthique avec une meilleure résolution, un nombre d'itérations différent, et une méthode de coloration différente aussi.

Mais l'esprit est là.