Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2022-12-24T06:53:16+01:00Les derniers messages parus sur le forum de Zeste de Savoir.Implémenter fractales de Julia, message #2478642022-12-24T06:53:16+01:00Armand75001/@Armand75001https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p247864<p>À votre attention !
Je viens en témoignage sur se site pour vous raconter comment je suis tombé sur
M. Lahuppe Philippe
J’étais à la recherche d’un prêt entre particulier pour finaliser la construction de ma maison vu que ce n’est pas facile avec les banques de faire un prêt.
C’est ainsi que j’ai visiter un site pour avoir de notions concernant le système de prêt entre particulier. A ma grande surprise beaucoup de personnes ont bénéficiés de ses offres de prêt. J’ai donc pris son contact mail sur lequel j’ai essayer de la contacté pour un prêt de 8.000€.
Dans les brefs délais j’ai réellement reçu la somme demandée avec un taux d’intérêt convenable.
Voilà en quelques lignes comment je suis sur M. Lahuppe Philippe
Voici donc son e-mail : <a href="mailto:contactsfinances@gmail.com">contactsfinances@gmail.com</a>
Voici donc son e-mail : <a href="mailto:contactsfinances@gmail.com">contactsfinances@gmail.com</a>
Voici donc son e-mail : <a href="mailto:contactsfinances@gmail.com">contactsfinances@gmail.com</a></p>
<p>N°: ( +33 ) 0756914547
N°: ( +33 ) 0756914547</p>Implémenter fractales de Julia, message #2449742022-08-26T23:46:51+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244974<p>Sur une fonction aussi simple, j’imagine que <code>numba</code> s’en sortirait pas trop mal en effet, il arriverait à vectoriser et virer tout appel à l’API Python.</p>
<p>Dernièrement j’ai pas mal joué avec Rust + PyO3 + ndarray et c’est vraiment pas mal pour exposer une API Python au-dessus d’un code vectorisé proprement.</p>Implémenter fractales de Julia, message #2449712022-08-26T23:35:33+02:00brian.sinquin/@brian.sinquinhttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244971<p>Nous parlons bien de la même chose. Je pensais à la base que np.vectorise faisait de la compilation à la volée par exemple comme numba ou un binding avec un executable plus efficace.</p>Implémenter fractales de Julia, message #2449702022-08-26T23:23:28+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244970<blockquote>
<p>Intéressant ! Je suppose que la vectorisation devient effectivement efficace à partir d’un rang et/ou d’une taille de tableau donnée.</p>
</blockquote>
<p>Quand tu dis vectorisation, tu parles de <code>np.vectorize</code>, ou de la version qui fait juste des manipulations sur les <code>np.ndarray</code> ? Parce qu’en fait, ironiquement, <code>vectorize</code> ne vectorise pas les opérations au sens où on l’entend classiquement en HPC (et qui idéalement donne accès aux instructions CPU pour faire ça efficacement).</p>
<p><code>np.vectorize</code> se contente de faire des boucles sur les tableaux passés en arguments et appeler la fonction Python sur chaque élément. D’un autre côté, les opérations sur les tableaux numpy sont effectivements des opérations sur des tableaux contigus qui peuvent exploiter le cache et les instructions processeurs qui vont bien (et on pourrait même faire encore mieux en compilant pour la machine sur laquelle on tourne plutôt qu’un dénominateur commun). C’est pour ça que <code>np.vectorize</code> est hyper-lent par rapport à des opérations sur un array numpy, et à opérations identiques ce sera toujours plus lent. Vu le facteur 7 que se prend <code>np.vectorize</code> dans le cas présent, sa seule chance pour concurrencer avec une implémentation sur les arrays est d’avoir beaucoup plus d’itérations (ce qui en pratique n’est utile que si on zoome à mort) pour que le gâchis d’opérations commence à faire sentir.</p>Implémenter fractales de Julia, message #2449692022-08-26T23:10:07+02:00brian.sinquin/@brian.sinquinhttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244969<p>Intéressant ! Je viens de lire <a href="https://towardsdatascience.com/dont-assume-numpy-vectorize-is-faster-dd7e455dba2">ça</a>, np.vectorize ne semble être qu’une macro qui ne fait rien d’autre qu’une boucle for. Je n’ai jamais essayé numba mais c’est peut-être une piste pour gagner en efficacité. <a href="/@b4b4" rel="nofollow" class="ping ping-link">@<span class="ping-username">b4b4</span></a> comme l’algorithme ne dépend que du pixel considéré, tu peux paralléliser le code (avec numba justement ou en faisant du multi-threading), ça peut être intéressant pour voir à quel point tu peux augmenter la résolution de l’image pour un même temps de traitement. Et c’est aussi un bon exercice si tu n’as jamais fait de multi-threading.</p>Implémenter fractales de Julia, message #2449242022-08-25T18:31:31+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244924<p>Salut,</p>
<p>Par curiosité, j’ai fait un petit test de performances pour voir si utiliser <code>np.vectorize</code> est pertinent par rapport à une solution qui passe son temps dans numpy quitte a faire un peu de travail pour rien. Le résultat est sans appel (<em>pun intended</em>), utiliser <code>np.vectorize</code> est hyper-lent. C’est normal, <code>numpy</code> se contente de faire une boucle sur la fonction Python, donc on perd beaucoup de temps à construire les objets Python, les manipuler, et appeler la fonction elle-même.</p>
<p>Pour l’histoire, je génère une image de 4000x4000 pixels avec 100 itérations. Je compare en gros cette implémentation :</p>
<div class="hljs-code-div hljs-code-python"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span></div><pre><code class="hljs language-python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">divergence</span>(<span class="hljs-params">z_0: <span class="hljs-built_in">complex</span>, c_0: <span class="hljs-built_in">complex</span>, threshold: <span class="hljs-built_in">float</span>, itermax: <span class="hljs-built_in">int</span></span>):</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(itermax):
z_0 = z_0**<span class="hljs-number">2</span> + c_0
<span class="hljs-keyword">if</span> <span class="hljs-built_in">abs</span>(z_0) >= threshold:
<span class="hljs-keyword">return</span> i
<span class="hljs-keyword">return</span> itermax
div_vect = np.vectorize(divergence, otypes=[np.uint32])
div = div_vect(z_s, c_0, threshold, itermax)
</code></pre></div>
<p>Avec celle-ci:</p>
<div class="hljs-code-div hljs-code-python"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span></div><pre><code class="hljs language-python">div = np.full_like(z_s, itermax, dtype=np.uint32)
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(itermax):
z_s = np.square(z_s) + self.c_0
diverged = np.<span class="hljs-built_in">abs</span>(z_s) >= self.threshold
div[diverged] = np.uint32(i)
z_s[diverged] = np.nan
</code></pre></div>
<p>Le code à base de <code>np.vectorize</code> met 139 secondes à faire les calculs. Le code effectivement factorisé (mais qui fait des calculs pour rien) met seulement <em>19 secondes</em> ! C’est un exemple de plus que faire un truc idiot point de vue algorithmique (plein de calculs sur des <code>np.nan</code> sur les points qui ont déjà divergés) peut être largement plus rapide à cause des préfacteurs immenses côté Python (et d’un autre côté, <code>numpy</code> fait probablement des trucs pas trop idiots pour bien vectoriser les calculs).</p>
<p>Un autre truc qui prend du temps dans le code de <a href="/@b4b4" rel="nofollow" class="ping ping-link">@<span class="ping-username">b4b4</span></a> est l’utilisation de <code>pcolormesh</code> (quelques secondes) plutôt que construire une image directement avec PIL (coût négligeable).</p>Implémenter fractales de Julia, message #2448602022-08-23T09:51:48+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244860<figure><blockquote>
<p>Et il y a quelque chose que je ne comprend pas bien: les images générés par <a href="/@adri1" rel="nofollow" class="ping ping-link">@<span class="ping-username">adri1</span></a>, proviennent elles de mon programme ou bien d’ailleurs ? Auquel cas, si il ne provient pas de mon code, le soucie vien-il du nombre d’itération, que j’ai intentionellement limité à 30 à cause de la puissance de mon ordinateur ?</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244857">b4b4</a></figcaption></figure>
<p>Mon programme, que j’ai mis en fin de message. Oui, le soucis vient du nombre d’itérations, c’est ce que je dis et montre dans mon message… Si ton ordi est un peu lent, tu pourrais diminuer le nombre de pixels de l’image pour vérifier qu’augmenter le nombre d’itérations permet effectivement de résoudre plus de détails.</p>Implémenter fractales de Julia, message #2448582022-08-23T08:47:19+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244858<p>Non tu ne l’instancies pas (la classe n’est jamais appelée et tu n’as donc pas d’instance). Si tu le faisais tes appels de méthodes échoueraient (puisqu’elles ne sont pas définies comme statiques) :</p>
<div class="hljs-code-div hljs-code-pycon"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span></div><pre><code class="hljs language-pycon"><span class="hljs-meta">>>></span> <span class="python">julia = Julia()</span>
<span class="hljs-meta">>>></span> <span class="python">julia.create_complex_matrix(-<span class="hljs-number">4</span>, <span class="hljs-number">4</span>, -<span class="hljs-number">4</span>, <span class="hljs-number">4</span>, <span class="hljs-number">1000</span>)</span>
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Julia.create_complex_matrix() takes 5 positional arguments but 6 were given
</code></pre></div>
<p>En Python les modules sont déjà une bonne manière d’organiser les choses.
Il n’est donc pas utile d’ajouter une classe coquille vide, à part si tu as bien sûr un état à conserver (ce qui se fait dans une instance de la classe donc).</p>
<p>Aussi tu gagnerais à lister tes dépendances (<code>numpy</code> et <code>matplotlib</code> en l’occurrence) dans un fichier <code>requriements.txt</code> par exemple pour faciliter l’installation.</p>Implémenter fractales de Julia, message #2448572022-08-23T08:38:38+02:00Lokasku/@Lokaskuhttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244857<p>Alors, premièrement j’instencie belle et bien cette classe dans le fichier <code>run.py</code> à la racine du projet. Et oui en effet j´aurai très bien pu ne pas mettre de classe, mais je trouve que ça organise les choses d’une certaine manière.</p>
<p>Et il y a quelque chose que je ne comprend pas bien: les images générés par <a href="/@adri1" rel="nofollow" class="ping ping-link">@<span class="ping-username">adri1</span></a>, proviennent elles de mon programme ou bien d’ailleurs ? Auquel cas, si il ne provient pas de mon code, le soucie vien-il du nombre d’itération, que j’ai intentionellement limité à 30 à cause de la puissance de mon ordinateur ?</p>Implémenter fractales de Julia, message #2448562022-08-23T08:29:36+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244856<figure><blockquote>
<p>Mon programme fonctionne correctement grâce à vos remarques, et il est disponible <a href="https://github.com/b4-b4/julia">ici</a> sur mon GitHub.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244851">b4b4</a></figcaption></figure>
<p>En lisant ton code je me demande à quoi sert la classe <code>Julia</code> : tu ne l’instancies jamais et elle ne contient donc que deux méthodes statiques (qui ne sont pas définies comme telle, ce qui pourrait poser problème).<br>
Pourquoi ne pas simplement définir les fonctions à la racine du module <code>julia</code> ?</p>Implémenter fractales de Julia, message #2448532022-08-23T00:49:20+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244853<p>En l’occurrence, c’est juste une question du nombre d’itérations que tu fais pour tester si un point diverge ou non. Avec 50 itérations :</p>
<figure><img src="/media/galleries/5664/02a1dd6c-39b2-43eb-b133-a867fc763aa4.png" alt="image.png"><figcaption>image.png</figcaption></figure>
<p>Avec 200 itérations :</p>
<figure><img src="/media/galleries/5664/08d59ed5-2477-4d15-afba-99c98c476d7d.png" alt="image.png"><figcaption>image.png</figcaption></figure>
<p>Le code, avec une approche un peu différente, pour ceux que ça intéresse</p>
<details class="custom-block custom-block-spoiler"><div class="custom-block-body"><div class="hljs-code-div hljs-code-python"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span><span data-count="36"></span><span data-count="37"></span><span data-count="38"></span><span data-count="39"></span><span data-count="40"></span><span data-count="41"></span><span data-count="42"></span><span data-count="43"></span><span data-count="44"></span><span data-count="45"></span><span data-count="46"></span><span data-count="47"></span><span data-count="48"></span><span data-count="49"></span><span data-count="50"></span><span data-count="51"></span><span data-count="52"></span><span data-count="53"></span><span data-count="54"></span><span data-count="55"></span><span data-count="56"></span><span data-count="57"></span><span data-count="58"></span><span data-count="59"></span><span data-count="60"></span><span data-count="61"></span></div><pre><code class="hljs language-python"><span class="hljs-keyword">from</span> dataclasses <span class="hljs-keyword">import</span> dataclass
<span class="hljs-keyword">from</span> numpy.typing <span class="hljs-keyword">import</span> NDArray
<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">from</span> PIL <span class="hljs-keyword">import</span> Image
<span class="hljs-meta">@dataclass</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ComplexPlane</span>:</span>
xleft: <span class="hljs-built_in">float</span>
xright: <span class="hljs-built_in">float</span>
yleft: <span class="hljs-built_in">float</span>
yright: <span class="hljs-built_in">float</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">xspan</span>(<span class="hljs-params">self</span>) -> <span class="hljs-built_in">float</span>:</span>
<span class="hljs-keyword">return</span> self.xright - self.xleft
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">yspan</span>(<span class="hljs-params">self</span>) -> <span class="hljs-built_in">float</span>:</span>
<span class="hljs-keyword">return</span> self.yright - self.yleft
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">create</span>(<span class="hljs-params">self, resolution: <span class="hljs-built_in">int</span></span>) -> NDArray[np.complexfloating]:</span>
x_s = np.linspace(self.xleft, self.xright,
<span class="hljs-built_in">int</span>(self.xspan() * resolution))
y_s = np.linspace(self.yleft, self.yright,
<span class="hljs-built_in">int</span>(self.yspan() * resolution))
<span class="hljs-keyword">return</span> x_s[:, np.newaxis] + y_s[np.newaxis, :] * <span class="hljs-number">1j</span>
<span class="hljs-meta">@dataclass</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">JuliaSetDivergence</span>:</span>
c_0: <span class="hljs-built_in">complex</span>
threshold: <span class="hljs-built_in">float</span> = <span class="hljs-number">2.0</span>
n_iterations: <span class="hljs-built_in">int</span> = <span class="hljs-number">50</span>
resolution: <span class="hljs-built_in">int</span> = <span class="hljs-number">1000</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">over</span>(<span class="hljs-params">self, plane: ComplexPlane</span>) -> NDArray[np.floating]:</span>
z_s = plane.create(self.resolution)
div = np.full_like(z_s, self.n_iterations, dtype=np.uint32)
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(self.n_iterations):
z_s = np.square(z_s) + self.c_0
diverged = np.<span class="hljs-built_in">abs</span>(z_s) >= self.threshold
div[diverged] = np.uint32(i)
z_s[diverged] = np.nan
<span class="hljs-keyword">return</span> div / self.n_iterations
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">main</span>() -> <span class="hljs-literal">None</span>:</span>
plane = ComplexPlane(xleft=-<span class="hljs-number">2.0</span>, xright=<span class="hljs-number">2.0</span>, yleft=-<span class="hljs-number">2.0</span>, yright=<span class="hljs-number">2.0</span>)
julia_div = JuliaSetDivergence(
c_0=<span class="hljs-built_in">complex</span>(-<span class="hljs-number">0.4</span>, <span class="hljs-number">0.6</span>),
resolution=<span class="hljs-number">500</span>,
n_iterations=<span class="hljs-number">200</span>,
)
div_map = julia_div.over(plane)
im = Image.fromarray((div_map * <span class="hljs-number">255</span>).astype(np.uint8))
im.save(<span class="hljs-string">"plot.tiff"</span>)
<span class="hljs-keyword">if</span> __name__ == <span class="hljs-string">"__main__"</span>:
main()
</code></pre></div></div></details>Implémenter fractales de Julia, message #2448522022-08-23T00:06:32+02:00Berdes/@Berdeshttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244852<p>Ton problème n’est qu’un effet du choix de la constante <code>c</code>. Suivant la constante <code>c</code> que tu choisis choisi, la fractale de Julia associé va beaucoup varier. Pour tous les valeurs de <code>c</code> qui correspondent à des points situés à l’intérieur de l’ensemble de Mandelbrot, les fractales de Julia associés sont entièrement connecté et tu vas te retrouver avec des zones unis. À l’inverse, pour tous les autres valeurs de <code>c</code>, les fractales de Julia associés ne sont composés que de points isolés et tu n’auras donc aucune zones unis.</p>
<p>Quand tu regardes l’ensemble de Mandelbrot, chaque pixel correspond à un <code>c</code> particulier, donc tu peux générer un ensemble de Julia pour chaque point d’une image d’un ensemble de Mandelbrot. En faisant le lien entre les deux, tu pourra mieux comprendre comment choisir un <code>c</code> qui te permettra d’avoir un ensemble de Julia qui va plus corresponde à ce que tu cherches.</p>Implémenter fractales de Julia, message #2448512022-08-22T22:51:10+02:00Lokasku/@Lokaskuhttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244851<p>Bonsoir,</p>
<p>Mon programme fonctionne correctement grâce à vos remarques, et il est disponible <a href="https://github.com/b4-b4/julia">ici</a> sur mon GitHub. Pour <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mo>=</mo><mo>−</mo><mn>0.4</mn><mo>+</mo><mn>0.6</mn><mi>i</mi></mrow><annotation encoding="application/x-tex">c = -0.4 + 0.6i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">c</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.72777em;vertical-align:-0.08333em;"></span><span class="mord">−</span><span class="mord">0</span><span class="mord">.</span><span class="mord">4</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord">0</span><span class="mord">.</span><span class="mord">6</span><span class="mord mathdefault">i</span></span></span></span></span>, voici la commande à entrer pour générer la fractale associé, car oui, j’ai armé mon programme d’une CLI:</p>
<div class="hljs-code-div hljs-code-text"><pre><code class="hljs language-text">python /path/to/julia/run.py 1000 27 -0.4 0.6 -c "inferno"
</code></pre></div>
<p>Ou plus explicitement:</p>
<div class="hljs-code-div hljs-code-text"><pre><code class="hljs language-text">... <density-pixel> <detail-density> <cr> <ci> [-c THEME]
</code></pre></div>
<p><code><cr></code> représente la partie réelle de <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi></mrow><annotation encoding="application/x-tex">c</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">c</span></span></span></span></span> et <code>ci</code> sa partie imaginaire. Donc quand on entre cette commande, on a:</p>
<figure><img src="/media/galleries/18111/32c8684e-d70a-4a9c-8882-203988790d5e.png" alt="Fractale de Julia pour c = -0.4 + 0.6i"><figcaption>Fractale de Julia pour c = -0.4 + 0.6i</figcaption></figure>
<p>Le problème, comme vous pouvez le voir, c’est qu’il n’y a aucun détail <em>intérieur</em> à la figure: celui-ci est juste remplie d’une couleur. Les seuls détails se trouvent en extérieurs, et avec n’importe quelle autre fractale, ces détails ne se montrent pas, et la cause m’échappe.</p>
<p>Pouvez-vous m’aider à résoudre ce problème ?</p>
<p>Cordialement.</p>Implémenter fractales de Julia, message #2448122022-08-21T15:28:29+02:00brian.sinquin/@brian.sinquinhttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244812<p>Réponse corrigée, en effet mauvaise interprétation et erreur dans le retour de l’itération.</p>Implémenter fractales de Julia, message #2448102022-08-21T14:42:59+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244810<p>C’est dommage de cracher une solution toute faite, qui plus est fausse. <img src="/static/smileys/svg/siffle.svg" alt=":-°" class="smiley"></p>
<blockquote>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span></div><pre><code class="hljs language-py"><span class="hljs-meta">@np.vectorize </span><span class="hljs-comment"># pour itérer sur chaque élément du plan complexe z0</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">julia</span>(<span class="hljs-params">z0, c, i</span>):</span>
z = z0
<span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(i):
z = z*z + c
<span class="hljs-keyword">if</span> (<span class="hljs-built_in">abs</span>(z) > <span class="hljs-number">2</span>) : <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-comment"># on stop l'algorithme si ça commence à diverger</span>
<span class="hljs-keyword">return</span> i <span class="hljs-comment"># on retourne l'itération si ça converge (la norme sera la vitesse de convergence)</span>
</code></pre></div>
</blockquote>
<p>Retourner le nombre d’itérations (soit tout le temps <code>30</code>, ou <code>0</code> sur les points qui divergent) ne donnera pas une mesure de la vitesse de convergence. Ce qu’on veut plotter est une vitesse de divergence d’ailleurs…</p>
<hr>
<blockquote>
<p>A partir de ceux-ci il créé deux matrice unidimensionnel et ressort la "fusion" de ces dernières en une matrice bidimensionnel qui nous permet donc d’avoir une matrice ayant des nombres flottants, et négatif (ce qui n’est pas permis nativement).</p>
</blockquote>
<p>Par "pas nativement", tu parles des <em>indices</em> flottants ? La matrice que tu as construit ne contourne aucunement ceci, elle est remplie de sorte que <code>z[i, k] = x(k) + y(i) * 1j</code>. Aucun langage (ni bibliothèque) un minimum sain ne va proposer l’indexage par des flottants. C’est ultra casse-gueule à cause des problèmes des calculs flottants qui ont une précision limitée.</p>
<blockquote>
<p>et enfin, appliquons se masque à la matrice bidimensionnelle plan afin de n’afficher uniquement les nombres de ce dernier qui matcheraient avec le masque.</p>
</blockquote>
<p>Les masques <code>numpy</code> ne fonctionnent pas comme ça, ce sont des tableaux de booleans qui disent si l’élément doit être montré ou non. Ce que tu voudrais faire serait équivalent à <code>plan[plan==mask]</code> (avec <code>mask</code> ne contenant que la dernière itération, pas toute la liste). Ce serait une façon logique d’afficher les points fixes (donc l’ensemble de Julia lui même), mais en fait ça ne peut pas marcher en pratique à cause de la précision finie des nombres flottants et de l’échantillonage discret du plan qui est fait. C’est pour ça qu’à la place, soit on fait un plot binaire des points qui ont divergés ou non (ce que tu as fait pour Mandelbrot), soit la vitesse de divergence des points qui ne sont pas dans l’ensemble, pour avoir une idée de la "distance" à laquelle on est de l’ensemble de Julia (et puis en bonus c’est joli comme ça).</p>Implémenter fractales de Julia, message #2448092022-08-21T13:57:24+02:00brian.sinquin/@brian.sinquinhttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244809<p>Update</p>
<p>L’algorithme de Julia diffère de celui de Mandelbrot. Dans mandelbrot, la constante c est la position dans le plan complexe. Dans Julia c’est le z0 initial qui est la position dans le plan complexe et c est une constante à part entière. D’autres part, on veut retourner l’itération maximale qui garde la norme de z dans la borne qu’on a fixée.</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span></div><pre><code class="hljs language-py"><span class="hljs-meta">@np.vectorize </span><span class="hljs-comment"># pour itérer sur chaque élément du plan complexe z0</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">julia</span>(<span class="hljs-params">z0, c, i</span>):</span>
z = z0
<span class="hljs-keyword">for</span> it <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(i):
z = z*z + c
<span class="hljs-keyword">if</span> (<span class="hljs-built_in">abs</span>(z) > <span class="hljs-number">2</span>) : <span class="hljs-keyword">break</span> <span class="hljs-comment"># on stop l'algorithme si on sort de notre borne</span>
<span class="hljs-keyword">return</span> it <span class="hljs-comment"># on retourne l'itération (plus it est grand plus ça diverge lentement)</span>
</code></pre></div>
<p>Comme alternative à la méthode des masques, on peut appliquer la fonction julia (grâce à <a href="/@np" rel="nofollow" class="ping ping-link">@<span class="ping-username">np</span></a>.vectorize) à tout les point du plan complexe (la matrice plan). Ici on aura pas de résultats binaires mais un gradient d’intensité et donc on pourra colorer l’image en fonction de la vitesse de divergence.</p>
<p>Pour créer votre plan complexe vous pouvez aussi utiliser np.meshgrid() qui permet de faire de l’algèbre multidimensionnel et retourner des matrices :</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span></div><pre><code class="hljs language-py">X,Y = np.meshgrid(x,y)
M = X + <span class="hljs-number">1j</span>*Y
</code></pre></div>
<p><a href="https://github.com/curio-sitas/Fractals">Vous trouverez différentes implémentations ici</a></p>Implémenter fractales de Julia, message #2447982022-08-21T11:03:54+02:00Lokasku/@Lokaskuhttps://zestedesavoir.com/forums/sujet/16412/implementer-fractales-de-julia/?page=1#p244798<p>Bonjour,</p>
<p> <a href="https://github.com/b4-b4/mandelbrot">J’ai hier développé un simple programme</a> qui me permettait d’afficher l’ensemble de Mandelbrot en Python. Aujourd’hui, j’ai envie de reprendre ce programme afin de le transformer en quelque chose qui m’afficherai selon <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi></mrow><annotation encoding="application/x-tex">c</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">c</span></span></span></span></span> une fractale de Julia. Alors, pour premier jet, même si ça ne marche pas, voilà ce que ça donne:</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span></div><pre><code class="hljs language-py"><span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">create_complex_matrix</span>(<span class="hljs-params">x1, x2, y1, y2, quality</span>):</span>
x = np.linspace(x1, x2, <span class="hljs-built_in">int</span>((x2 - x1) * quality))
y = np.linspace(y1, y2, <span class="hljs-built_in">int</span>((y2 - y1) * quality))
<span class="hljs-keyword">return</span> x[np.newaxis, :] + y[:, np.newaxis] * <span class="hljs-number">1j</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">julia</span>(<span class="hljs-params">c, i</span>):</span>
z = c
z_list = []
<span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(i):
z = z ** <span class="hljs-number">2</span> + c
z_list.append(z)
<span class="hljs-keyword">return</span> z_list
plan = create_complex_matrix(-<span class="hljs-number">2</span>, <span class="hljs-number">0.5</span>, -<span class="hljs-number">1.5</span>, <span class="hljs-number">1.5</span>, quality=<span class="hljs-number">1000</span>)
mask = julia(<span class="hljs-built_in">complex</span>(-<span class="hljs-number">0.1</span>, <span class="hljs-number">0.651</span>), i=<span class="hljs-number">30</span>)
plt.imshow(plan[mask], cmap=<span class="hljs-string">"binary"</span>)
plt.show()
</code></pre></div>
<p> Ce programme, fonctionne de la sorte:</p>
<ul>
<li>Nous importons la librairie <code>numpy</code>ainsi que <code>matplotlib.pyplot</code> qui nous servirons respectivement à créer des matrices et à afficher ces matrices.</li>
<li>Nous définissons une fonction <code>create_complex_matrix</code> qui prend en entrée <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">x_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>, <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">x_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>, <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">y_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03588em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> et <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">y_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03588em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>. A partir de ceux-ci il créé deux matrice unidimensionnel et ressort la "fusion" de ces dernières en une matrice bidimensionnel qui nous permet donc d’avoir une matrice ayant des nombres flottants, et négatif (ce qui n’est pas permis nativement).</li>
<li>Nous définissons la fonction <code>julia</code> qui prend en argument <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi></mrow><annotation encoding="application/x-tex">c</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">c</span></span></span></span></span> et <code>i</code>. "<span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi></mrow><annotation encoding="application/x-tex">c</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">c</span></span></span></span></span>" correspond au nombre complexe à partir duquel nous voulons que la fractale s’organise. <code>i</code> n’est qu’une simple valeur qui déterminera le nombre de fois que nous ferons <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>Z</mi><mi>n</mi></msub><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">Z_n+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.07153em;">Z</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:-0.07153em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">n</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span></span> (le "<span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">+ 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.72777em;vertical-align:-0.08333em;"></span><span class="mord">+</span><span class="mord">1</span></span></span></span></span>" s’applique à <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">n</span></span></span></span></span> mais je n’ai pas réussi à le mettre à l’échelle), donc, déterminera la complexité de la fractale rendue (puisque il détermine en soit le nombre de pixel de la fractale). Le fonctionnement interne de la fonction est relativement simple:
<ul>
<li>nous affectons <code>c</code> à <code>z</code> et non pas <code>0</code> pour gagner un tour ;</li>
<li>nous définissons la liste <code>z_list</code> qui correspond à <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>Z</mi></mrow><annotation encoding="application/x-tex">Z</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.07153em;">Z</span></span></span></span></span> (rappelez-vous, la suite pour <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>Z</mi><mi>n</mi></msub></mrow><annotation encoding="application/x-tex">Z_n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.07153em;">Z</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:-0.07153em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">n</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>) ;</li>
<li>nous entrons dans une boucle <code>for</code> qui bouclera <code>i</code> fois ;</li>
<li>nous appliquons la formule <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>z</mi><mo>=</mo><mi>z</mi><mtext>²</mtext><mo>+</mo><mi>c</mi></mrow><annotation encoding="application/x-tex">z = z² + c</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.04398em;">z</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.66666em;vertical-align:-0.08333em;"></span><span class="mord mathdefault" style="margin-right:0.04398em;">z</span><span class="mord">²</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">c</span></span></span></span></span> ;</li>
<li>affectons la valeur (<span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>Z</mi><mi>n</mi></msub></mrow><annotation encoding="application/x-tex">Z_n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.07153em;">Z</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:-0.07153em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">n</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>) à la liste <code>z_list</code> (<span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>Z</mi></mrow><annotation encoding="application/x-tex">Z</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.07153em;">Z</span></span></span></span></span>) ;</li>
<li>puis retournons la liste <code>z_list</code>.</li>
</ul>
</li>
</ul>
<p>Ensuite, nous créons une matrice bidimensionnelle qui correspond aux normes de la surface nécessaires nativement à Mandelbrot, créons une variable <code>mask</code> qui contient la suite <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>Z</mi></mrow><annotation encoding="application/x-tex">Z</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.07153em;">Z</span></span></span></span></span> pour <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mo>=</mo><mo>−</mo><mn>0.1</mn><mo>+</mo><mn>0.651</mn><mi>i</mi></mrow><annotation encoding="application/x-tex">c = -0.1 + 0.651i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">c</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.72777em;vertical-align:-0.08333em;"></span><span class="mord">−</span><span class="mord">0</span><span class="mord">.</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord">0</span><span class="mord">.</span><span class="mord">6</span><span class="mord">5</span><span class="mord">1</span><span class="mord mathdefault">i</span></span></span></span></span> (pris arbitrairement) et enfin, appliquons se masque à la matrice bidimensionnelle <code>plan</code> afin de n’afficher uniquement les nombres de ce dernier qui matcheraient avec le masque.</p>
<p>Or ce programme ne fonctionne pas et renvoie d’ailleurs une erreur:</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span></div><pre><code class="hljs language-py"> plt.imshow(plan[mask], cmap=<span class="hljs-string">"binary"</span>)
IndexError: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`<span class="hljs-literal">None</span>`) <span class="hljs-keyword">and</span> integer <span class="hljs-keyword">or</span> boolean arrays are valid indices
</code></pre></div>
<p>En plus de ça, je me doute qu’il à un pépin dans la logique de mon code, et j’attend vos retours quand au remaniement de ce programme.</p>
<p>Cordialement.</p>JuMP, l'optimisation avec Julia, message #1803232018-05-16T09:35:31+02:00oiseauroch/@oiseaurochhttps://zestedesavoir.com/forums/sujet/10703/jump-loptimisation-avec-julia/?page=1#p180323<p>Beaucoup plus clair en effet.
Encore quelques fautes que j’ai relevé : </p>
<ul>
<li>solveurs représente<strong>nt</strong> une part</li>
<li>la bonne approche pour <del>être</del> résoudre le problème rapidement</li>
<li>de cette contrainte<del>s</del> en lui assignant</li>
<li>modèle et plus de complexité<del>s</del></li>
<li>on <del>introduction</del> <strong>introduit</strong> une nouvelle </li>
</ul>
<p>peut être changer la formulation de ces phrases : </p>
<blockquote>
<p>pour sélectionner un solveur <del>pour</del> <strong>afin de</strong> résoudre un problème</p>
<p>seulement de résoudre des <del>programmes</del> <strong>problèmes</strong> linéaires</p>
<p>de résoudre des <del>programmes</del> <strong>problèmes</strong> linéaires en</p>
</blockquote>JuMP, l'optimisation avec Julia, message #1802752018-05-15T13:33:41+02:00Torejy/@Torejyhttps://zestedesavoir.com/forums/sujet/10703/jump-loptimisation-avec-julia/?page=1#p180275<p>Bonjour les agrumes !</p>
<p>La bêta a été mise à jour et décante sa pulpe
à l’adresse suivante :</p>
<div align="center">
<p><a href="https://zestedesavoir.com/contenus/beta/2219/jump-loptimisation-avec-julia/">JuMP, l’optimisation avec Julia</a> </p>
</div>
<p>Merci d’avance pour vos commentaires.</p>
<hr>
<p>J’ai mis à jour l’article en me basant sur vos retours !
La sous-partie intégration nécessiterait peut-être un peu plus de description.</p>JuMP, l'optimisation avec Julia, message #1799212018-05-09T14:53:55+02:00Torejy/@Torejyhttps://zestedesavoir.com/forums/sujet/10703/jump-loptimisation-avec-julia/?page=1#p179921<p>Merci pour vos retours !</p>
<p>J’ai commencé à réarranger et axer un peu plus sur la recherche opérationnelle avec le problème du sac à dos (knapsack problem). Ça sera bien plus intéressant qu’un simple problème mathématique qu’on peut résoudre en traçant 3 droites.</p>JuMP, l'optimisation avec Julia, message #1798872018-05-08T19:27:50+02:00ache/@achehttps://zestedesavoir.com/forums/sujet/10703/jump-loptimisation-avec-julia/?page=1#p179887<p>\o/<br>
J’ai bien aimé !</p>
<p>Mais j’ai le sentiment qu’il manque un truc, comme si c’était un peu trop abstrait. Sans réelle but.<br>
Peut-être que rajouter un exemple concret permettrait de mieux conclure l’article.<br>
La partie T&A fait vraiment cheap.</p>
<p>L’exemple à pas besoin de faire compliqué.</p>
<p>Pour les commandes, tu peux utiliser les balises de code inline <code>sudo myCommand</code>.</p>