एक मार्कोव प्रक्रिया का अभिसरण

10

चुनौती

एक बाएं या दाएं-स्टोचस्टिक मैट्रिक्स को देखते हुए जहां x के रूप में मैट्रिक्स की अनंतता के लिए सीमा एक्स की शक्ति के लिए सभी परिमित मूल्यों के साथ एक मैट्रिक्स से संपर्क करती है, उस मैट्रिक्स को वापस कर देती है जिसमें मैट्रिक्स परिवर्तित होता है। असल में, आप मैट्रिक्स को अपने आप से गुणा करना चाहते हैं जब तक कि परिणाम में परिवर्तन न हो।

परीक्षण के मामलों

[[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]]

नियम

  • स्टैंडर्ड लोफॉल्स लागू होते हैं
  • आप चुन सकते हैं कि क्या आप एक सही-या एक बाईं-स्टोचस्टिक मैट्रिक्स चाहते हैं
  • आप किसी भी उचित संख्या प्रकार का उपयोग कर सकते हैं, जैसे कि फ़्लोट्स, तर्कसंगत, अनंत सटीक दशमलव, आदि
  • यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा के लिए बाइट्स में सबसे कम प्रस्तुत करने वाले को इसकी भाषा के लिए विजेता घोषित किया जाता है। कोई उत्तर स्वीकार नहीं किया जाएगा
code-golf  matrix 
— HyperNeutrino
स्रोत
@FryAmTheEggman ऐसा लगता है कि कुछ पहले की टिप्पणियों को हटा दिया गया है, इसलिए यह निरर्थक हो सकता है, लेकिन reducible और आवधिक मैट्रिक्स पहले से ही "छोड़ दिया-या दाएं-स्टोकेस्टिक मैट्रिक्स" को देखते हुए बाहर रखा गया है, जहां एक्स के रूप में सीमा मैट्रिक्स के अनंत तक पहुंच जाती है। एक्स सभी परिमित मूल्यों के साथ एक मैट्रिक्स के पास पहुंचता है ", जो मैं कहता हूं कि इनपुट एक अद्वितीय समाधान के लिए अभिसरण की गारंटी है। (यानी इनपुट मैट्रिक्स को क्षीण होने की गारंटी है।)
— नथानिएल
@ नथनियल यह बिल्कुल सच नहीं है, जैसे कि श्रृंखला फिर से चालू है, तो आपके पास एक परिणाम हो सकता है (जैसे पहचान मैट्रिक्स के लिए) जो आपके द्वारा कहे गए से मिलता है, लेकिन यह जो श्रृंखला का वर्णन करता है वह अप्रासंगिक नहीं है और इसलिए इनपुट की गारंटी नहीं होगी ergodic हो (क्योंकि यह सकारात्मक आवर्तक नहीं होगा)। Ergodicity की गारंटी देना ओपी चाहता है, और मुझे लगता है कि उनके पास अब है, पंक्ति मूल्यों के सभी के अतिरिक्त अवरोध के लिए धन्यवाद। यदि आप मार्कोव श्रृंखलाओं के स्पष्टीकरण को जोड़ने की आवश्यकता के बिना इनपुट को बाधित करने का एक बेहतर तरीका जानते हैं, तो मुझे यकीन है कि हाइपरएनेट्रिनो इसकी सराहना करेंगे! :)
— FryAmTheEggman
1
@FryAmTheEggman आह, आप सही हैं, क्षमा करें। मैं मैट्रिक्स को पावर बढ़ाने के बजाय पावर इटरेशन के बारे में सोच रहा था। (तो "अद्वितीय समाधान" से मेरा मतलब था "एक जो कि पुनरावृत्ति प्रक्रिया के शुरुआती बिंदु से स्वतंत्र है", लेकिन यह यहां प्रासंगिक नहीं है।) मैं मानता हूं कि 'सभी पंक्तियां समान हैं' स्थिति काम करती है। मुझे लगता है कि ओपी यह कह सकता है कि "मार्कोव श्रृंखला को क्षीण होने की गारंटी है," जो हमारे जैसे लोगों को संतुष्ट करेगा जो इसके बारे में चिंता करने की संभावना है!
— नथानिएल
वास्तव में, अगर बी के लिए एक समाधान है बीए = बी , तो है सीबी किसी भी अदिश निरंतर के लिए ग । एक गैर-शून्य समाधान कड़ाई से अद्वितीय नहीं हो सकता, जब तक कि आप किसी तरह पैमाने को ठीक न करें। ( बी को स्टोचस्टिक होने की आवश्यकता होगी।) इसके अलावा, स्पष्ट रूप से, कि क्या इसकी पंक्तियाँ या बी के कॉलम समान हैं, यह इस बात पर निर्भर करेगा कि ए बाएं या दाएं स्टोचस्टिक है या नहीं।
— इल्मरी करोनें
2
किसी और के लिए जो हाई स्कूल में मैथ-क्लास के दौरान मैट्रिक के बारे में कभी नहीं सीख पाया और उन्हें कैसे गुणा करना है: mathsisfun.com/algebra/matrix-multiplying.html । मुझे यह समझने के लिए इसे देखना था कि क्या पूछा जा रहा है .. शायद यह पृथ्वी पर कहीं और सामान्य ज्ञान है:: एस
— केविन क्रूज़सेन

जवाबों:

7

आर ,  44  43 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बस तब तक गुणा करना रहता है जब तक कि यह एक निश्चित मैट्रिक्स न मिल जाए। जाहिरा तौर X!=(X=X%*%m)पर तुलना करता है, फिर आश्वस्त करता है X, इसलिए यह साफ है।

एक बाइट को शेव करने के लिए @Vlo का धन्यवाद; भले ही ४४ को पार कर लिया गया हो लेकिन अभी भी नियमित ४४ है।

— ग्यूसेप
स्रोत
1
मुझे आश्चर्य है कि क्यों function(m){ while(any(m!=(m=m%*%m)))0 m}काम नहीं करता है न्यूमेरिकल अशुद्धियाँ ट्रिगर होने से समाप्ति की स्थिति को रोकती हैं?
— कोडइन्चोस
@CodesInChaos सबसे अधिक संभावना है कि यह परिशुद्धता की कमी है। मनमाने ढंग से सटीक लाइब्रेरी में जाने से या तो मदद नहीं मिलती है - या तो वे उसी समय (Rmpfr) या फेल (gmp) एक ही तरीके से करते हैं, हालाँकि मैं शायद कुछ गलत कर रहा हूँ।
— Giuseppe
@Giuseppe मुझे लगता है कि सुझाव दिया दृष्टिकोण दोहराया जा रहा है जब तक कोई परिवर्तन नहीं? (मैं आर नहीं पढ़ सकता)
— user202729
@ user202729 हाँ, यह है। आर 64-बिट फ्लोटिंग पॉइंट नंबरों का उपयोग करता है और मुझे पता है कि त्रुटियां बहुत जल्दी फैलती हैं।
— Giuseppe
मुझे लगता है कि एल्गोरिथ्म अस्थिर है। जेली की भी यही समस्या है। (TODO इसे साबित करता है और एक विकल्प
— ढूंढता है
5

सप्तक ,45 42 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Giuseppe के लिए 3 बाइट्स, और लुइस मेंडो के लिए 7 और धन्यवाद धन्यवाद बचा!

यह उपयोग करता है कि eigenvector 1 के लिए इसी eigenvector (अधिकतम eigenvalue) स्तंभ वेक्टर है जो सीमित मैट्रिक्स के प्रत्येक मूल्य के लिए दोहराया जाता है। हमें स्टोचस्टिक होने के लिए वेक्टर को सामान्य करने के लिए 1 का योग करना पड़ता है, फिर हम मैट्रिक्स को भरने के लिए इसे दोहराते हैं। मैं बहुत अच्छी तरह से गोल्फिंग ऑक्टेव में निपुण नहीं हूं, लेकिन मैं बार-बार गुणा करने का एक कार्यात्मक तरीका नहीं खोज पाया हूं, और एक पूर्ण कार्यक्रम ऐसा लगता है कि यह हमेशा इससे अधिक लंबा होगा।

हम उन any(A)प्रतिबंधों के बाद से उपयोग कर सकते हैं जिन्हें हम जानते हैं कि मैट्रिक्स को एक इरोड्यूसबल मार्कोव श्रृंखला का वर्णन करना चाहिए, और इसलिए प्रत्येक राज्य को अन्य राज्यों से पहुंच योग्य होना चाहिए। इसलिए प्रत्येक कॉलम में कम से कम एक मूल्य गैर-शून्य होना चाहिए।

— FryAmTheEggman
स्रोत
eigsहमेशा इसी के अनुरूप आइजन्वेक्टर कैसे वापस करता है 1? मार्कोव चेन्स की मेरी मेमोरी थोड़ी फजी है।
— ग्यूसेप
— Giuseppe
@Giuseppe क्योंकि मैट्रिक्स स्टोचस्टिक है, और कुछ अन्य चीजें, इसका अधिकतम eigenvalue 1 है, और eigsसबसे बड़ा eigenvalue से शुरू होता है। इसके अलावा, गोल्फ के लिए धन्यवाद!
— फ्राईमईएग्गमैन
ओह सही। मार्कोव श्रृंखलाएं मेरी अगली परीक्षा में हैं, लेकिन चूंकि यह अभिनेताओं के लिए है, इसलिए कुछ विवरण पूरी तरह से गायब हैं।
— ग्यूसेप
3

एपीएल (डायलॉग) , 18 6 बाइट्स

12 बाइट्स ने @ H.PWiz को धन्यवाद दिया

+.×⍨⍣≡

इसे ऑनलाइन आज़माएं!

— Uriel
स्रोत
+.×⍨⍣≡6 बाइट्स के लिए। वह है, जब तक कुछ भी नहीं बदलता है
— H.PWiz
@ H.PWiz मेरा मानना ​​है कि यह है। मुझे नहीं पता कि मैंने इसे पहले स्थान पर क्यों नहीं किया। धन्यवाद!
— ऊरीएल
3

k / q, 10 बाइट्स

k / q क्योंकि प्रोग्राम दोनों भाषाओं में समान है। कोड वास्तव में सिर्फ मुहावरेदार कश्मीर / q है।

{$[x]/[x]}

व्याख्या

{..}xएक अनुमानित पैरामीटर के रूप में , लैम्ब्डा सिंटैक्स है

$[x] बाइनरी मैट्रिक्स गुणन ऑपरेटर के रूप में $ है, केवल एक पैरामीटर प्रदान करने से एक एकीकृत ऑपरेटर बन जाता है जो मार्कोव मैट्रिक्स द्वारा कई गुना छोड़ देता है

/[x] अभिसरण तक बाएं गुणन को लागू करता है, x से ही शुरू होता है।

— ulucs
स्रोत
3

C (gcc) , 207 192 190 181 176 बाइट्स + 2 फ्लैग बाइट्स-lm

  • सहेजे गए पंद्रह सत्रह बीस-दो बाइट के लिए धन्यवाद ceilingcat ।
  • नौ बाइट्स बचाए; निकाल रहा है 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]));}

इसे ऑनलाइन आज़माएं!

— जोनाथन फ्रेच
स्रोत
@ceilingcat कंपाइलर फ्लैग बाइट्स की गिनती करते हुए, यह 192 में फिर से परिणाम देता है। फिर भी अपने सुझाव को शामिल करें।
— जोनाथन फ्रीच
@ceilingcat धन्यवाद।
— जोनाथन फ्रीच
2

पायथन 3 , 75 61 बाइट्स

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

इसे ऑनलाइन आज़माएं!

परीक्षण के मामलों में फ्लोट की अशुद्धि होती है, इसलिए मान सटीक भिन्न से थोड़ा भिन्न हो सकते हैं।

पुनश्च। numpy.allclose()उपयोग किया जाता है क्योंकि numpy.array_equal()लंबे समय तक रहता है और अशुद्धियों को तैरने का खतरा होता है।

-14 बाइट्स हाइपरनेटायरिनो;) अरे हाँ मैं @ ऑपरेटर भूल गया; पी

— शायरु असकोतो
स्रोत
dotइसके बजाय का उपयोग करें matmul: D
— HyperNeutrino
वास्तव में, इनपुट के रूप में संख्यात्मक सरणियां लें और ऐसा करें x=n@n: P tio.run/…
— HyperNeutrino
— हाइपरनेत्रिनो
f=आगे पीछे जोड़ा गया क्योंकि इसे पुनरावर्ती कहा जाता है;)
— शायरु असाकोतो
अरे हाँ तुम सही हो :) अच्छी कॉल!
— हाइपरनेत्रिनो
2

जावा 8, 356 339 बाइट्स

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 बाइट्स @ceilingcat की बदौलत ।

निश्चित रूप से सही भाषा नहीं .. धिक्कार है फ़्लोटिंग पॉइंट प्रिसिजन ।।

स्पष्टीकरण:

इसे ऑनलाइन आज़माएं।

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
— केविन क्रूज़सेन
स्रोत
मुख्य क्रिया इतनी क्रिया क्यों है?
— user202729
@ user202729 क्योंकि float/ doubleउचित चल बिन्दु परिशुद्धता की जरूरत नहीं है, java.math.BigDecimalबजाय प्रयोग किया जाना चाहिए। और इसके बजाय बस +-*/, BigDecimals का उपयोग करें.add(...) , .subtract(...), .multiply(...), .divide(...)। तो बस के रूप में कुछ 7/10बन जाता है new BigDecimal(7).divide(new BigDecimal(10))। इसके अलावा, ,scale,RoundingModeमें divide'अनंत' दशमलव मान (जैसे के साथ मूल्यों के लिए आवश्यक हैं 1/3किया जा रहा है 0.333...)। मुख्य विधि निश्चित रूप से गोल्फ हो सकती है, लेकिन मैं परेशान नहीं हुआ जब मैंने एक खोज की और BigDecimals में फ़्लोट्स को बदलने के लिए प्रतिस्थापित किया।
— केविन क्रूज़सेन
@ceilingcat धन्यवाद!
— केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.