Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2023-02-17T17:08:21+01:00Les derniers messages parus sur le forum de Zeste de Savoir.Unicité matrice rotation, message #2492332023-02-17T17:08:21+01:001e49ba0eba/@1e49ba0ebahttps://zestedesavoir.com/forums/sujet/16824/unicite-matrice-rotation/?page=1#p249233<p>Merci. Effectivement, c’est évident maintenant que tu le dis.</p>Unicité matrice rotation, message #2492172023-02-17T13:39:50+01:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16824/unicite-matrice-rotation/?page=1#p249217<p>Salut,</p>
<p>Une autre manière de voir les choses un peu plus proche de la façon dont tu as formulé ta question est que si ta rotation est la succession de trois rotations <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>R</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">R_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.00773em;">R</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.00773em;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>R</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">R_2</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.00773em;">R</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.00773em;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> 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>R</mi><mn>3</mn></msub></mrow><annotation encoding="application/x-tex">R_3</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.00773em;">R</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.00773em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</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> autour de trois axes, alors l’opération globale s’écrit <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>R</mi><mo>=</mo><msub><mi>R</mi><mn>1</mn></msub><msub><mi>R</mi><mn>2</mn></msub><msub><mi>R</mi><mn>3</mn></msub></mrow><annotation encoding="application/x-tex">R=R_1R_2R_3</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.00773em;">R</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.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;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 class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;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 class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</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 multiplication de matrices carrées est commutative (parce que ce ne sont que des opérations linéaires) donc l’ordre dans lequel les rotations sont effectuées ne change pas l’opération globale : <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>R</mi><mo>=</mo><msub><mi>R</mi><mn>2</mn></msub><msub><mi>R</mi><mn>1</mn></msub><msub><mi>R</mi><mn>3</mn></msub><mo>=</mo><msub><mi>R</mi><mn>3</mn></msub><msub><mi>R</mi><mn>1</mn></msub><msub><mi>R</mi><mn>2</mn></msub><mo>=</mo><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">R=R_2R_1R_3=R_3R_1R_2=...</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.00773em;">R</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.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;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 class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;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 class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</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.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.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</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="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;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 class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;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 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.10556em;vertical-align:0em;"></span><span class="mord">.</span><span class="mord">.</span><span class="mord">.</span></span></span></span></span>.</p>
<p>Pour être un peu plus général, ça marche indépendamment du repère, du nombre de dimensions, et quelque soit les opérations que tu effectues si celle-ci sont linéaires (comme une translation ou une dilatation) : l’ordre dans lequel tu combines des opérations linéaires n’importe pas, la composition d’opérations linéaires de <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi mathvariant="double-struck">R</mi><mi>n</mi></msup></mrow><annotation encoding="application/x-tex">\mathbb R^n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68889em;vertical-align:0em;"></span><span class="mord"><span class="mord mathbb">R</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.664392em;"><span style="top:-3.063em;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></span></span></span></span></span></span></span> vers <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi mathvariant="double-struck">R</mi><mi>n</mi></msup></mrow><annotation encoding="application/x-tex">\mathbb R^n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68889em;vertical-align:0em;"></span><span class="mord"><span class="mord mathbb">R</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.664392em;"><span style="top:-3.063em;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></span></span></span></span></span></span></span> est commutative.</p>Unicité matrice rotation, message #2492072023-02-17T10:20:56+01:00luxera/@luxerahttps://zestedesavoir.com/forums/sujet/16824/unicite-matrice-rotation/?page=1#p249207<p>Salut,</p>
<blockquote>
<p>Y-a-t-il unicité des matrices de rotation ?</p>
</blockquote>
<p>Oui, pour montrer ça on peut faire 2 lignes d’algèbre :</p>
<p>Si 2 matrices <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>R</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">R_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.00773em;">R</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.00773em;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>R</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">R_2</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.00773em;">R</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.00773em;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> donnent la même orientation finale, cela veut dire que quel que soit le vecteur <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi></mrow><annotation encoding="application/x-tex">u</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">u</span></span></span></span></span> considéré on a <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>R</mi><mn>1</mn></msub><mi>u</mi><mo>=</mo><msub><mi>R</mi><mn>2</mn></msub><mi>u</mi></mrow><annotation encoding="application/x-tex">R_1 u = R_2 u</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.00773em;">R</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.00773em;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 class="mord mathdefault">u</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.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;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 class="mord mathdefault">u</span></span></span></span></span>.</p>
<p>Par ailleurs, si on prend <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mo>=</mo><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo separator="true">,</mo><mn>0</mn><msup><mo stretchy="false">)</mo><mi>T</mi></msup></mrow><annotation encoding="application/x-tex">u=(1,0,0)^T</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">u</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:1.0913309999999998em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">0</span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8413309999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight" style="margin-right:0.13889em;">T</span></span></span></span></span></span></span></span></span></span></span></span> alors <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>R</mi><mn>1</mn></msub><mi>u</mi></mrow><annotation encoding="application/x-tex">R_1 u</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.00773em;">R</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.00773em;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 class="mord mathdefault">u</span></span></span></span></span> représente la première colonne de <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>R</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">R_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.00773em;">R</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.00773em;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 on peut faire une opération du même type pour les 2 autres colonnes). En utilisant <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>R</mi><mn>1</mn></msub><mi>u</mi><mo>=</mo><msub><mi>R</mi><mn>2</mn></msub><mi>u</mi></mrow><annotation encoding="application/x-tex">R_1 u = R_2 u</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.00773em;">R</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.00773em;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 class="mord mathdefault">u</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.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.00773em;">R</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.00773em;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 class="mord mathdefault">u</span></span></span></span></span>, on voit que les 2 matrices ont les mêmes colonnes.</p>Unicité matrice rotation, message #2492052023-02-17T09:32:30+01:001e49ba0eba/@1e49ba0ebahttps://zestedesavoir.com/forums/sujet/16824/unicite-matrice-rotation/?page=1#p249205<p>Une petite question rapidement :</p>
<p>Y-a-t-il unicité des matrices de rotation ?</p>
<p>Je m’explique : pour obtenir une orientation quelconque d’un solide dans l’espace, on peut définir trois rotation (une autour de chaque axe) et donc définir l’orientation par trois angles. Ces angles ne sont pas les mêmes selon l’ordre des axes choisis, mais quelque soit cet ordre il est toujours possible d’obtenir toutes les orientations possibles.</p>
<p>Est-ce qu’a une même orientation finales corresponds toujours une même matrice de rotations ? Dit autrement si Rx·Ry·Rz donne la même orientation finale que R’y·R’x·R’z, est-ce que Rx·Ry·Rz = R’y·R’x·R’z ?</p>
<p>Autre manière de formuler la même question : la matrice de rotation finale dépends-elles de l’ordre des axes rotations.</p>
<p>Merci d’avance.</p>Génération de matrices sous contraintes, message #2278662020-11-10T10:43:50+01:00etherpin/@etherpinhttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227866<figure><blockquote>
<p>L’idée est en fait plutôt simple, quand on s’est débarrassé de ces contraintes ennuyantes "d’avoir l’air aléatoire" :</p>
<p></p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227847">Lucas-84</a> </figcaption></figure>
<p>Merci, c’est très clair.<br>
J’interprète la ligne du bas et la colonne de droite comme un "crédit" qu’il convient d’annuler.<br>
La stratégie consiste à mettre à sec la ligne ou colonne la plus pauvre.<br>
Cette stratégie permet de trouver une matrice valide en 9 itérations, elle est donc économe.<br>
On peut envisager une stratégie (plus coûteuse en calcul) visant à appauvrir la case la plus riche, auquel cas on aurait 30 dans la case en haut à gauche.<br>
30 est donc la plus grande valeur qui puisse apparaître dans cette matrice. </p>Génération de matrices sous contraintes, message #2278472020-11-09T22:43:31+01:00Lucas-84/@Lucas-84https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227847<blockquote>
<p>Non, pas de malentendu, je suis parti d’une matrice valide et j’ai généré une autre matrice valide.</p>
</blockquote>
<p>Ah oui, au temps pour moi !</p>
<blockquote>
<p>Ton code trouve une solution valide <img src="/static/smileys/svg/smile.svg" alt=":)" class="smiley"> , même si on a du mal à comprendre comment ça marche <img src="/static/smileys/svg/magicien.svg" alt=":magicien:" class="smiley"> .</p>
</blockquote>
<p>L’idée est en fait plutôt simple, quand on s’est débarrassé de ces contraintes ennuyantes "d’avoir l’air aléatoire" :</p>
<hr>
<p>Au départ ta matrice est disons :</p>
<div class="hljs-code-div hljs-code-autre"><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-autre"> ? ? ? ? 30
? ? ? ? 22
? ? ? ? 24
? ? ? ? 19
? ? ? ? 27
36 26 31 29
</code></pre></div>
<p>On cherche la plus petite somme, que ce soit sur une ligne ou une colonne. Ici c’est 19, donc la quatrième ligne. On met un 19 n’importe où sur la ligne et 0 partout ailleurs, par exemple sur la première colonne. Sur la première colonne, la somme qu’on veut maintenant est 36–19 = 17.</p>
<div class="hljs-code-div hljs-code-autre"><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-autre"> ? ? ? ? 30
? ? ? ? 22
? ? ? ? 24
19 0 0 0 /
? ? ? ? 27
17 26 31 29
</code></pre></div>
<p>Maintenant, on a le même le problème que précédemment, mais sur une matrice 4x4. Et on a conservé l’invariant que 17+26+31+29=30+22+24+27. La plus petite somme est 17 :</p>
<div class="hljs-code-div hljs-code-autre"><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-autre">17 ? ? ? 13
0 ? ? ? 22
0 ? ? ? 24
19 0 0 0 /
0 ? ? ? 27
/ 26 31 29
</code></pre></div>
<p>On a maintenant une matrice 4x3, et ainsi de suite. Les histoires de <code>float('inf')</code> c’est juste pour gérer les lignes/colonnes déjà remplies.</p>
<hr>
<p>On notera au passage que cette stratégie donne une matrice de départ très "sparse" (de l’ordre 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>n</mi><mo>+</mo><mi>m</mi></mrow><annotation encoding="application/x-tex">n+m</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.66666em;vertical-align:-0.08333em;"></span><span class="mord mathdefault">n</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">m</span></span></span></span></span> cases non nulles sur <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><mi>m</mi></mrow><annotation encoding="application/x-tex">nm</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 class="mord mathdefault">m</span></span></span></span></span> au total), alors que l’opération de perturbation ne progresse pas lorsqu’elle sélectionne certaines cases avec des zéros. Donc la partie initiale de la convergence n’est pas très optimisée. </p>Génération de matrices sous contraintes, message #2278452020-11-09T22:08:09+01:00etherpin/@etherpinhttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227845<blockquote>
<blockquote>
<p>Matrice que l’on eut ensuite bricoler avec la chaîne de Markov citée plus haut.</p>
</blockquote>
<p>Il doit y avoir un malentendu, la "chaîne de Markov" en question ne transforme pas n’importe quelle solution invalide en une solution valide — au contraire, elle est construite de manière à ne pas modifier les sommes sur les colonnes/lignes.</p>
</blockquote>
<p>Non, pas de malentendu, je suis parti d’une matrice valide et j’ai généré une autre matrice valide. </p>
<blockquote>
<hr>
<p>Comme c’est peut-être un peu abstrait, j’ai implémenté la méthode que j’ai décrite plus haut. Pour trouver une solution quelconque au problème, pas besoin de programmation linéaire : tout est dans la fonction <code>initialize</code> (vérifier par récurrence que ça marche toujours si la somme des contraintes sur les lignes et les colonnes est la même). Le 10000 est évidemment arbitraire — avis aux amateurs pour les meilleures conjectures. </p>
</blockquote>
<p>Mon code ne trouve pas toujours une solution valide <img src="/static/smileys/svg/pleure.svg" alt=":'(" class="smiley"> . Par contre, il part d’une idée assez intuitive <img src="/static/smileys/svg/hihi.svg" alt="^^" class="smiley"> .<br>
Ton code trouve une solution valide <img src="/static/smileys/svg/smile.svg" alt=":)" class="smiley"> , même si on a du mal à comprendre comment ça marche <img src="/static/smileys/svg/magicien.svg" alt=":magicien:" class="smiley"> .</p>
<blockquote>
<p>Je précise que je ne suis pas Pythoniste de naissance. Ne copiez pas mon style ! <img src="/static/smileys/svg/hihi.svg" alt="^^" class="smiley"></p>
</blockquote>
<p>Il ne faut pas non plus copier mon style.
Pour ma part, je préfère le camelCase au snake-case que j’ai plus de mal à lire rapidement.</p>
<p>Source:<a href="https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227840">Lucas-84</a></p>Génération de matrices sous contraintes, message #2278402020-11-09T19:53:40+01:00Lucas-84/@Lucas-84https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227840<blockquote>
<p>Matrice que l’on eut ensuite bricoler avec la chaîne de Markov citée plus haut.</p>
</blockquote>
<p>Il doit y avoir un malentendu, la "chaîne de Markov" en question ne transforme pas n’importe quelle solution invalide en une solution valide — au contraire, elle est construite de manière à ne pas modifier les sommes sur les colonnes/lignes.</p>
<hr>
<p>Comme c’est peut-être un peu abstrait, j’ai implémenté la méthode que j’ai décrite plus haut. Pour trouver une solution quelconque au problème, pas besoin de programmation linéaire : tout est dans la fonction <code>initialize</code> (vérifier par récurrence que ça marche toujours si la somme des contraintes sur les lignes et les colonnes est la même). Le 10000 est évidemment arbitraire — avis aux amateurs pour les meilleures conjectures. </p>
<p>Je précise que je ne suis pas Pythoniste de naissance. Ne copiez pas mon style ! <img src="/static/smileys/svg/hihi.svg" alt="^^" class="smiley"></p>
<div 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></div><pre><code class="hljs language-python"><span class="hljs-keyword">import</span> random
<span class="hljs-comment"># Contraintes sur les lignes/colonnes</span>
slin, scol = [<span class="hljs-number">30</span>, <span class="hljs-number">22</span>, <span class="hljs-number">24</span>, <span class="hljs-number">19</span>, <span class="hljs-number">27</span>], [<span class="hljs-number">36</span>, <span class="hljs-number">26</span>, <span class="hljs-number">31</span>, <span class="hljs-number">29</span>]
nb_lins, nb_cols = len(slin), len(scol)
<span class="hljs-comment"># Génère deux entiers aléatoires distincts entre 0 et n-1 (uniformément)</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">generate_distinct_pair</span>(<span class="hljs-params">n</span>):</span>
x = random.randrange(n)
y = random.randrange(<span class="hljs-number">1</span>, n)
<span class="hljs-keyword">return</span> x, (x + y) % n
<span class="hljs-comment"># Effectue une étape de perturbation sur M</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">perturbate</span>(<span class="hljs-params">M</span>):</span>
i1, i2 = generate_distinct_pair(nb_lins)
j1, j2 = generate_distinct_pair(nb_cols)
<span class="hljs-keyword">if</span> M[i1][j1] != <span class="hljs-number">0</span> <span class="hljs-keyword">and</span> M[i2][j2] != <span class="hljs-number">0</span>:
M[i1][j1] -= <span class="hljs-number">1</span>
M[i2][j2] -= <span class="hljs-number">1</span>
M[i1][j2] += <span class="hljs-number">1</span>
M[i2][j1] += <span class="hljs-number">1</span>
<span class="hljs-comment"># Retourne une matrice quelconque vérifiant les contraintes</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">initialize</span>():</span>
M = [[<span class="hljs-number">0</span>] * nb_cols <span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> range(nb_lins)]
<span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> range(nb_lins + nb_cols - <span class="hljs-number">1</span>):
min_slin, min_scol = min(slin), min(scol)
imin, jmin = slin.index(min_slin), scol.index(min_scol)
<span class="hljs-keyword">if</span> min_slin < min_scol:
M[imin][jmin] = slin[imin]
scol[jmin] -= slin[imin]
slin[imin] = float(<span class="hljs-string">'inf'</span>)
<span class="hljs-keyword">else</span>:
M[imin][jmin] = scol[jmin]
slin[imin] -= scol[jmin]
scol[jmin] = float(<span class="hljs-string">'inf'</span>)
<span class="hljs-keyword">return</span> M
M = initialize()
<span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> range(<span class="hljs-number">10000</span>):
perturbate(M)
print(M)
</code></pre></div></div></div>Génération de matrices sous contraintes, message #2278052020-11-08T23:38:59+01:00etherpin/@etherpinhttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227805<p>Un code Python à l’arrache, incomplet :<br>
Je n’ai pas implémenté la modification de la matrice.<br>
La différence entre le total cible et celui de la matrice<br>
indique le nombre de cases à modifier.<br>
Reste à identifier les cases en question, si il n’y en a qu’une, c’est facile. </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><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></div><pre><code class="hljs language-py"><span class="hljs-comment">### saisie contrainte lignes</span>
print(<span class="hljs-string">"contraintes sur les lignes :"</span>)
l = [<span class="hljs-number">0</span> <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(nbl)]
totl=<span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(nbl):
l[i]=int(input(<span class="hljs-string">"ligne "</span>+str(i)+<span class="hljs-string">":"</span>))
totl=totl+l[i]
<span class="hljs-keyword">print</span> (l, <span class="hljs-string">"totl ="</span>, totl)
<span class="hljs-comment">### saisie contraintes colonnes</span>
c = [<span class="hljs-number">0</span> <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(nbc)]
totc=<span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(nbc):
c[i]=int(input(<span class="hljs-string">"colonne "</span>+str(i)+<span class="hljs-string">":"</span>))
totc=totc+c[i]
<span class="hljs-keyword">print</span> (c, <span class="hljs-string">"totc ="</span>,totc)
<span class="hljs-keyword">if</span> totc!=totl:
<span class="hljs-keyword">print</span> (<span class="hljs-string">"erreur, totc n'est pas égal à totl"</span>)
<span class="hljs-comment">### calcul d'une matrice proche</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(nbl):
<span class="hljs-keyword">for</span> j <span class="hljs-keyword">in</span> range(nbc):
mat[i][j]=round(l[i]*c[j]/totl)
print(mat)
<span class="hljs-comment">### calcul des ommes</span>
lp = [<span class="hljs-number">0</span> <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(nbl)]
cp = [<span class="hljs-number">0</span> <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(nbc)]
tot=<span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(nbl):
<span class="hljs-keyword">for</span> j <span class="hljs-keyword">in</span> range(nbc):
lp[i]=lp[i]+mat[i][j]
cp[j]=cp[j]+mat[i][j]
tot=tot+mat[i][j]
<span class="hljs-keyword">print</span> (tot,lp, cp)
<span class="hljs-keyword">if</span> tot!=totl:
print(<span class="hljs-string">"modier la matrice pour "</span>,tot-totl,<span class="hljs-string">" élément"</span>)
<span class="hljs-keyword">else</span>:
<span class="hljs-keyword">print</span> (<span class="hljs-string">"la matrice est correcte"</span>)
</code></pre></div>
<h4 id="exemple">Exemple<a aria-hidden="true" href="#exemple"><span class="icon icon-link"></span></a></h4>
<div class="hljs-code-div hljs-code-text"><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></div><pre><code class="hljs language-text">nombre de colonnes :2
nombre de lignes :3
contraintes sur les lignes :
ligne 0:21
ligne 1:17
ligne 2:35
[21, 17, 35] totl = 73
colonne 0:36
colonne 1:37
[36, 37] totc = 73
[[10, 11], [8, 9], [17, 18]]
73 [21, 17, 35] [35, 38]
la matrice est correcte
</code></pre></div>Génération de matrices sous contraintes, message #2277792020-11-08T14:04:42+01:00etherpin/@etherpinhttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227779<figure><blockquote>
<p>Si pour chaque élément de la matrice on fait v[i, j] = l[i]*c[j]/total on arrive à une solution valide mais avec des nombres flottants, après il faut gérer l’arrondi.</p>
<p>Exemple avec 5 lignes / 4 colonnes</p>
<div class="hljs-code-div hljs-code-bash"><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></div><pre><code class="hljs language-bash">Sommes de chaque ligne
30
22
24
19
27
Sommes de chaque colonne
36 26 31 29
Total 122
Valeurs calculées
8.852 6.393 7.623 7.131
6.492 4.689 5.590 5.230
7.082 5.115 6.098 5.705
5.607 4.049 4.828 4.516
7.967 5.754 6.861 6.418
</code></pre></div>
<p>EDIT: bon ça donne des valeurs plutôt "pondérées", si on veut que cela paraissent plus aléatoire on peut éventuellement appliquer un offset +/- à chaque valeur dont la somme est nulle en ligne / colonne.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227772">fromvega</a></figcaption></figure>
<p>Si on prend la valeur arrondie, cela donne :</p>
<p>9 6 8 7<br>
6 5 6 5<br>
7 5 6 6<br>
6 4 <strong>5</strong> 5<br>
8 6 7 6 </p>
<p>avec un total de 123, en regardant la somme des lignes et la somme des colonnes,<br>
on identifie un élément à changer, ce qui conduit à la matrice :</p>
<p>9 6 8 7<br>
6 5 6 5<br>
7 5 6 6<br>
6 4 <strong>4</strong> 5<br>
8 6 7 6 </p>
<p>Matrice que l’on eut ensuite bricoler avec la chaîne de Markov citée plus haut.</p>
<p>13 6 8 3<br>
6 5 6 5<br>
7 5 6 6<br>
5 4 4 6<br>
5 6 7 9 </p>Génération de matrices sous contraintes, message #2277782020-11-08T13:52:46+01:00Lucas-84/@Lucas-84https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227778<p>Pour ce genre de problème (générer aléatoirement uniformément une solutions à un problème), une stratégie qui marche bien en théorie et en pratique est de définir des opérations de perturbation locales qui transforment une solution valide en une autre solution. L’algorithme est alors le suivant : on part d’une solution à notre problème (pas du tout aléatoire), on tire aléatoirement une "petite" perturbation, et on répète ça un très grand nombre de fois. </p>
<p>Autrement dit, on définit un graphe sur l’ensemble des solutions, on part d’un nœud quelconque, et à chaque étape on choisit aléatoirement un de ses voisins. En fait, on peut montrer que si ce graphe satisfait certaines conditions (connexité, symétrie, …), alors, quand le nombre d’étapes tend vers l’infini, on a autant de chance d’être sur chaque sommet : la loi est uniforme sur l’ensemble des solutions (plus exactement, converge vers la loi uniforme, en un certain sens). </p>
<p>Si tu as déjà vu une chaîne de Markov (qui n’est rien d’autre qu’un graphe avec des probabilités écrites sur les arêtes), tout ceci n’est pas un miracle : une chaîne de Markov réversible, ergodique, symétrique a pour unique loi stationnaire la loi uniforme. Avec ce formalisme, on est intéressé par des versions quantitatives de la convergence décrite plus haut — le temps de mélange, à savoir le plus petit temps <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.61508em;vertical-align:0em;"></span><span class="mord mathdefault">t</span></span></span></span></span> tel que pour n’importe quel état de départ, à partir de l’étape <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.61508em;vertical-align:0em;"></span><span class="mord mathdefault">t</span></span></span></span></span>, la distance entre notre distribution sur l’ensemble des sommets et la loi uniforme est inférieure à 0.01 (au sens de la distance en variation totale, par exemple). C’est une manière de fixer le nombre d’étapes à effectuer en fonction de à quel point tu t’autorises à dévier de la loi uniforme sur l’ensemble des solutions.</p>
<p>Evidemment, toute la difficulté du problème consiste à définir ces opérations de perturbation, de manière à ce qu’on puisse aller de n’importe quelle solution valide à n’importe quelle autre par une suite de perturbations, et que la chaîne de Markov converge "rapidement". Pour ce problème de matrices sous contrainte, connu — je découvre également — sous le nom de "contingency tables" dans la littérature, il y a une chaîne de Markov classique, apparemment due à <a href="https://statistics.stanford.edu/sites/g/files/sbiybj6031/f/EFS%20NSF%20452.pdf">Diaconis et Gangolli</a> :</p>
<hr>
<p>Pour perturber la matrice <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>M</mi></mrow><annotation encoding="application/x-tex">M</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.10903em;">M</span></span></span></span></span> :</p>
<ul>
<li>Générer uniformément aléatoirement <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mo>≤</mo><mi>i</mi><mo separator="true">,</mo><msup><mi>i</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup><mo>≤</mo><mi>m</mi><mo separator="true">,</mo><mn>1</mn><mo>≤</mo><mi>j</mi><mo separator="true">,</mo><msup><mi>j</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup><mo>≤</mo><mi>n</mi></mrow><annotation encoding="application/x-tex">1 \le i, i'\le m, 1\le j, j' \le n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.78041em;vertical-align:-0.13597em;"></span><span class="mord">1</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.946332em;vertical-align:-0.19444em;"></span><span class="mord mathdefault">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathdefault">i</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.751892em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></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.8388800000000001em;vertical-align:-0.19444em;"></span><span class="mord mathdefault">m</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</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.946332em;vertical-align:-0.19444em;"></span><span class="mord mathdefault" style="margin-right:0.05724em;">j</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.05724em;">j</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.751892em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></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.43056em;vertical-align:0em;"></span><span class="mord mathdefault">n</span></span></span></span></span> tels que <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo mathvariant="normal">≠</mo><msup><mi>i</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow><annotation encoding="application/x-tex">i \neq i'</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathdefault">i</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel"><span class="mrel"><span class="mord"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.69444em;"><span style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="rlap"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="inner"><span class="mrel"></span></span><span class="fix"></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.19444em;"><span></span></span></span></span></span></span><span class="mrel">=</span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.751892em;vertical-align:0em;"></span><span class="mord"><span class="mord mathdefault">i</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.751892em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></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><mi>j</mi><mo mathvariant="normal">≠</mo><msup><mi>j</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow><annotation encoding="application/x-tex">j\neq j'</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathdefault" style="margin-right:0.05724em;">j</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel"><span class="mrel"><span class="mord"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.69444em;"><span style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="rlap"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="inner"><span class="mrel"></span></span><span class="fix"></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.19444em;"><span></span></span></span></span></span></span><span class="mrel">=</span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.946332em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.05724em;">j</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.751892em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span></span>.</li>
<li>Modifier <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>M</mi></mrow><annotation encoding="application/x-tex">M</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.10903em;">M</span></span></span></span></span> de la manière suivante : <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>M</mi><mrow><mi>i</mi><mi>j</mi></mrow></msub><mo>=</mo><msub><mi>M</mi><mrow><mi>i</mi><mi>j</mi></mrow></msub><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">M_{ij}=M_{ij}+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.969438em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">M</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:-0.10903em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></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.969438em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">M</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:-0.10903em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><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>, <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>M</mi><mrow><msup><mi>i</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup><mi>j</mi></mrow></msub><mo>=</mo><msub><mi>M</mi><mrow><msup><mi>i</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup><mi>j</mi></mrow></msub><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">M_{i'j}=M_{i'j}-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.969438em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">M</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32798em;"><span style="top:-2.5500000000000003em;margin-left:-0.10903em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6828285714285715em;"><span style="top:-2.786em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></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.969438em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">M</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32798em;"><span style="top:-2.5500000000000003em;margin-left:-0.10903em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6828285714285715em;"><span style="top:-2.786em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><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>, <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>M</mi><mrow><mi>i</mi><msup><mi>j</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow></msub><mo>=</mo><msub><mi>M</mi><mrow><mi>i</mi><msup><mi>j</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow></msub><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">M_{ij'}=M_{ij'}-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.969438em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">M</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32798em;"><span style="top:-2.5500000000000003em;margin-left:-0.10903em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mord mtight"><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6828285714285715em;"><span style="top:-2.786em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></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.969438em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">M</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32798em;"><span style="top:-2.5500000000000003em;margin-left:-0.10903em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mord mtight"><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6828285714285715em;"><span style="top:-2.786em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><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>, <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>M</mi><mrow><msup><mi>i</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup><msup><mi>j</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow></msub><mo>=</mo><msub><mi>M</mi><mrow><msup><mi>i</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup><msup><mi>j</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow></msub><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">M_{i'j'}=M_{i'j'}+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.969438em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">M</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32798em;"><span style="top:-2.5500000000000003em;margin-left:-0.10903em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6828285714285715em;"><span style="top:-2.786em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span><span class="mord mtight"><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6828285714285715em;"><span style="top:-2.786em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></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.969438em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">M</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32798em;"><span style="top:-2.5500000000000003em;margin-left:-0.10903em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6828285714285715em;"><span style="top:-2.786em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span><span class="mord mtight"><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6828285714285715em;"><span style="top:-2.786em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><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>.</li>
<li>Si une des cases 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>M</mi></mrow><annotation encoding="application/x-tex">M</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.10903em;">M</span></span></span></span></span> devient négative, revenir à l’ancien <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>M</mi></mrow><annotation encoding="application/x-tex">M</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.10903em;">M</span></span></span></span></span> (ne rien changer).</li>
</ul>
<hr>
<p>Pour générer une matrice sous contrainte (quasi-uniformément) aléatoirement :</p>
<ul>
<li>Partir de n’importe quelle matrice <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>M</mi></mrow><annotation encoding="application/x-tex">M</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.10903em;">M</span></span></span></span></span> respectant les contraintes</li>
<li>Répéter un très grand nombre de fois :<ul>
<li>Perturber <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>M</mi></mrow><annotation encoding="application/x-tex">M</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.10903em;">M</span></span></span></span></span></li>
</ul></li>
</ul>
<hr>
<p>Pour choisir ce "très grand nombre de fois", j’imagine que tu peux le faire expérimentalement. Les meilleurs résultats théoriques sur le temps de mélange de la chaîne de Markov de Diaconis et Gangolli sont à mon avis assez loin de la réalité.</p>Génération de matrices sous contraintes, message #2277752020-11-08T13:28:07+01:00Marius/@Mariushttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227775<p>Et bien et bien, je m’attendais pas à un tel enthousiasme !</p>
<p>Je ne vais pas pouvoir répondre à tout les messages par contre je suis désolé :/</p>
<p>En regardant à tête reposée le problème je me suis aussi dit que peut être c’était simplement un problème de programmation linéaire, donc peut être résoluble avec la méthode du simplexe, mais c’est sûrement de l’artillerie lourde pour pas grand chose.</p>
<p>Pour ce qui est de mélanger les lignes et les colonnes, ça devrait passer en faisant bouger des lignes et colonnes entières avec leurs contraintes associées :
Si on intervertit la ligne i avec la ligne j on intervertit aussi les contraintes <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>l</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">l_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</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>l</mi><mi>j</mi></msub></mrow><annotation encoding="application/x-tex">l_j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.980548em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight" style="margin-right:0.05724em;">j</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span></span> dans le tableau et idem pour les colonnes.</p>
<figure><blockquote>
<p>Il y a des contraintes sur les contraintes : </p>
<ul>
<li>la somme des Li est nécessairement égale à la somme des Ci.</li>
<li>chaque Li doit être supérieur ou égal à n</li>
<li>chaque Ci doit être supérieur ou égal à m</li>
</ul>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227767">etherpin</a></figcaption></figure>
<p>Effectivement je n’avais pas pensé à ces contraintes (quand on y pense c’est vrai qu’elles sont immédiates pourtant ^^' ), ma génération de contraintes ne les prenait pas en compte et pourtant ça marchait, sûrement un coup de chance</p>
<figure><blockquote>
<p>Ensuite, on peut partir d’une matrice triviale remplie de 1.<br>
on calcule Sc le tableau des sommes des colonnes et Sl le tableau des sommes des lignes.
On cherche le plus petit élément de Sc qui vérifie la contrainte, pareil pour Sl.
On ajoute 1’élément correspondant, et on recommence.</p>
<p>On s’arrête quand toutes les contraintes sont respectées.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227767">etherpin</a></figcaption></figure>
<p>Alors là j’avoue que je ne comprend pas l’algorithme, autant celui de <a href="/membres/voir/ache/" rel="nofollow" class="ping ping-link">@<span class="ping-username">ache</span></a> je vois l’idée même si la partie redistribution me semble plus compliquée à mettre en place.</p>
<figure><blockquote>
<p>Si pour chaque élément de la matrice on fait v[i, j] = l[i]*c[j]/total on arrive à une solution valide mais avec des nombres flottants, après il faut gérer l’arrondi.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227772">fromvega</a></figcaption></figure>
<p>Le problème va justement être avec l’arrondi je pense, on n’est obligé de gérer les deux contraintes pour chaque case en parallèle. Du coup à chaque fois les valeurs risquent de potentiellement se propager dans toute la matrice et ça devient tout de suite un algorithme avec une forte complexité.</p>
<figure><blockquote>
<p>Normalement en utilisant le formalisme de la transformée Mojette.</p>
<p>Les contraintes deviennent qu’à partir des projections selon le vecteur <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(0, 1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mclose">)</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>l</mi><mi>n</mi></msub></mrow><annotation encoding="application/x-tex">l_n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</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.01968em;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>) et le vecteur <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">0</span><span class="mclose">)</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>c</mi><mi>m</mi></msub></mrow><annotation encoding="application/x-tex">c_m</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">c</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:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">m</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>).</p>
<p>Ils nous manque bien sûr des projections (sauf dans le cas où n = m = 2) puisque selon le lemme de Katz la convolution des fantômes correspondant tiens dans le support (la matrice).</p>
<p>Je me demande si ajouter des projections jusqu’à que la convolution des fantômes des vecteurs remplisse l’espace du support donnerait un résultat cohérent.</p>
<p>Je suppose que oui mais il faudrait avoir certaines conditions pour que le résultat soit positif, sans quoi et bien il ne le sera pas :/</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227774">ache</a></figcaption></figure>
<p>Là je suis complètement perdu mais je vais regarder un peu ce dont tu parles ça me semble intéressant !</p>
<p>Finalement j’ai trouvé une solution, un peu idiote, mais qui fonctionne en changeant mon problème.</p>
<p>Dans mon problème je devais générer des instances composées des triplets suivants :</p>
<ul>
<li>Contrainte lignes</li>
<li>Contrainte colonnes</li>
<li>Matrice sous contrainte</li>
</ul>
<p>Le problème se posait du fait que je générais les contraintes d’abord, puis tentait de générer la matrice ensuite. Mais si je génère juste les contraintes de lignes, puis la matrice qui les satisfait (chaque ligne aléatoirement qui respectent la contrainte ligne) alors les contraintes colonnes sont elles aussi générées automatiquement (il suffit de sommer les colonnes de la matrice).</p>
<p>Finalement c’était juste une question de point de vue. <img src="/static/smileys/svg/clin.svg" alt=";)" class="smiley"></p>
<p>Par contre je vais continuer à regarder le problème de la génération avec tout ce que vous m’avez dit, ça me semble intéressant à poser comme autre problème !</p>Génération de matrices sous contraintes, message #2277742020-11-08T13:08:11+01:00ache/@achehttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227774<p>Normalement en utilisant le formalisme de la transformée Mojette.</p>
<p>Les contraintes deviennent qu’à partir des projections selon le vecteur <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(0, 1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mclose">)</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>l</mi><mi>n</mi></msub></mrow><annotation encoding="application/x-tex">l_n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</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.01968em;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>) et le vecteur <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">0</span><span class="mclose">)</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>c</mi><mi>m</mi></msub></mrow><annotation encoding="application/x-tex">c_m</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">c</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:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">m</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>).</p>
<p>Ils nous manque bien sûr des projections (sauf dans le cas où n = m = 2) puisque selon le lemme de Katz la convolution des fantômes correspondant tiens dans le support (la matrice).</p>
<p>Je me demande si ajouter des projections jusqu’à que la convolution des fantômes des vecteurs remplisse l’espace du support donnerait un résultat cohérent.</p>
<p>Je suppose que oui mais il faudrait avoir certaines conditions pour que le résultat soit positif, sans quoi et bien il ne le sera pas :/</p>Génération de matrices sous contraintes, message #2277722020-11-08T11:58:17+01:00fromvega/@fromvegahttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227772<p>Si pour chaque élément de la matrice on fait v[i, j] = l[i]*c[j]/total on arrive à une solution valide mais avec des nombres flottants, après il faut gérer l’arrondi.</p>
<p>Exemple avec 5 lignes / 4 colonnes</p>
<div class="hljs-code-div hljs-code-bash"><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></div><pre><code class="hljs language-bash">Sommes de chaque ligne
30
22
24
19
27
Sommes de chaque colonne
36 26 31 29
Total 122
Valeurs calculées
8.852 6.393 7.623 7.131
6.492 4.689 5.590 5.230
7.082 5.115 6.098 5.705
5.607 4.049 4.828 4.516
7.967 5.754 6.861 6.418
</code></pre></div>
<p>EDIT: bon ça donne des valeurs plutôt "pondérées", si on veut que cela paraissent plus aléatoire on peut éventuellement appliquer un offset +/- à chaque valeur dont la somme est nulle en ligne / colonne.</p>Génération de matrices sous contraintes, message #2277672020-11-07T23:12:41+01:00etherpin/@etherpinhttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227767<p>Il y a des contraintes sur les contraintes : </p>
<ul>
<li>la somme des Li est nécessairement égale à la somme des Ci.</li>
<li>chaque Li doit être supérieur ou égal à n</li>
<li>chaque Ci doit être supérieur ou égal à m</li>
</ul>
<p>Il faut commencer par vérifier que les contraintes peuvent être respectées.</p>
<p>Ensuite, on peut partir d’une matrice triviale remplie de 1.<br>
on calcule Sc le tableau des sommes des colonnes et Sl le tableau des sommes des lignes.
On cherche le plus petit élément de Sc qui vérifie la contrainte, pareil pour Sl.
On ajoute 1’élément correspondant, et on recommence.</p>
<p>On s’arrête quand toutes les contraintes sont respectées.</p>Génération de matrices sous contraintes, message #2277642020-11-07T21:45:54+01:00ache/@achehttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227764<p>Échanger deux colonnes ne devrait pas poser de problèmes si ?<br>
Pareil pour les lignes ?</p>
<p>En échangeant aléatoirement des lignes on les mélanges et pareils ensuite pour les colonnes ?</p>
<p>Ah oui, je vois, ça échange également les contraintes des deux lignes échangées. (╥_╥)
Pareil pour les colonnes. :/</p>Génération de matrices sous contraintes, message #2277632020-11-07T21:43:19+01:00adri1/@adri1https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227763<blockquote>
<p>Au pire, à la fin tu peux mélanger les lignes et les colonnes.</p>
</blockquote>
<p>Heu… Comment tu fais ça ? A priori les <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>l</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">l_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</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>c</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">c_i</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">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><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 mathdefault mtight">i</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> sont différents les uns des autres…</p>Génération de matrices sous contraintes, message #2277622020-11-07T21:36:07+01:00ache/@achehttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227762<p>Peu importe pour le fais que ça semble aléatoire ou non.
Au pire, à la fin tu peux mélanger les lignes et les colonnes.</p>
<p>Après, pour une suite de <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span></span> puis <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>l</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">l_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</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> oui bon ça aide pas de mélanger.</p>Génération de matrices sous contraintes, message #2277612020-11-07T20:13:05+01:00adri1/@adri1https://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227761<p>Salut,</p>
<p>À ta place je créerais une matrice <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>m</mi><mo>−</mo><mn>1</mn><mo stretchy="false">)</mo><mo>×</mo><mo stretchy="false">(</mo><mi>n</mi><mo>−</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(m-1)\times (n-1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathdefault">m</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:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">)</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:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathdefault">n</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:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span></span>, remplie de nombres entiers aléatoires positif, puis je complèterai la colonne et la ligne manquantes avec des nombres (possiblement negatifs) qui respectent les contraintes. Les deux dernières contraintes donnent le terme dans le coin final (si une grille vérifiant les contraintes existe, ce qui n’est pas le cas général d’ailleurs, il faut déjà que la somme des contraintes soit la même dans les deux directions). Ensuite il ne reste plus qu’à redistribuer les valeurs négatives en repércutant les changements à la fois sur les lignes et les colonnes pour ne pas perdre le respect des contraintes. Si c’est impossible à un moment de rester positif partout, c’est que la grille n’a pas de solution…</p>Génération de matrices sous contraintes, message #2277602020-11-07T19:01:55+01:00Marius/@Mariushttps://zestedesavoir.com/forums/sujet/14707/generation-de-matrices-sous-contraintes/?page=1#p227760<p>Bonjour les zestotifiques ! <img src="/static/smileys/svg/smile.svg" alt=":)" class="smiley"> </p>
<p>Pour un petit problème que j’ai imaginé, je dois générer des matrices qui respectent des contraintes sur chaque ligne et chaque colonne. J’avais une idée d’algorithme qui me semblait marcher mais impossible de le mettre en oeuvre en python.</p>
<p>Je viens donc vous quémander de l’aide, car sinon je vais rester bloqué et je n’ai pas envie d’écrire ces matrices à la main. <img src="/static/smileys/svg/triste.svg" alt=":(" class="smiley"></p>
<p>Mon problème donc, je dispose de mes contraintes (toujours des nombres entiers strictement positifs) :</p>
<ul>
<li>un tableau de contraintes pour les lignes : [<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>l</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>l</mi><mn>1</mn></msub><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><msub><mi>l</mi><mrow><mi>m</mi><mo>−</mo><mn>1</mn></mrow></msub></mrow><annotation encoding="application/x-tex">l_0,l_1... l_{m-1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.902771em;vertical-align:-0.208331em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</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.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</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="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</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.01968em;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 class="mord">.</span><span class="mord">.</span><span class="mord">.</span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.301108em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">m</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.208331em;"><span></span></span></span></span></span></span></span></span></span></span>]</li>
<li>un tableau de contraintes pour les colonnes : [<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>c</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>c</mi><mn>1</mn></msub><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><msub><mi>c</mi><mrow><mi>n</mi><mo>−</mo><mn>1</mn></mrow></msub></mrow><annotation encoding="application/x-tex">c_0,c_1...c_{n-1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.638891em;vertical-align:-0.208331em;"></span><span class="mord"><span class="mord mathdefault">c</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">0</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="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathdefault">c</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 class="mord">.</span><span class="mord">.</span><span class="mord">.</span><span class="mord"><span class="mord mathdefault">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.301108em;"><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"><span class="mord mathdefault mtight">n</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.208331em;"><span></span></span></span></span></span></span></span></span></span></span>]</li>
<li>avec <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>m</mi><mo>></mo><mo>=</mo><mi>n</mi></mrow><annotation encoding="application/x-tex">m>=n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5782em;vertical-align:-0.0391em;"></span><span class="mord mathdefault">m</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">></span></span><span class="base"><span class="strut" style="height:0.36687em;vertical-align:0em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">n</span></span></span></span></span></li>
</ul>
<p>Et j’aimerais générer une matrice telle que:</p>
<ul>
<li>Pour chaque ligne <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathdefault">i</span></span></span></span></span>,la somme de la ligne <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathdefault">i</span></span></span></span></span> est égale à <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>l</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">l_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</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>Pour chaque colonne <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathdefault">i</span></span></span></span></span>, la somme de la colonne <span class="math math-inline"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathdefault">i</span></span></span></span></span> est égale à <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>c</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">c_i</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">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><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 mathdefault mtight">i</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>
</ul>
<p>Ah oui, il faudrait que les éléments de ma matrice semblent aléatoires, donc pas juste une suite de 0 puis <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>l</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">l_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</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> par exemple.</p>
<p>Pour ça j’avais pensé à l’algorithme suivant :</p>
<div class="hljs-code-div hljs-code-scheme"><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-scheme">Pour i=<span class="hljs-number">0</span> à m<span class="hljs-number">-1</span>:
l' <- séquence aléatoire de m<span class="hljs-number">-1</span>-i éléments avec leur somme = l_i
matrice[<span class="hljs-name">i</span>][<span class="hljs-name">i:</span>] = l'
contrainte_colonne = contrainte_colonne - l'
c' <- séquence aléatoire de n<span class="hljs-number">-2</span>-i éléments avec leur somme = c_i
matrice[<span class="hljs-name">:</span>][<span class="hljs-name">i+1:</span>] <- c'
contrainte_ligne = contrainte_ligne - c'
</code></pre></div>
<p>Malheureusement mon implémentation ne fonctionne pas à cause de mes séquences qui ne font pas la même taille entre autres.</p>
<p>Voici un extrait en python 3 avec numpy :</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-keyword">for</span> i <span class="hljs-keyword">in</span> range(m):
line = np.array(random_ints_with_sum(contrainte_ligne[i],max_length=m<span class="hljs-number">-1</span>-i))
mat[i][i:] = line
contrainte_ligne -= line
col = np.array(random_ints_with_sum(contrainte_colonne[i],max_length=n<span class="hljs-number">-2</span>-i))
mat = mat.transpose()
mat[i][i+<span class="hljs-number">1</span>:] = col
mat = mat.transpose()
contrainte_colonne -= col
</code></pre></div>
<p>Est ce que vous auriez des idées pour améliorer cet algorithme / le corriger / en trouver un qui marche mieux ?</p>
<p>Merci d’avance !</p>Vecteurs propres d’une matrice, message #1903422018-10-02T21:25:03+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/11381/vecteurs-propres-dune-matrice/?page=2#p190342<p>Ni l’un, ni l’autre. C’est plus justement du point de vue pratique que théorique (ce pourquoi je parle de méthode) que d’une part le calcul du déterminant n’est pas évident à généraliser et d’autre part que les termes non diagonaux étant nul, des termes disparaissent du calcul et cachent sa lecture générale.</p>