जैव-गणना में फ्लाईवेट पैटर्न में सुधार

प्रागितिहास

तुरंत मैं जटिलता के लिए माफी माँगता हूँ, लेकिन इस स्थिति को लागू करना मुश्किल है, और इसे हल करने का तरीका है, लेकिन परिणाम सुंदर और प्रभावी है :)

यह OOP समस्याओं के बारे में एक समस्या का वर्णन करके शुरू हुआ। फिर संयोग से, बातचीत के लिए धन्यवाद, मैंने डिज़ाइन पैटर्न के बारे में सोचना शुरू किया। और "किसी वस्तु की पूरी नकल" विषय के संबंध में, वह फ्लाईवेट पैटर्न में आए। कौन नहीं जानता - कृपया ऑब्जेक्ट-ओरिएंटेड डिज़ाइन ट्रिक्स में उसके बारे में पहले पढ़ें । डिज़ाइन पैटर्न (विकी में नहीं, बल्कि मूल में)।

मुख्य विचार यह है:

फ्लाईवेट पैटर्न का वर्णन है कि अत्यधिक उच्च लागत के बिना एक साथ बहुत छोटी वस्तुओं को कैसे साझा किया जाए। प्रत्येक फिटिंग ऑब्जेक्ट के दो भाग होते हैं: आंतरिक और बाहरी राज्य। आंतरिक स्थिति को स्थिरता में संग्रहीत (साझा) किया जाता है और इसमें ऐसी जानकारी होती है जो इसके संदर्भ से स्वतंत्र होती है। बाहरी राज्य को क्लाइंट ऑब्जेक्ट्स द्वारा संग्रहीत या गणना की जाती है और अवसरवादी को पास किया जाता है जब उसके तरीकों को बुलाया जाता है।

कार्य

हम इस बात पर ध्यान देंगे कि इसे एक ठोस उदाहरण के साथ कैसे सुधारें। मैं जैव-गणना के बारे में बहुत कम बोलूंगा - लेकिन इस पर उदाहरण बनाया जाएगा। मैं केवल योजना को छोड़कर, जैव-गणना के सार को पूरी तरह से खोदने की कोशिश करूँगा।

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



तो एक आरएनए ऑब्जेक्ट (आरएनए) है। वह अधिक सामान्य चेन ऑब्जेक्ट का उत्तराधिकारी है (उदाहरण के लिए, डीएनए, प्रोटीन आदि भी हो सकता है)। प्रत्येक आरएनए में कई अणु (न्यूक्लियोटाइड्स) (अणु) होते हैं। इस मामले में, अणु चार प्रकार के हो सकते हैं (अणु उत्तराधिकारी) - साइटोसिन, यूरैसिल, गुआनिन, एडेनिन। प्रत्येक अणु, प्रकार के आधार पर, 28-33 परमाणु (एटम) होते हैं। प्रत्येक परमाणु के तीन गणना कोण हैं।

सार्वजनिक वर्ग कोण
{
निजी नाव फ़ाइ ;
निजी फ्लोट थीटा ;
निजी नाव d ;
}

यह श्रृंखला की प्राथमिक संरचना के आधार पर आवश्यक है, उदाहरण के लिए, एगैग्यूगसगैकैकुगैकुग - एक तीन-आयामी मॉडल बनाने के लिए। यानी लगभग 1000 परस्पर जुड़े हुए परमाणु बनाते हैं, जो सामान्य रूप से रेखांकन होते हैं। इस ग्राफ को बनाने में गंभीर समय लगता है।

अगला, आपको जैव गणना करने की आवश्यकता है। यह श्रृंखला एक विशिष्ट 3 डी विन्यास को स्वीकार करती है। प्रत्येक परमाणु के निर्देशांक और उसके कोण दूसरे परमाणु के संबंध में गणना किए जाते हैं। गणना योजना के अनुसार की जाती है - हम आरएनए की अंतिम "अच्छी" स्थिति लेते हैं और इसे "सुधार" करने का प्रयास करते हैं। मान लीजिए कि एक कोने में एक अणु को घुमाने के लिए 1000 प्रयास किए जाते हैं। इस 1000 से, केवल एक सबसे अच्छा विकल्प चुना जाता है - यह तय किया जाता है (एक "अच्छा" राज्य बन जाता है) और गणना दोहराई जाती है।

माथे का फैसला

दरअसल, यह शुरुआत में तय किया गया था, यह रॉसेटा @ होम प्रोजेक्ट के लिए कोड से विरासत में मिला था।

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

आरएनए बेस्टएआरएनए ;
आरएनए करेंटआरएनए ;

और करने की जरूरत है

कर्रेंटा = बेस्टटीन। क्लोन ( ) ;
गणना ( करंट आरएनए ) ;

समस्या बिल्कुल इस क्लोन () की है। याद रखें कि सभी परमाणुओं के ग्राफ का निर्माण एक बहुत ही संसाधन-गहन प्रक्रिया है।
और यदि आप निर्माण नहीं करते हैं, तो हम सभी परमाणुओं के कोणों को "अच्छी" स्थिति में मिटा देंगे।

क्लासिक फ्लाईवेट

क्लासिक फ्लाईवेट हमें परमाणुओं से कोनों के गुणों को फैलाने और ऊपर की वस्तुओं में डालने की पेशकश करता है। इस सीमा तक कि आरएनए ऑब्जेक्ट में स्थित सरणी। इस सरणी को किसी तरह अनुक्रमित किया जाएगा ताकि सूचकांक द्वारा आप निश्चित रूप से वांछित परमाणु में मिल सकें।

फिर, जब क्लोनिंग करते हैं, तो केवल इस सरणी को क्लोन करने की आवश्यकता होगी, और परमाणुओं के ग्राफ की आवश्यकता नहीं है।

लेकिन यह सब गंभीरता से ओओपी के सिद्धांतों का उल्लंघन करता है। वास्तव में, ऑब्जेक्ट्स के गुणों को गणना की गति बढ़ाने के लिए ऑब्जेक्ट्स से चुना जाता है। मॉडल अपना सार खो देता है - कोण अब परमाणुओं के गुण नहीं हैं, बल्कि संपूर्ण श्रृंखला के गुण हैं। हल्के से। यह संरचनात्मक प्रोग्रामिंग का संकेत है, न कि ऑब्जेक्ट प्रोग्रामिंग।

क्या करें?

मुख्य बात पहले यह महसूस करना है कि हम वास्तव में समय की गणना कर रहे हैं। यानी हमें समय के साथ परमाणुओं के प्रक्षेपवक्र को बनाए रखने की आवश्यकता है। ऑब्जेक्ट पिक्चर को तब पुनर्स्थापित किया जाता है।

फिर कम से कम टिप्पणियों के साथ बहुत सारे कोड होंगे, जो स्पष्ट पूछना नहीं है।

इसलिए, हम जो पहली चीज़ करते हैं, वह एकल कोणों को समय की सरणियों से बदल देती है, लेकिन वर्तमान समय में पहुंच के साथ।

सार्वजनिक वर्ग कोण
{
निजी फ्लोट [ ] फ़ि = नया फ्लोट [ चेन। TimeHistory ] ;
निजी नाव [ ] थीटा = नई नाव [ श्रृंखला। TimeHistory ] ;
निजी फ्लोट [ ] डी = नया फ्लोट [ चेन। TimeHistory ] ;
जनता तैरती है
{
{{ फी फी [ चैन। समय ] ; }
सेट { फी ] चेन। समय ] = मूल्य ; }
}
सार्वजनिक नाव थीटा
{
{{ थीटा वापस करें । समय ] ; }
सेट { थीटा [ चेन। समय ] = मूल्य ; }
}
सार्वजनिक नाव D
{
get { वापसी d [ चैन। समय ] ; }
सेट { d [ चेन। समय ] = मूल्य ; }
}
सार्वजनिक शून्य सेटइन्सेशन ( int argTime )
{
फी = फी [ अर्गाइम ] ;
थीटा = थीटा [ argTime ] ;
D = d [ argTime ] ;
}
}

आगे का समय सर्किट स्तर पर नियंत्रित किया जाता है, अर्थात सबसे ऊपरी वस्तु। मैं कोड का एक टुकड़ा देता हूं और धीरे-धीरे समझाता हूं। पूरा विचार केवल अंत में स्पष्ट होगा (कथन गणित में जैसा है - शुरुआत में यह स्पष्ट नहीं है कि यह क्यों आवश्यक है, और केवल अंत में यह स्पष्ट है कि यह सब क्यों है)।

सार्वजनिक वर्ग की चेन
{
निजी स्थिर चेन उदाहरण ;
सार्वजनिक श्रृंखला ( इंट मोलाउंट )
{
उदाहरण = यह ;
}
/// वर्तमान समय
निजी इंट टाइम = 0 ;
सार्वजनिक स्थैतिक int समय
{
{ रिटर्न उदाहरण प्राप्त करें। समय ; }
सेट { उदाहरण। समय = मान ; }
}
सार्वजनिक स्थैतिक int OldTime
{
प्राप्त
{
int oldTime = उदाहरण। समय - 1 ;
अगर ( पुराना समय == - 1 )
{
oldTime = टाइमहाइस्टर - 1 ;
}
पुराने समय को वापस करें ;
}
}
/// समय की संख्या कदम है कि वस्तु भंडार
सार्वजनिक स्थैतिक int TimeHistory = 5 ;

निजी स्थिर इंट पीढ़ी ;
सार्वजनिक स्थैतिक int जनरेशन
{
{ वापसी पीढ़ी प्राप्त करें ; }
}
/// स्थानांतरण समय एक कदम आगे
संरक्षित शून्य NextTime ( int argGeneration )
{
समय ++ ;
अगर ( समय > = टाइमहिस्ट्री )
{
समय = 0 ;
जनरेशन = argGeneration + 1 ;
CurrentMaxTimeID = 0 ;
}
}

सार्वजनिक शून्य चेकटाइम ( int argTimeID, int argGeneration )
{
// 2 पीढ़ी से अधिक पुरानी पीढ़ी नहीं हो सकती है, और यदि यह वर्तमान पीढ़ी है,
// तब समय टिकट जारी किए गए टिकटों से अधिक लंबा नहीं हो सकता है
// (यह केवल वर्तमान और पिछली पीढ़ी के बीच हो सकता है)
// और वर्तमान से बड़ी कोई पीढ़ी नहीं हो सकती
if ( argGeneration < ( जनरेशन - 1 ) ||
( argGeneration == जनरेशन && CurrentMaxTimeID < argTimeID ) ||
पीढ़ी > पीढ़ी )
{
कंसोल। राइटलाइन ( "ErrorGenerationRNA" ) ;
कंसोल। ReadLine ( ) ;
}
अगर ( समय ! = argTimeID )
{
समय = argTimeID ;
}
}

निजी स्थिर int CurrentMaxTimeID = 0 ;
सार्वजनिक स्थैतिक int GetNextTimeID ( int argCurrentTimeID, int argGeneration )
{
int NextTime = - 1 ;

यदि ( argGeneration == जनरेशन )
{
NextTime = argCurrentTimeID + 1 ;
}
अगर ( argGeneration == जनरेशन - 1 )
{
अगली बार = 0 ;
}
अगर ( CurrentMaxTimeID < NextTime )
{
करंटमैक्सटाइमआईडी = नेक्स्ट टाइम ;
}
अगली बार लौटें ;
}
}

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

TimeHistory के मान से एरर्स बनाए जाते हैं। यह एक सापेक्ष मूल्य है, राज्यों के प्रक्षेपवक्र में चरणों की संख्या जो कि SIMULTANEOUSLY होना महत्वपूर्ण है। हमारे उदाहरण में, आम तौर पर दो हो सकते हैं: सर्वश्रेष्ठ और वर्तमान। लेकिन इष्टतमता के लिए, इसे थोड़ा बढ़ाकर 5 कर दिया गया है।

आगे, जो किया जा रहा है। आपको समय पर काम करने के लिए आरएनए गुणों / विधियों तक पहुंच को पूरी तरह से नियंत्रित करने की आवश्यकता है। हम "मध्यस्थ" पैटर्न का उपयोग करते हैं (लेकिन इसलिए उपयोग करने वाला वर्ग यह नहीं समझता है - वह है, पारदर्शी)

RNARealise को RNA वर्ग का नाम दें। और असली आरएनए के बजाय, हम एक "मध्यस्थ" बनाते हैं:

सार्वजनिक वर्ग आर.एन.ए.
{
निजी RNARealise बॉडी ;

निजी int TimeID = 0 ;
निजी int GenerationID = 0 ;

सार्वजनिक अणु [ ] अणु
{
प्राप्त
{
शरीर। चेकटाइम ( टाइमआईडी, जेनरेशनआईडी ) ;
वापसी शरीर। अणु ;
}
}
सार्वजनिक आरएनए ( RNASeq argSeq )
{
body = नया RNARealise ( argSeq ) ;
}
सार्वजनिक आरएनए क्लोन ( )
{
शरीर। चेकटाइम ( टाइमआईडी, जेनरेशनआईडी ) ;
आरएनए न्यूआरएनए = ( आरएनए ) यह । सदस्यवार क्लिक करें ( ) ;
NewRNA। शरीर = नया। शरीर । क्लोन ( यह । जेनरेशनआईडी ) ;
NewRNA। TimeID = चेन। GetNextTimeID ( यह । TimeID , यह । GenerationID ) ;
NewRNA। पीढ़ी = जंजीर। पीढ़ी;

वापसी NewRNA ;
}

सार्वजनिक शून्य वापसी ( int argPosition )
{
शरीर। चेकटाइम ( टाइमआईडी, जेनरेशनआईडी ) ;
शरीर। Refold ( argPosition ) ;
}
}

यहाँ क्या महत्वपूर्ण है एक पहचानकर्ता को ऑब्जेक्ट में जोड़ा जाता है - TimeID टाइम स्टैम्प और जेनरेशनआईडी ऑब्जेक्ट्स की पीढ़ी। और प्रॉपर्टी के प्रत्येक एक्सेस से पहले और हर बार कॉल करने से पहले, हम जाँचते हैं कि क्या बॉडी.चेकटाइम ऑब्जेक्ट (TimeID, GenerationID) उस समय में है।

और विचार करें कि सार्वजनिक आरएनए क्लोन () क्लोनिंग का अनुकरण कैसे किया जाता है।

वास्तव में, केवल मध्यस्थ का खोल क्लोन किया जाता है, जिसमें समय और पीढ़ी का एक नया मुहर सौंपा जाता है। इसके अंदर नेक्स्टटाइम क्लोन टाइम (argGeneration) का अनुवाद भी होगा। और अणु क्लोनिंग के स्तर पर, कोनों का आरंभीकरण भी पिछले मूल्य होगा

for ( int i = 1 ; i < FullAngles। लंबाई ; i ++ )
{
FullAngles [ i ] । सेटइंश्योरियल ( चेन। ओल्डटाइम ) ;
}

जो पूर्ण क्लोनिंग की तुलना में काफी कम है। और पूरा कॉलिंग कोड बिल्कुल नहीं बदलता है - जहां क्लोनिंग की गई थी, यह किया जाता है। गणना कुछ इस तरह थी

सार्वजनिक शून्य अवरोधक ( )
{
आरएनए saveRNA = CurrentRNA। क्लोन ( ) ;
locScore = NucFluctuation ( saveRNA ) ;
// सबसे अच्छा राज्य बचाओ
बचाओ ( ) ;
}

सार्वजनिक डबल NucFluctuation ( RNA argRNA )
{
for ( int j = 1 ; j < FragmentCount ; j ++ )
{
आरएनए locRNA = argRNA। क्लोन ( ) ;
// रोटेशन करें
घुमाएँ। AtomAngleRotate ( locRNA ) ;
// बारी की लाभप्रदता की गणना
RNAScore। स्कोर ( locRNA ) ;
}
}

यह अनुमान लगाने की कोशिश करें कि ऐसा कैसे होता है कि अलग-अलग समय पर कोण भ्रमित नहीं होते हैं, हालांकि कोई भी सीधे ऊपर से समय को नियंत्रित नहीं करता है? (सामान्य तौर पर, मैं इसे पाठक के लिए "होमवर्क" के लिए छोड़ दूंगा, अगर यह समझना अभी भी मुश्किल है, तो मैं टिप्पणियों से समझता हूं)।