एल्गोरिथम विजार्ड्री: विदेशी मुद्रा में ग्राफ़ सिद्धांत का शोषण

यदि आप फिनटेक स्टार्टअप उद्योग से परिचित हैं, तो आपने लंदन, यूके में स्थित एक प्रसिद्ध फिनटेक दिग्गज, रिवोल्यूट के बारे में सुना होगा। 2015 में स्थापित, Revolut ने पर्याप्त निवेश अर्जित किया है और यूके में सबसे तेजी से बढ़ते स्टार्टअप में से एक बन गया है, जो कई यूरोपीय नागरिकों को बैंकिंग सेवाएं प्रदान करता है।

जबकि बैंकिंग परिचालन अक्सर रहस्य में डूबा रहता है जब बात आती है कि वे राजस्व कैसे उत्पन्न करते हैं, वर्ष 2020 और 2021 के लिए Revolut के बारे में कुछ प्रमुख आंकड़ों ने उनके आय स्रोतों पर कुछ प्रकाश डाला है:

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

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

करेंसी आर्बिट्राज एक व्यापारिक रणनीति है जिसमें एक मुद्रा व्यापारी कई ट्रेडों के माध्यम से एक विशेष मुद्रा जोड़ी के लिए दलालों द्वारा पेश किए गए विभिन्न स्प्रेड का लाभ उठाता है।

कार्य में यह स्पष्ट रूप से उल्लेख किया गया था कि एल्गोरिदम की नींव ग्राफ़ सिद्धांत में निहित होनी चाहिए।

एफएक्स मूल बातें

एफएक्स, या विदेशी मुद्रा, वैश्विक व्यापार में एक महत्वपूर्ण भूमिका निभाती है, जो हमारी परस्पर जुड़ी दुनिया के कामकाज को रेखांकित करती है। यह स्पष्ट है कि बैंकों को सबसे धनी संगठनों में से एक बनाने में एफएक्स भी महत्वपूर्ण भूमिका निभाता है।

विदेशी मुद्रा से उत्पन्न लाभ मुख्य रूप से खरीद (बीआईडी) और बिक्री (एएसके) कीमतों के बीच का अंतर या प्रसार है। हालाँकि यह अंतर प्रति लेन-देन में मामूली लग सकता है, लेकिन दैनिक परिचालन की मात्रा को देखते हुए यह लाखों डॉलर के मुनाफे में जमा हो सकता है। यह कुछ कंपनियों को इन अत्यधिक स्वचालित वित्तीय परिचालनों पर पूरी तरह से फलने-फूलने की अनुमति देता है।

एफएक्स (विदेशी मुद्रा) के दायरे में, हम हमेशा EUR/USD जैसी मुद्राओं के जोड़े के साथ काम करते हैं। ज्यादातर मामलों में, ये एक्सचेंज द्विदिशात्मक होते हैं (यानी, EUR/USD और USD/EUR), और विनिमय दर का मूल्य प्रत्येक दिशा में भिन्न होता है।

एक आर्बिट्रेज जोड़ी दो मुद्राओं (उदाहरण के लिए यूरो और यूएस डॉलर) के मूल्यों के बीच एक संख्यात्मक अनुपात का प्रतिनिधित्व करती है, जो उनके बीच विनिमय दर का निर्धारण करती है।

संभावित रूप से, हम लाभदायक व्यापार के लिए कई मध्यवर्ती मुद्राओं का उपयोग कर सकते हैं, जिन्हें एक निश्चित शर्त के रूप में जाना जाता है।

आर्बिट्रेज श्योर बेट जोड़ियों का एक सेट है जिसका उपयोग गोलाकार तरीके से किया जाता है। और पढ़ें

कई प्रदाता अपने स्वयं के लाभ को सुरक्षित करने और दूसरों को उनसे लाभ कमाने से रोकने के लिए गणितीय मॉडलिंग और विश्लेषण का उपयोग करते हैं। इसलिए, यहां संभावित शब्द पर जोर दिया गया है।

निश्चित शर्त लंबाई उन जोड़ियों की संख्या को संदर्भित करती है जो संभावित मध्यस्थता अवसरों का एक सेट बनाती हैं।

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

व्यावहारिक लाभदायक ट्रेडों में, कई चरणों में विभिन्न विनिमय प्लेटफार्मों पर विभिन्न मुद्राओं के माध्यम से रूपांतरण शामिल हो सकते हैं। दूसरे शब्दों में, आर्बिट्रेज सर्कल काफी व्यापक हो सकता है।

आर्बिट्रेज सर्कल में एक मुद्रा प्राप्त करना, उसे दूसरे प्लेटफ़ॉर्म पर स्थानांतरित करना, अन्य मुद्राओं के लिए विनिमय करना और अंततः मूल मुद्रा में वापस लौटना शामिल है।

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

एक उदाहरण

उदाहरण के लिए, आइए कल्पना करें कि हम अमेरिकी डॉलर के लिए स्विस फ्रैंक खरीदना चाहते हैं, फिर जापानी येन के लिए फ्रैंक का आदान-प्रदान करना चाहते हैं, और फिर अमेरिकी डॉलर के लिए येन बेचना चाहते हैं। शरद ऋतु, 2023 में, हमारे पास निम्नलिखित विनिमय दरें हैं:

1. हम 1 USD के लिए 0.91 CHF (स्विस फ्रैंक) खरीद सकते हैं।

2. हम 1 CHF के लिए 163.16 जापानी येन खरीद सकते हैं।

3. हम 1 जापानी येन के लिए 0.0067 USD खरीद सकते हैं।

   
   

आइए इसे एक तालिका के साथ प्रस्तुत करें:

 1 USD | 1 CHF | 1 YEN 0.91 CHF | 163.16 YEN | 0.0067 USD ----------------|-------------------|-------------- 1.098901099 | 0.006128953 | 149.2537313

अब, हमें उन मूल्यों का एक उत्पाद खोजने की जरूरत है। लेन-देन का एक क्रम तब लाभदायक हो जाता है जब यह उत्पाद एक से कम मूल्य प्राप्त करता है :

 1.098901099 * 0.006128953 * 149.2537313 = 1.005240803

जैसा कि हम देख सकते हैं कि परिणाम एक से बड़ा है, इसलिए ऐसा लगता है कि हमने अपना 0.05% पैसा खो दिया है। लेकिन वास्तव में कितने? हम इसे इस प्रकार सुलझा सकते हैं:

 0.91 CHF * 163.16 (YEN per 1 CHF) * 0.0067 (USD per 1 YEN) = 0.99478652 US Dollars

तो, शुरुआत में 1 अमेरिकी डॉलर बेचने के बाद हमें 0.994 मिले - अंत में 1 अमेरिकी डॉलर से भी कम।

सरल शब्दों में, आर्बिट्रेज चक्र तब लाभदायक होता है जब मुद्रा की एक इकाई उसी मुद्रा की एक इकाई से कम के लिए प्राप्त की जा सकती है।

आइए कल्पना करें कि हमें शुरुआती लेनदेन में 0.91 सीएचएफ के बजाय 0.92 सीएचएफ प्रति 1 अमेरिकी डॉलर लेने का अवसर मिला है:

 1 USD | 1 CHF | 1 YEN 0.92 CHF | 163.16 YEN | 0.0067 USD ----------------|-------------------|-------------- 1.086956522 | 0.006128953 | 149.2537313

एक उत्पाद 1 से कम होगा:

 1.086956522 * 0.006128953 * 149.2537313 = 0.994314272

इसका मतलब है, वास्तविक मुद्राओं में यह हमें 1 अमेरिकी डॉलर से अधिक देगा:

 0.92 CHF * 163.16 (YEN per 1 CHF) * 0.0067 (USD per 1 YEN) = 1.00571824 US Dollars

वूओला, हमें कुछ लाभ हुआ! अब, आइए देखें कि ग्राफ़ विश्लेषण का उपयोग करके इसे कैसे स्वचालित किया जाए।

तो, 3 आर्बिट्राज जोड़े के आर्बिट्राज सर्कल में लाभ या हानि की जांच करने का सूत्र इस तरह दिखेगा:

 USD/CHF * CHF/YEN * YEN/USD < 1.0

ग्राफ़ प्रतिनिधित्व

उन प्रक्रियाओं को स्वचालित करने के लिए हम ग्राफ़ का उपयोग कर सकते हैं। पहले उल्लिखित तालिकाओं को स्वाभाविक रूप से एक ग्राफ के मैट्रिक्स प्रतिनिधित्व में परिवर्तित किया जा सकता है, जहां नोड्स मुद्राओं का प्रतिनिधित्व करते हैं और किनारे द्विदिश आदान-प्रदान का प्रतिनिधित्व करते हैं।

इसलिए, मैट्रिक्स में दो जोड़ियों के आदान-प्रदान को इस तरह दर्शाना सीधा है:

 EUR USD 1 1 EUR 1 1 USD

शामिल जोड़ियों की संख्या के आधार पर, हमारा मैट्रिक्स विस्तारित हो सकता है:

 EUR USD YEN CHF 1 1 1 1 EUR 1 1 1 1 USD 1 1 1 1 YEN 1 1 1 1 CHF

नतीजतन, यदि हम अधिक विनिमय प्लेटफार्मों और संसाधनों को ध्यान में रखते हैं, तो हमारी तालिका केवल दो मुद्राओं के लिए भी काफी बड़ी हो सकती है।

वास्तविक मुद्रा मध्यस्थता समस्याओं का समाधान करने के लिए, एक पूर्ण ग्राफ़ का उपयोग अक्सर किया जाता है जो मुद्रा उद्धरण के लिए सभी संबंधों को शामिल करता है। तीन-मुद्रा विनिमय तालिका इस प्रकार दिखाई दे सकती है:

 USD CHF YEN { 1.0, 1.10, 0.0067 } USD { 0.91, 1.0, 0.0061 } CHF { 148.84, 163.16, 1.0 } YEN

हम स्मृति में अपनी मुद्रा जोड़े को दर्शाने के लिए एक सरल ग्राफ़ डेटा संरचना का उपयोग कर सकते हैं:

 class GraphNode { public: string Name; }; class Graph { public: vector<vector<double>> Matrix; vector<GraphNode> Nodes; };

अब, हमें केवल यह पता लगाना है कि इस ग्राफ़ को कैसे पार किया जाए और सबसे अधिक लाभदायक सर्कल कैसे खोजा जाए। लेकिन अभी भी एक समस्या है...

गणित हमें फिर से बचाता है

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

हालाँकि, इस सीमा को दरकिनार करने के लिए, किसी उत्पाद से योग में संक्रमण करने का एक गणितीय तरीका है: लघुगणक। यदि कोई उत्पाद लघुगणक के अंतर्गत आता है, तो इसे लघुगणक के योग में परिवर्तित किया जा सकता है।

इस समीकरण के दाईं ओर, वांछित संख्या एक से कम है, जो दर्शाता है कि इस संख्या का लघुगणक शून्य से कम होना चाहिए:

 LogE(USD/CHF) * LogE(CHF/YEN) * LogE(YEN/USD) < 0.0

यह सरल गणितीय युक्ति हमें एक से कम किनारे की लंबाई वाले उत्पाद वाले चक्र की खोज करने से लेकर ऐसे चक्र की खोज करने की अनुमति देती है जहां किनारे की लंबाई का योग शून्य से कम है।

हमारे मैट्रिक्स मान को LogE(x) में परिवर्तित किया गया और बिंदु के बाद 2 अंकों के साथ पूर्णांकित किया गया, अब इस तरह दिखें:

 USD CHF YEN { 0.0, 0.1, -5.01 } USD { -0.09, 0.0, -5.1 } CHF { 5.0, 5.09, 0.0 } YEN

अब यह समस्या शास्त्रीय ग्राफ़ एल्गोरिदम का उपयोग करके अधिक हल करने योग्य हो गई है। हमें विनिमय के सबसे लाभदायक मार्ग की तलाश में ग्राफ को पार करने की आवश्यकता है।

ग्राफ़ एल्गोरिदम

प्रत्येक एल्गोरिदम की अपनी सीमाएँ होती हैं। मैंने अपने पिछले लेख में उनमें से कुछ का उल्लेख किया था।

हम यहां शास्त्रीय बीएफएस, डीएफएस या यहां तक कि डिज्क्स्ट्रा को लागू नहीं कर सकते क्योंकि हमारे ग्राफ में नकारात्मक भार हो सकता है, जो ग्राफ को पार करते समय नकारात्मक चक्र का कारण बन सकता है। नकारात्मक चक्र एल्गोरिथम के लिए एक चुनौती पेश करते हैं क्योंकि यह लगातार प्रत्येक पुनरावृत्ति पर बेहतर समाधान ढूंढता है।

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

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

हालांकि यह एल्गोरिदम सैद्धांतिक रूप से सीधा है (और आप इसके बारे में अरबों वीडियो पा सकते हैं), हमारी आवश्यकताओं के लिए व्यावहारिक कार्यान्वयन के लिए कुछ प्रयास की आवश्यकता होती है। आइए इसकी खोज करें।

बेलमैन-फोर्ड एल्गोरिदम कार्यान्वयन

चूँकि इस लेख का उद्देश्य कंप्यूटर विज्ञान है, मैं काल्पनिक विनिमय दरों का उपयोग करूँगा जिनका वास्तविक से कोई लेना-देना नहीं है।

एल्गोरिथ्म के सहज परिचय के लिए, आइए एक ऐसे ग्राफ़ का उपयोग करें जिसमें नकारात्मक चक्र बिल्कुल भी न हों:

 graph.Nodes.push_back({ "USD" }); graph.Nodes.push_back({ "CHF" }); graph.Nodes.push_back({ "YEN" }); graph.Nodes.push_back({ "GBP" }); graph.Nodes.push_back({ "CNY" }); graph.Nodes.push_back({ "EUR" }); // Define exchange rates for pairs of currencies below // USD CHF YEN GBP CNY EUR graph.Matrix = { { 0.0, 0.41, INF, INF, INF, 0.29 }, // USD { INF, 0.0, 0.51, INF, 0.32, INF }, // CHF { INF, INF, 0.0, 0.50, INF, INF }, // YEN { 0.45, INF, INF, 0.0, INF, -0.38 }, // GBP { INF, INF, 0.32, 0.36, 0.0, INF }, // CNY { INF, -0.29, INF, INF, 0.21, 0.0 } }; // EUR

नीचे दिया गया कोड उदाहरण बेलमैन-फोर्ड एल्गोरिदम का उपयोग करके दो नोड्स के बीच एक पथ ढूंढता है जब ग्राफ़ में नकारात्मक चक्रों का अभाव होता है:

 vector<double> _shortestPath; vector<int> _previousVertex; void FindPath(Graph& graph, int start) { int verticesNumber = graph.Nodes.size(); _shortestPath.resize(verticesNumber, INF); _previousVertex.resize(verticesNumber, -1); _shortestPath[start] = 0; // For each vertex, apply relaxation for all the edges V - 1 times. for (int k = 0; k < verticesNumber - 1; k++) for (int from = 0; from < verticesNumber; from++) for (int to = 0; to < verticesNumber; to++) if (_shortestPath[to] > _shortestPath[from] + graph.Matrix[from][to]) { _shortestPath[to] = _shortestPath[from] + graph.Matrix[from][to]; _previousVertex[to] = from; } }

चीनी युआन के लिए इस कोड को चलाने से _previousVertex सरणी भर जाती है और इस तरह परिणाम मिलते हैं:

 Path from 4 to 0 is : 4(CNY) 3(GBP) 0(USD) Path from 4 to 1 is : 4(CNY) 3(GBP) 5(EUR) 1(CHF) Path from 4 to 2 is : 4(CNY) 3(GBP) 5(EUR) 1(CHF) 2(YEN) Path from 4 to 3 is : 4(CNY) 3(GBP) Path from 4 to 4 is : 4(CNY) Path from 4 to 5 is : 4(CNY) 3(GBP) 5(EUR)

जैसा कि आप देख सकते हैं, यह CNY और विभिन्न अन्य मुद्राओं के बीच इष्टतम पथ की पहचान करता है।

और फिर, मैं केवल एक सर्वश्रेष्ठ खोजने पर ध्यान केंद्रित नहीं करूंगा, क्योंकि यह अपेक्षाकृत सरल कार्य है और लेख का लक्ष्य नहीं है।

उपरोक्त कार्यान्वयन आदर्श मामलों में अच्छा काम करता है लेकिन नकारात्मक चक्र वाले ग्राफ़ से निपटने में विफल रहता है।

नकारात्मक चक्रों का पता लगाना

हमें वास्तव में यह पहचानने की क्षमता की आवश्यकता है कि ग्राफ़ में नकारात्मक चक्र हैं या नहीं, और यदि हां, तो समस्याग्रस्त खंडों को इंगित करें। यह ज्ञान हमें इन मुद्दों को कम करने और अंततः लाभदायक श्रृंखलाओं की खोज करने की अनुमति देता है।

पुनरावृत्तियों की संख्या हमेशा सटीक रूप से V - 1 तक नहीं पहुंचती है। यदि (N+1)-वें चक्र पर, N-वें चक्र से बेहतर कोई रास्ता नहीं खोजा जाता है, तो एक समाधान पाया हुआ माना जाता है। इस प्रकार, थोड़े अनुकूलन की गुंजाइश है।

पहले बताए गए कोड को न केवल पथ खोजने के लिए बढ़ाया जा सकता है, बल्कि यह भी पता लगाया जा सकता है कि ग्राफ़ में नकारात्मक चक्र हैं या नहीं, जिसमें मेरे द्वारा उल्लिखित अनुकूलन भी शामिल है:

 vector<double> _shortestPath; vector<int> _previousVertex; bool ContainsNegativeCycles(Graph& graph, int start) { int verticesNumber = graph.Nodes.size(); _shortestPath.resize(verticesNumber, INF); _previousVertex.resize(verticesNumber, -1); _shortestPath[start] = 0; // For each vertex, apply relaxation for all the edges V - 1 times. for (int k = 0; k < verticesNumber - 1; k++) { updated = false; for (int from = 0; from < verticesNumber; from++) { for (int to = 0; to < verticesNumber; to++) { if (_shortestPath[to] > _shortestPath[from] + graph.Matrix[from][to]) { _shortestPath[to] = _shortestPath[from] + graph.Matrix[from][to]; _previousVertex[to] = from; updated = true; } } } if (!updated) // No changes in paths, means we can finish earlier. break; } // Run one more relaxation step to detect which nodes are part of a negative cycle. if (updated) for (int from = 0; from < verticesNumber; from++) for (int to = 0; to < verticesNumber; to++) if (_shortestPath[to] > _shortestPath[from] + graph.Matrix[from][to]) // A negative cycle has occurred if we can find a better path beyond the optimal solution. return true; return false; }

और अब हम एक अधिक जटिल ग्राफ़ के साथ खेलते हैं जिसमें नकारात्मक चक्र शामिल हैं:

 graph.Nodes.push_back({ "USD" }); // 1 (Index = 0) graph.Nodes.push_back({ "CHF" }); graph.Nodes.push_back({ "YEN" }); graph.Nodes.push_back({ "GBP" }); graph.Nodes.push_back({ "CNY" }); graph.Nodes.push_back({ "EUR" }); graph.Nodes.push_back({ "XXX" }); graph.Nodes.push_back({ "YYY" }); // 8 (Index = 7) // USD CHF YEN GBP CNY EUR XXX YYY graph.Matrix = { { 0.0, 1.0, INF, INF, INF, INF, INF, INF }, // USD { INF, 0.0, 1.0, INF, INF, 4.0, 4.0, INF }, // CHF { INF, INF, 0.0, INF, 1.0, INF, INF, INF }, // YEN { INF, INF, 1.0, 0.0, INF, INF, INF, INF }, // GBP { INF, INF, INF, -3.0, 0.0, INF, INF, INF }, // CNY { INF, INF, INF, INF, INF, 0.0, 5.0, 3.0 }, // EUR { INF, INF, INF, INF, INF, INF, 0.0, 4.0 }, // XXX { INF, INF, INF, INF, INF, INF, INF, 0.0 } }; // YYY

हमारा प्रोग्राम बस रुक जाता है और एक संदेश प्रदर्शित करता है:

 Graph contains negative cycle.

हम समस्या को इंगित करने में सक्षम थे, हालाँकि, हमें ग्राफ़ के समस्याग्रस्त खंडों के आसपास नेविगेट करने की आवश्यकता है।

नकारात्मक चक्रों से बचना

इसे पूरा करने के लिए, हम उन शीर्षों को चिह्नित करेंगे जो एक स्थिर मान, NEG_INF के साथ नकारात्मक चक्रों का हिस्सा हैं:

 bool FindPathsAndNegativeCycles(Graph& graph, int start) { int verticesNumber = graph.Nodes.size(); _shortestPath.resize(verticesNumber, INF); _previousVertex.resize(verticesNumber, -1); _shortestPath[start] = 0; for (int k = 0; k < verticesNumber - 1; k++) for (int from = 0; from < verticesNumber; from++) for (int to = 0; to < verticesNumber; to++) { if (graph.Matrix[from][to] == INF) // Edge not exists { continue; } if (_shortestPath[to] > _shortestPath[from] + graph.Matrix[from][to]) { _shortestPath[to] = _shortestPath[from] + graph.Matrix[from][to]; _previousVertex[to] = from; } } bool negativeCycles = false; for (int k = 0; k < verticesNumber - 1; k++) for (int from = 0; from < verticesNumber; from++) for (int to = 0; to < verticesNumber; to++) { if (graph.Matrix[from][to] == INF) // Edge not exists { continue; } if (_shortestPath[to] > _shortestPath[from] + graph.Matrix[from][to]) { _shortestPath[to] = NEG_INF; _previousVertex[to] = -2; negativeCycles = true; } } return negativeCycles; }

अब, यदि हम _shortestPath सरणी में NEG_INF का सामना करते हैं, तो हम एक संदेश प्रदर्शित कर सकते हैं और अन्य मुद्राओं के लिए इष्टतम समाधान की पहचान करते हुए उस सेगमेंट को छोड़ सकते हैं। उदाहरण के लिए, नोड 0 (यूएसडी का प्रतिनिधित्व) के साथ:

 Graph contains negative cycle. Path from 0 to 0 is : 0(USD) Path from 0 to 1 is : 0(USD) 1(CHF) Path from 0 to 2 is : Infinite number of shortest paths (negative cycle). Path from 0 to 3 is : Infinite number of shortest paths (negative cycle). Path from 0 to 4 is : Infinite number of shortest paths (negative cycle). Path from 0 to 5 is : 0(USD) 1(CHF) 5(EUR) Path from 0 to 6 is : 0(USD) 1(CHF) 6(XXX) Path from 0 to 7 is : 0(USD) 1(CHF) 5(EUR) 7(YYY)

वाह! इस तथ्य के बावजूद कि हमारा डेटा "थोड़ा गंदा" था, हमारा कोड कई लाभदायक श्रृंखलाओं की पहचान करने में सक्षम था। परीक्षण डेटा सहित ऊपर उल्लिखित सभी कोड उदाहरण मेरे GitHub पर आपके साथ साझा किए गए हैं।

यहां तक कि थोड़ा उतार-चढ़ाव भी मायने रखता है

आइए अब हमने जो सीखा है उसे समेकित करें। तीन मुद्राओं की विनिमय दरों की सूची को देखते हुए, हम आसानी से नकारात्मक चक्रों का पता लगा सकते हैं:

 graph.Nodes.push_back({ "USD" }); // 1 (Index = 0) graph.Nodes.push_back({ "CHF" }); graph.Nodes.push_back({ "YEN" }); // 3 (Index = 2) // LogE(x) table: USD CHF YEN graph.Matrix = { { 0.0, 0.489, -0.402 }, // USD { -0.489, 0.0, -0.891 }, // CHF { 0.402, 0.89, 0.0 } }; // YEN from = 0; FindPathsAndNegativeCycles(graph, from);

परिणाम:

 Graph contains negative cycle. Path from 0 to 0 is: Infinite number of shortest paths (negative cycle). Path from 0 to 1 is: Infinite number of shortest paths (negative cycle). Path from 0 to 2 is: Infinite number of shortest paths (negative cycle).

हालाँकि, विनिमय दरों में मामूली बदलाव (यानी, मैट्रिक्स में समायोजन) भी महत्वपूर्ण अंतर पैदा कर सकता है:

 // LogE(x) table: USD CHF YEN graph.Matrix = { { 0.0, 0.490, -0.402 }, // USD { -0.489, 0.0, -0.891 }, // CHF { 0.403, 0.891, 0.0 } }; // YEN from = 0; FindPathsAndNegativeCycles(graph, from);

देखिए, हमें एक लाभदायक श्रृंखला मिली है:

 Path from 0 to 0 is : 0(USD) Path from 0 to 1 is : 0(USD) 2(YEN) 1(CHF) Path from 0 to 2 is : 0(USD) 2(YEN)

हम इन अवधारणाओं को कई मुद्राओं को शामिल करते हुए बहुत बड़े ग्राफ़ पर लागू कर सकते हैं:

 graph.Nodes.push_back({ "USD" }); // 1 (Index = 0) graph.Nodes.push_back({ "CHF" }); graph.Nodes.push_back({ "YEN" }); graph.Nodes.push_back({ "GBP" }); graph.Nodes.push_back({ "CNY" }); // 5 (Index = 4) // LogE(x) table: USD CHF YEN GBP CNY graph.Matrix = { { 0.0, 0.490, -0.402, 0.7, 0.413 }, // USD { -0.489, 0.0, -0.891, 0.89, 0.360 }, // CHF { 0.403, 0.891, 0.0, 0.91, 0.581 }, // YEN { 0.340, 0.405, 0.607, 0.0, 0.72 }, // GBP { 0.403, 0.350, 0.571, 0.71, 0.0 } }; // CNY from = 0; runDetectNegativeCycles(graph, from);

परिणामस्वरूप, हमें लाभ पाने के लिए कई उम्मीदवार मिल सकते हैं:

 Path from 0 to 0 is : 0(USD) Path from 0 to 1 is : 0(USD) 2(YEN) 1(CHF) Path from 0 to 2 is : 0(USD) 2(YEN) Path from 0 to 3 is : 0(USD) 2(YEN) 3(GBP) Path from 0 to 4 is : 0(USD) 2(YEN) 4(CNY) 

हालाँकि, दो महत्वपूर्ण कारक हैं:

1. मध्यस्थता प्रक्रियाओं को लागू करने में समय एक महत्वपूर्ण कारक है, मुख्य रूप से मुद्रा की कीमतों में तेजी से उतार-चढ़ाव के कारण। परिणामस्वरूप, एक निश्चित दांव का जीवनकाल बहुत कम होता है।

2. प्लेटफ़ॉर्म प्रत्येक लेनदेन के लिए कमीशन लेते हैं।

   
   

इसलिए, समय की लागत को कम करना और कमीशन को कम करना सर्वोपरि है, जिसे निश्चित दांव की अवधि को सीमित करके हासिल किया जाता है।

अनुभवजन्य अनुभव से पता चलता है कि एक स्वीकार्य निश्चित शर्त की लंबाई आम तौर पर 2 से 3 जोड़े तक होती है। इसके अलावा, कम्प्यूटेशनल आवश्यकताएं बढ़ती हैं और ट्रेडिंग प्लेटफॉर्म बड़े कमीशन लगाते हैं।

इस प्रकार, आय अर्जित करने के लिए ऐसी तकनीकों का होना ही पर्याप्त नहीं है, बल्कि आपको निम्न-स्तरीय कमीशन तक पहुंच की भी आवश्यकता है। आमतौर पर केवल बड़े वित्तीय संस्थानों के हाथ में ही ऐसा संसाधन होता है।

स्मार्ट अनुबंधों का उपयोग करके स्वचालन

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

स्मार्ट कॉन्ट्रैक्ट का उपयोग करना आज एफएक्स संचालन करने के सबसे नवीन तरीकों में से एक है। स्मार्ट अनुबंध देरी या मानवीय हस्तक्षेप के बिना वास्तविक समय एफएक्स संचालन को सक्षम करते हैं (स्मार्ट अनुबंध के निर्माण को छोड़कर)।

सॉलिडिटी स्मार्ट कॉन्ट्रैक्ट बनाने के लिए विशेष प्रोग्रामिंग भाषा है जो क्रिप्टोकरेंसी से जुड़े वित्तीय संचालन को स्वचालित करती है। स्मार्ट अनुबंधों की दुनिया गतिशील है और तेजी से तकनीकी परिवर्तनों और विकसित हो रहे नियमों के अधीन है। यह काफी प्रचार-प्रसार वाला क्षेत्र है और वॉलेट तथा कानूनी अनुपालन से संबंधित महत्वपूर्ण जोखिम भी हैं।

हालांकि निस्संदेह प्रतिभाशाली व्यक्ति और टीमें इस क्षेत्र से लाभ कमा रही हैं, वहीं नियामक संस्थाएं भी हैं जो यह सुनिश्चित करने का प्रयास कर रही हैं कि बाजार के नियमों को बरकरार रखा जाए।

हम इस पर गौर क्यों कर रहे हैं?

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

बेशक, राजनीति, नियम और केंद्रीय बैंक जैसे विभिन्न कारक विनिमय दरों और एफएक्स दक्षता को प्रभावित करते हैं। ये जटिलताएँ वित्तीय परिदृश्य को जटिल बनाती हैं। फिर भी, यह विश्वास करना आवश्यक है कि ये जटिलताएँ आम भलाई के लिए एक बड़े उद्देश्य की पूर्ति करती हैं।

कई वैज्ञानिक दस्तावेज़ वैश्विक अर्थव्यवस्था में विनिमय दरों के अस्तित्व और निर्धारण पर गहराई से चर्चा करते हैं, जिनमें से कुछ का उल्लेख करें:

• आयातक, निर्यातक और विनिमय दर डिस्कनेक्ट

• मुद्रा चयन और विनिमय दर पास-थ्रू

• विनिमय दर पहेलियाँ और नीतियां

  
  

ये दस्तावेज़ विदेशी मुद्रा विनिमय के कुछ मूलभूत तंत्रों पर प्रकाश डालते हैं, जिन्हें समझना और एक मॉडल में फिट करना अभी भी कठिन है।

हालाँकि, कोड के साथ खेलने और एक व्यावहारिक समस्या का समाधान खोजने की कोशिश करने से मुझे इसके बारे में कुछ और जानकारी प्राप्त करने में मदद मिली। मुझे आशा है कि आपने इस छोटी सी अन्वेषण यात्रा का उतना ही आनंद लिया जितना मैंने लिया।

बने रहें!

लिंक

• इन सभी उदाहरणों के साथ स्रोत कोड
• सेडगेविक आर. - सी में एल्गोरिदम, भाग 5: ग्राफ़ एल्गोरिदम
• बेलमैन फोर्ड एल्गोरिथम कोड कार्यान्वयन
• विलियम फिसेट के गिटहब उदाहरण - बेलमैन फोर्ड ऑन एडजेंसी मैट्रिक्स
• विलियम फिसेट के गिटहब उदाहरण - बेलमैन फोर्ड ऑन एज लिस्ट