अपरिमेय संख्या में भग्न। भाग २

भाग ०: अभाज्य संख्याओं में भिन्नता।
भाग 1: तर्कहीन संख्याओं में भिन्नता।



लेख में Gif और विषम चित्र शामिल हैं। मिर्गी के दौरे में मिर्गी का दौरा पड़ सकता है।

पिछले लेख में, हमने एक बाइनरी अनुक्रम विज़ुअलाइज़ेशन एल्गोरिदम को देखा। याद करते हैं।

बाइनरी अनुक्रम लें। एक उदाहरण के रूप में, पिछले लेख में चर्चा की गई भग्न अनुक्रम के पहले कुछ अंश:

$$

$$Q_n = \ lfloor n \ sqrt {2} \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ...$$

0100110110010011001001101100

हम एक वर्ग सेल फ़ील्ड बनाते हैं। हम बिट्स को ऊपरी सीमा पर सेट करते हैं। बिट्स के बीच की दूरी दो कोशिकाएं हैं:



प्रत्येक बिट के लिए, विकर्ण (सेल के माध्यम से) के साथ एक धराशायी रास्ता खींचें। शून्य के लिए, पहले स्ट्रोक को दाईं ओर खींचें:



इकाइयों के लिए - बाईं ओर:



प्रत्येक बिट के लिए एक प्रक्षेपवक्र ड्रा। हमें एक "बिलियर्ड" पैटर्न मिला:



एक समान पैटर्न (एक विकर्ण दोष के बिना - अनुक्रम अनंत है, हमने इसे अंतिम अनुक्रम के रूप में कल्पना की) दूसरे तरीके से प्राप्त किया जा सकता है। अनुक्रम में भी हर पल उलटा:

0 0 0 1 1 0 0 0 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 1 0 0 1 1

अगला, प्रत्येक बिट के लिए, लंबवत धराशायी रेखाएँ खींचें:



हम बिट्स को बाईं ओर सेट करते हैं, क्षैतिज रेखाएँ खींचते हैं:



हम गठबंधन करते हैं:



पहला लेख लिखने के बाद, दो प्रश्न अनसुलझे रहे:

1. क्या तर्कहीन संख्याओं के लिए एक फ्रैक्टल पैटर्न खींचना संभव है। आप कर सकते हैं। पिछले आलेख में समस्या हल हो गई थी। ऊपर की तस्वीर में - के लिए भग्न पैटर्न का हिस्सा $$$\ sqrt {2}$ । यदि आप इस पैटर्न में एक घटता का चयन करते हैं:



प्रसिद्ध फ्रैक्टल वक्र प्राप्त करें - "फाइबोनैचि शब्द भग्न"।

2. दूसरा सवाल यह है कि क्या एक एल्गोरिथ्म लिखना संभव है जो एक पैटर्न को पेंट करता है:



इस लेख में दूसरे मुद्दे पर ध्यान दिया जाएगा। हम लूम की मदद से पैटर्न को रंग देंगे, जिसका काम हम जावास्क्रिप्ट का उपयोग करके अनुकरण करते हैं।



ऊपर दिए गए आरेख में - सबसे आसान मशीन। इसमें दो फ्रेम होते हैं, जिसके माध्यम से धागे खींचे जाते हैं। फ़्रेम पेडल से जुड़े होते हैं। जब आप किसी एक पेडल को दबाते हैं, तो फ्रेम में से एक उगता है। इस फ्रेम के माध्यम से खींचे गए धागे और एक अनुप्रस्थ धागे को थ्रेड्स के बीच के अंतर में फैला दिया जाता है। यदि आप अलग-अलग फ़्रेमों के माध्यम से सम और विषम धागे खींचते हैं, तो आपको एक बिसात पैटर्न में बुनाई मिलती है:



अधिक जटिल मशीनों में, चार या अधिक फ्रेम का उपयोग किया जाता है:


एशफोर्ड 4 दस्ता टेबल करघा

आदेश में भ्रमित नहीं होने के लिए कि किस पेडल को दबाया जाए, वे एक आरेख बनाते हैं।



पैटर्न के ऊपरी दाहिने भाग में यह इंगित किया जाता है कि किस फ्रेम के माध्यम से धागे चलते हैं (8-फ्रेम लूम के लिए पैटर्न)।

ऊपरी बाएं कोने में - जो एक ही समय में क्लैंप करने के लिए पैडल (प्रत्येक पेडल केवल अपने ही फ्रेम से जुड़ा हुआ है)।

निचले बाएं हिस्से में - पेडल को किस क्रम में।

निचले दाहिने भाग में - हमें क्या बुनाई मिलती है। यदि आप काले रंग के माध्यम से सफेद धागा खींचते हैं - हमें एक मोनोक्रोम पैटर्न मिलता है।

तुरंत "दर्ज करें" सिद्धांत थोड़ा मुश्किल लग सकता है। नीचे दी गई तस्वीर दिखाती है कि बुनाई पैटर्न कैसे बनता है:



एक स्क्रिप्ट लिखते हैं। हम एक आयामी सरणी array2 का उपयोग करके फ़्रेम के माध्यम से थ्रेड्स को बढ़ाएंगे। एक आयामी सरणी array1 में, हम पेडल क्लैम्पिंग के अनुक्रम को लिखते हैं। Array3 (8x8 बाइनरी एरे) में हम लिखते हैं कि एक ही समय में किस पैडल को दबाना है।

for(var i=0;i<length;i++){ for(var j=0;j<length;j++){ if(array3[array1[i]][array2[j]]){ context.fillRect(i, j, 1, 1); } } } 

स्क्रिप्ट (Google Chrome में काम करता है)।

हमारे कामचलाऊ करघा की मदद से हम कई तरह के पैटर्न बना सकते हैं:



लेकिन ऐतिहासिक रूप से, औसत व्यक्ति के पास दो से अधिक पैर नहीं हैं। इसलिए, एक साथ दो पैडल से अधिक नहीं दबाना सुविधाजनक है। करघा के लिए सबसे लोकप्रिय पैटर्न में से एक इस प्रकार है:



4 फ्रेम के लिए। और 8 फ्रेम के लिए इसका संशोधन:



अप्रत्याशित रूप से, इस टेम्पलेट का उपयोग करके बनाए गए पैटर्न (या पैटर्न का एक टुकड़ा) हमारे "बिलियर्ड" पैटर्न के समान हैं। इसके अलावा, ये पैटर्न छायांकित हैं:



आप करघा के लिए "बिलियर्ड" पैटर्न का चयन करना सीख सकते हैं। एक उदाहरण:



लेख की शुरुआत में, हमने पहले से ही इस पैटर्न का एक टुकड़ा देखा।

करघे के साथ समाप्त करें और बाइनरी दृश्यों की कल्पना करने के लिए एक स्क्रिप्ट लिखें। हम सरणियों में से एक से छुटकारा पा सकते हैं - पैटर्न विकर्ण सममित है। शेष सरणी को कैसे भरें? प्राथमिक:



हम इसके लिए अनुक्रम लेते हैं $$$\ sqrt {2}$ । एक सरणी बनाएँ। सरणी के शून्य तत्व में, अनुक्रम का शून्य बिट लिखें। वैकल्पिक रूप से अनुक्रम के प्रत्येक बिट ले लो। यदि nth बिट = 1 - सरणी पर लिखें [n] = एक [n-1] +1। यदि बिट = 0 - एक [एन] = एक [एन -1] -1 लिखें

$$

$$Q_n = \ lfloor n \ sqrt {x} \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ... \\ a_n = \ start {मामलों} a_ {n-1} +1, Q_n = 1; \\ a_ {n-1} -1, Q_n = 0 \ end {!!! मामलों}$$

  var a=[0]; for(var i=1;i<size;i++){ if(Math.floor(i*Math.sqrt(2))%2==1) a[i]=a[i-1]+1; else a[i]=a[i-1]-1; } 

हम जाँच करते हैं:

  for(var i=0;i<size;i++){ context.fillRect(i, a[i]+50, 1, 1); } 

वास्तव में, हम पहले से ही एक प्राथमिक भग्न प्राप्त कर चुके हैं, लेकिन हम जारी रखेंगे।

अगला, हम मैट्रिक्स से निपटेंगे:



संक्षेप में प्रस्तुत करना $$$x$ और $$$य$ । मोडुलो को 4 से विभाजित करें। यदि परिणामी परिणाम = 0 या 1 - मैट्रिक्स में लिखें। 2 और 3 के लिए, गलत लिखें। हम एक मैट्रिक्स के बिना कर सकते हैं (यह अग्रिम में ज्ञात नहीं है कि अधिकतम और न्यूनतम मूल्य क्या है [एन] लेता है)। संक्षेप में एक [x] और एक [y]। परिणामी राशि में, कुछ संख्या जोड़ें $$$सी$ (उन मामलों से छुटकारा पाने के लिए जब राशि एक नकारात्मक संख्या है)। मोडुलो को 4 से विभाजित करें। मानों 0 और 1 के लिए, निर्देशांक के साथ पिक्सेल पर पेंट करें $$$x$ और $$$य$ ।

अंतिम एल्गोरिथ्म केवल कुछ लाइनें लेता है:

  var a=[0]; for(var i=1;i<size;i++){ if(Math.floor(i*Math.sqrt(2))%2==1) a[i]=a[i-1]+1; else a[i]=a[i-1]-1; } for(var x=0;x<size;x++){ for(var y=0;y<size;y++){ q=(a[x]+a[y]+512)%4; if(q==0 || q==1) context.fillRect(x, y, 1, 1); } } 

हमारे भग्न दृश्यों की कल्पना करें।

$$

$$Q_n = \ lfloor n \ sqrt {2} \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ...$$

RGB छवि प्राप्त करने के लिए आप स्क्रिप्ट को आसानी से संशोधित कर सकते हैं:

  q=(a[x]+a[y]+512)%4; /*if(q==0 || q==1) context.fillRect(x, y, 1, 1);*/ if(q==0) context.fillStyle = 'rgb(255,0,0)'; if(q==1) context.fillStyle = 'rgb(0,255,0)'; if(q==2) context.fillStyle = 'rgb(0,0,255)'; if(q==3) context.fillStyle = 'rgb(0,0,0)'; context.fillRect(x, y, 1, 1); 

ऊपर, हमने एक संख्या को योग में जोड़ा [x] + [a] $$$सी$ । यदि आप इस संख्या को नहीं जोड़ते हैं, तो योग का न्यूनतम मान = -8, अधिकतम = 8 (के लिए) $$$x$ और $$$य$ 0 से 750)। यदि आप निकालते हैं $$$सी$ - कुछ मामलों में, राशि नकारात्मक हो जाती है और 4 के एक से अधिक नहीं होती है और इन मामलों के लिए पिक्सेल को चित्रित नहीं किया जाता है (काले रहें):

  q=(a[x]+a[y])%4; if(q==0 || q==1) context.fillRect(x, y, 1, 1); 

आप इसकी कल्पना कर सकते हैं जैसे कि भग्न का एक हिस्सा कुछ काल्पनिक सीमा से नीचे है (इस सीमा के नीचे केवल नकारात्मक मान 4: -4, -8, -12, ...) के गुणक हैं।

हम देख सकते हैं कि यह सीमा कहां है:

  if(a[x]+a[y]>=0) context.fillRect(x, y, 1, 1); 

मोडुलो को विभाजित करने के बजाय, हम कुछ निश्चित मूल्य के साथ राशि की तुलना कर सकते हैं और इस तरह भग्न के केवल एक "परत" पर पेंट कर सकते हैं। उदाहरण के रूप में, न्यूनतम और अधिकतम मानों के बीच का औसत लें:

  q=(a[x]+a[y]); if(q==0) context.fillRect(x, y, 1, 1); 

मूल्यों को न्यूनतम से अधिकतम तक बदलते हुए, हम देख सकते हैं कि कैसे गतिशीलता में "परतें" बदलती हैं:




इसके अलावा, हम "माथे पर" [x] की तुलना एक [y] के साथ कर सकते हैं और एक भग्न पैटर्न भी प्राप्त कर सकते हैं:

 if(a[x]==a[y]) context.fillRect(x, y, 1, 1); 

निम्नलिखित अनुक्रम:

$$

$$Q_n = \ lfloor n (\ sqrt {2} +1) \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ...$$

भग्न:



आरजीबी:



मध्य परत:



गतिकी में:

$$

$$Q_n = \ lfloor n \ sqrt {3} \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ...$$

भग्न:



आरजीबी:



मध्य परत:



गतिकी में:

$$

$$Q_n = \ lfloor n (\ sqrt {3} +1) \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ...$$

भग्न:



आरजीबी:



मध्य परत:



गतिकी में:

$$

$$Q_n = \ lfloor n \ sqrt {5} \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ...$$

भग्न:



आरजीबी:



मध्य परत:



गतिकी में:



खैर, हमारे पसंदीदा भग्न (इस पैटर्न का हिस्सा बिलियर्ड्स का उपयोग करके खींचा जा सकता है, जिसमें साइड साइज फिबोनाची संख्या के बराबर है):

$$

$$Q_n = \ lfloor n (\ sqrt {5} +1) \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ...$$

भग्न:



आरजीबी:



मध्य परत:



गतिकी में:



पूरा करने के लिए एक और क्रम:

$$

$$Q_n = \ lfloor n ^ {2} \ sqrt {2} \ rfloor \; (\ textrm {mod} \; 2); \ quad n = 0,1,2, ...$$

पैटर्न:



आरजीबी:



मध्य परत:



गतिकी में:



अन्य वर्ग जड़ों को स्क्रिप्ट में संचालित किया जा सकता है। (आप भिन्नात्मक मूल्यों में ड्राइव कर सकते हैं)।

दूसरी स्क्रिप्ट में, आप अनुक्रम को मैन्युअल रूप से चला सकते हैं।

बिलियर्ड्स के लिए एक और स्क्रिप्ट । माउस निर्देशांक - बिलियर्ड आयाम। बाईं ओर के पैटर्न को विभाजन के शेष (पिछले लेख में विवरण) का उपयोग करके प्राप्त अनुक्रम से बनाया गया है। दाईं ओर - समता $$$\ lfloor n \ frac {y} {x} \ rfloor$ ।