Herausforderung

Bei einer links- oder rechtsstochastischen Matrix, bei der sich die Grenze, wenn sich x der Unendlichkeit der Matrix nähert, der Potenz von x einer Matrix mit allen endlichen Werten nähert, die Matrix zurückgeben, zu der die Matrix konvergiert. Grundsätzlich möchten Sie die Matrix so lange mit sich selbst multiplizieren, bis sich das Ergebnis nicht mehr ändert.

Testfälle

[[7/10, 4/10], [3/10, 6/10]] -> [[4/7, 4/7], [3/7, 3/7]]
[[2/5, 4/5], [3/5, 1/5]] -> [[4/7, 4/7], [3/7, 3/7]]
[[1/2, 1/2], [1/2, 1/2]] -> [[1/2, 1/2], [1/2, 1/2]]
[[1/3, 2/3], [2/3, 1/3]] -> [[1/2, 1/2], [1/2, 1/2]]
[[1/10, 2/10, 3/10], [4/10, 5/10, 6/10], [5/10, 3/10, 1/10]] -> [[27/130, 27/130, 27/130], [66/130, 66/130, 66/130], [37/130, 37/130, 37/130]]
[[1/7, 2/7, 4/7], [2/7, 4/7, 1/7], [4/7, 1/7, 2/7]] -> [[1/3, 1/3, 1/3], [1/3, 1/3, 1/3], [1/3, 1/3, 1/3]]

Regeln

• Standardschlupflöcher gelten
• Sie können wählen, ob Sie eine rechts- oder eine linksstochastische Matrix wünschen
• Sie können jeden vernünftigen Zahlentyp verwenden, z. B. Gleitkommazahlen, Rationals, Dezimalstellen mit unendlicher Genauigkeit usw.
• Dies ist Code-Golf , daher wird die kürzeste Übermittlung in Bytes für jede Sprache zum Gewinner ihrer Sprache erklärt. Es wird keine Antwort akzeptiert

R ,  44  43 Bytes

function(m){X=m
while(any(X-(X=X%*%m)))0
X}

Probieren Sie es online aus!

Multipliziert einfach weiter, bis eine feste Matrix gefunden wird. Anscheinend X!=(X=X%*%m)führt der Vergleich dann eine Neuzuweisung durch X, das ist also ordentlich.

Vielen Dank an @Vlo für das Rasieren eines Bytes. obwohl durchgestrichen 44 ist immer noch regulär 44.

Oktave ,45 42 35 Bytes

@(A)([v,~]=eigs(A,1))/sum(v)*any(A)

Probieren Sie es online aus!

3 Bytes dank Giuseppe und 7 weitere dank Luis Mendo!

Dies verwendet, dass der dem Eigenwert 1 entsprechende Eigenvektor (auch der maximale Eigenwert) der Spaltenvektor ist, der für jeden Wert der Grenzmatrix wiederholt wird. Wir müssen den Vektor normalisieren, um die Summe 1 zu haben, damit er stochastisch ist. Dann wiederholen wir ihn einfach, um die Matrix auszufüllen. Ich bin nicht besonders gut mit dem Golfen von Octave vertraut, aber ich konnte keinen funktionalen Weg finden, um wiederholte Multiplikationen durchzuführen, und ein vollständiges Programm scheint immer länger zu sein.

Wir können verwenden, any(A)da wir aufgrund der Einschränkungen wissen, dass die Matrix eine irreduzible Markov-Kette beschreiben muss und daher jeder Zustand von den anderen Zuständen aus erreichbar sein muss. Daher muss mindestens ein Wert in jeder Spalte ungleich Null sein.

Wolfram Language (Mathematica) , 14 Bytes

Ausgabe schwebt:

N@#//.x_:>x.#&

Probieren Sie es online aus!

Wolfram Language (Mathematica) , 30 Bytes

Ausgabefraktionen:

Limit[#~MatrixPower~n,n->∞]&

Probieren Sie es online aus!

Gelee , 6 Bytes

æ׳$ÐL

Dies ist ein vollständiges Programm.

Probieren Sie es online aus!

APL (Dyalog) , 18 6 Bytes

12 Bytes dank @ H.PWiz gespeichert

+.×⍨⍣≡

Probieren Sie es online aus!

k / q, 10 Bytes

k / q, weil das Programm in beiden Sprachen identisch ist. Der Code ist wirklich nur idiomatisch k / q.

{$[x]/[x]}

Erläuterung

{..}ist aus Lambda-Syntax, mit xals impliziter Parameter

$[x] hat $ als Multiplikationsoperator für die binäre Matrix. Wenn nur ein Parameter angegeben wird, wird ein unärer Operator erstellt, der Multiplikationen mit der Markov-Matrix hinterlässt

/[x] wendet die linke Multiplikation bis zur Konvergenz an, beginnend mit x selbst.

C (gcc) , 207 192 190 181 176 Bytes + 2 Flagbytes-lm

• Gespeichert fünfzehn siebzehn zwanzig-zwei Bytes dank ceilingcat .
• Neun Bytes gespeichert; entfernen return A;.

float*f(A,l,k,j)float*A;{for(float B[l*l],S,M=0,m=1;fabs(m-M)>1e-7;wmemcpy(A,B,l*l))for(M=m,m=0,k=l*l;k--;)for(S=j=0;j<l;)m=fmax(m,fdim(A[k],B[k]=S+=A[k/l*l+j]*A[k%l+j++*l]));}

Probieren Sie es online aus!

Python 3 , 75 61 Bytes

f=lambda n:n if allclose(n@n,n)else f(n@n)
from numpy import*

Probieren Sie es online aus!

In Testfällen treten Float-Ungenauigkeiten auf, sodass die Werte geringfügig von den genauen Brüchen abweichen können.

PS. numpy.allclose()wird verwendet, weil numpy.array_equal()es länger ist und zu Ungenauigkeiten neigt.

-14 Bytes Danke HyperNeutrino;) Oh ja, ich habe den @ -Operator vergessen; P.

Java 8, 356 339 Bytes

import java.math.*;m->{BigDecimal t[][],q;RoundingMode x=null;for(int l=m.length,f=1,i,k;f>0;m=t.clone()){for(t=new BigDecimal[l][l],i=l*l;i-->0;)for(f=k=0;k<l;t[i/l][i%l]=(q!=null?q:q.ZERO).add(m[i/l][k].multiply(m[k++][i%l])))q=t[i/l][i%l];for(;++i<l*l;)f=t[i/l][i%l].setScale(9,x.UP).equals(m[i/l][i%l].setScale(9,x.UP))?f:1;}return m;}

-17 Bytes dank @ceilingcat .

Auf jeden Fall nicht die richtige Sprache. Verdammte Gleitkommapräzision.

Erläuterung:

Probieren Sie es online aus.

import java.math.*;     // Required import for BigDecimal and RoundingMode
m->{                    // Method with BigDecimal-matrix as both parameter and return-type
  BigDecimal t[][],q;   //  Temp BigDecimal-matrix
  RoundingMode x=null;  //  Static RoundingMode value to reduce bytes
  for(int l=m.length,   //  The size of the input-matrix
          f=1,          //  Flag-integer, starting at 1
          i,k;          //  Index-integers
      f>0;              //  Loop as long as the flag-integer is still 1
      m=t.clone()){     //    After every iteration: replace matrix `m` with `t`
    for(t=new BigDecimal[l][l],
                        //   Reset matrix `t`
        i=l*l;i-->0;)   //   Inner loop over the rows and columns
      for(f=k=0;        //    Set the flag-integer to 0
          k<l           //    Inner loop to multiply
          ;             //      After every iteration:
           t[i/l][i%l]=(q!=null?q:q.ZERO).add(
                        //       Sum the value at the current cell in matrix `t` with:
             m[i/l][k]  //        the same row, but column `k` of matrix `m`,
             .multiply(m[k++][i%l])))
                        //        multiplied with the same column, but row `k` of matrix `m`
        q=t[i/l][i%l];  //     Set temp `q` to the value of the current cell of `t`
    for(;++i<l*l;)      //   Loop over the rows and columns again
      f=t[i/l][i%l].setScale(9,x.UP).equals(m[i/l][i%l].setScale(9,x.UP))?
                        //    If any value in matrices `t` and `m` are the same:
         f              //     Leave the flag-integer unchanged
        :               //    Else (they aren't the same):
         1;}            //     Set the flag-integer to 1 again
  return m;}            //  Return the modified input-matrix `m` as our result