Algoritmik Sihirbazlık: Dövizde Grafik Teorisinden Yararlanmak

FinTech startup sektörüne aşina iseniz, Londra, İngiltere merkezli tanınmış bir FinTech devi olan Revolut'u duymuş olabilirsiniz. 2015 yılında kurulan Revolut, önemli yatırımlar topladı ve birçok Avrupa vatandaşına bankacılık hizmetleri sunarak Birleşik Krallık'ta en hızlı büyüyen girişimlerden biri haline geldi.

Bankacılık operasyonları, nasıl gelir elde ettikleri konusunda çoğu zaman gizemle örtülse de, Revolut'un 2020 ve 2021 yıllarına ilişkin bazı önemli rakamları, gelir kaynaklarına ışık tuttu:

Gösterildiği gibi, bu neobankın gelirinin önemli bir kısmı Döviz (FX), varlık yönetimi (kripto para birimleri dahil) ve kart hizmetlerinden geliyor. Özellikle 2021 yılında döviz en karlı sektör haline geldi.

Kendisi de yazılım mühendisi olan bir arkadaşım, birkaç yıl önce Revolut'un Yazılım Mühendisliği bölümünde yaptığı teknik röportajla ilgili ilginç bir hikaye paylaşmıştı. Bir veya daha fazla ara para birimi kullanarak iki para birimini dönüştürmenin en karlı yolunu belirleyecek bir algoritma geliştirmekle görevlendirildi. Yani Döviz Arbitrajı için bir strateji arıyorlardı.

Döviz Arbitrajı , bir döviz tüccarının birden fazla işlem yoluyla belirli bir döviz çifti için komisyoncular tarafından sunulan farklı spreadlerden yararlandığı bir ticaret stratejisidir.

Algoritmanın temelinin grafik teorisine dayanması gerektiği görevde açıkça belirtildi.

FX Temelleri

FX veya Döviz, küresel ticarette çok önemli bir rol oynuyor ve birbirine bağlı dünyamızın işleyişini destekliyor. FX'in bankaların en zengin kuruluşlardan biri haline getirilmesinde de önemli bir rol oynadığı açıktır.

Dövizden elde edilen kâr, öncelikle alış (BID) ve satış (ASK) fiyatları arasındaki fark veya spreaddir. Bu fark işlem başına çok küçük görünse de, günlük operasyonların hacmi göz önüne alındığında milyonlarca dolarlık kâra dönüşebilir. Bu, bazı şirketlerin yalnızca bu yüksek düzeyde otomatikleştirilmiş finansal işlemlerle başarılı olmalarına olanak tanır.

FX (Döviz) alanında her zaman EUR/USD gibi para birimi çiftleriyle çalışırız. Çoğu durumda, bu değişimler çift yönlüdür (yani, EUR/USD ve USD/EUR) ve döviz kuru değeri her yönde farklılık gösterir.

Arbitraj Çifti, iki para biriminin (örneğin, EUR ve ABD Doları) değerleri arasındaki sayısal oranı temsil eder ve aralarındaki döviz kurunu belirler.

Potansiyel olarak, karlı ticaret için, kesin bahis olarak bilinen birden fazla ara para birimini kullanabiliriz.

Arbitraj kesin bahis, dairesel bir şekilde kullanılacak bir dizi çifttir. Devamını oku

Birçok sağlayıcı, kendi kârlarını güvence altına almak ve başkalarının bundan kâr etmesini önlemek için matematiksel modelleme ve analiz kullanır. Bu nedenle burada potansiyel terimi vurgulanmaktadır.

Kesin bahis uzunluğu, bir dizi potansiyel arbitraj fırsatı oluşturan çiftlerin sayısını ifade eder.

Gerçek dünyada döviz kurları farklı bankalar veya döviz platformları arasında değişiklik gösterebilir. Turistlerin mümkün olan en iyi fiyatı bulmak için bir şehri dolaşması alışılmadık bir durum değil. Bilgisayar yazılımıyla, sağlayıcıların listesine erişiminiz olduğunda bu işlem milisaniyeler içinde gerçekleştirilebilir.

Pratik karlı işlemlerde, birden fazla adım, farklı döviz platformlarında çeşitli para birimleri aracılığıyla dönüşümleri içerebilir. Başka bir deyişle Arbitraj Çemberi oldukça geniş olabilir.

Arbitraj Çemberi , bir para biriminin satın alınmasını, onu başka bir platforma aktarmayı, diğer para birimleriyle takas yapmayı ve sonuçta orijinal para birimine geri dönmeyi gerektirir.

Bir veya daha fazla ara para birimi aracılığıyla iki para birimi arasındaki döviz kuru , bu ara işlemlerin döviz kurlarının çarpımı olarak hesaplanır.

Bir örnek

Örneğin, İsviçre Frankını ABD Doları karşılığında satın almak, ardından Frankları Japon Yenine çevirmek ve sonra Yenleri yeniden ABD Doları karşılığında satmak istediğimizi düşünelim. 2023 Sonbaharında aşağıdaki döviz kurlarına sahibiz:

1. 1 USD karşılığında 0,91 CHF (İsviçre Frankı) alabiliyoruz.

2. 1 CHF karşılığında 163,16 Japon Yeni alabiliyoruz.

3. 1 Japon Yeni karşılığında 0,0067 USD alabiliyoruz.

   
   

Bunu bir tabloyla sunalım:

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

Şimdi bu değerlerin bir ürününü bulmamız gerekiyor. Bu ürün birden az bir değer sağladığında bir dizi işlem karlı hale gelir :

 1.098901099 * 0.006128953 * 149.2537313 = 1.005240803

Gördüğümüz gibi sonuç birden büyük, yani paramızın %0,05'ini kaybetmişiz gibi görünüyor. Ama tam olarak kaç tane? Bunu şu şekilde sıralayabiliriz:

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

Yani başlangıçta 1 ABD Doları sattıktan sonra 0,994 elde ediyoruz - sonunda 1 ABD Dolarından az.

Daha basit bir ifadeyle, Arbitraj Döngüsü, aynı para biriminin bir biriminden daha azı karşılığında bir birim para birimi elde edilebildiğinde karlıdır.

İlk işlemde 1 ABD Doları başına 0,91 CHF yerine 0,92 CHF alma fırsatı bulduğumuzu varsayalım:

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

Bir ürün 1'den az olacaktır:

 1.086956522 * 0.006128953 * 149.2537313 = 0.994314272

Bu, gerçek para birimlerinde bize 1 ABD Dolarından fazlasını vereceği anlamına geliyor:

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

Wuolah, biraz KÂR elde ettik! Şimdi grafik analizini kullanarak bunu nasıl otomatikleştireceğimizi görelim.

Dolayısıyla, 3 Arbitraj Çiftinden oluşan bir Arbitraj Çemberinde kar veya zararı kontrol etme formülü şöyle görünecektir:

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

Grafik gösterimi

Bu süreçleri otomatikleştirmek için grafikleri kullanabiliriz. Daha önce bahsedilen tablolar, doğal olarak, düğümlerin para birimlerini ve kenarların çift yönlü değişimleri temsil ettiği bir grafiğin matris temsiline dönüştürülebilir.

Dolayısıyla, iki çift değişimini matriste şu şekilde temsil etmek kolaydır:

 EUR USD 1 1 EUR 1 1 USD

İlgili çiftlerin sayısına bağlı olarak matrisimiz genişleyebilir:

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

Sonuç olarak, daha fazla değişim platformu ve kaynağı hesaba katarsak, tablomuz yalnızca iki para birimi için bile önemli ölçüde büyüyebilir.

Gerçek döviz arbitrajı problemlerini çözmek için döviz kotasyonlarına ilişkin tüm ilişkileri kapsayan tam bir grafik sıklıkla kullanılır. Üç dövizli bir döviz tablosu aşağıdaki gibi görünebilir:

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

Bellekteki döviz çiftlerimizi temsil etmek için basit bir grafik veri yapısı kullanabiliriz:

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

Şimdi sadece bu grafiği nasıl geçeceğimizi ve en karlı daireyi nasıl bulacağımızı bulmamız gerekiyor. Ama hâlâ bir sorun var...

Matematik bizi yine kurtardı

Klasik grafik algoritmaları, kenar uzunluklarının çarpımı ile çalışmak için pek uygun değildir çünkü bunlar , bu uzunlukların toplamı olarak tanımlanan yolları bulmak için tasarlanmıştır (iyi bilinen herhangi bir klasik yol bulma algoritmasının BFS, DFS, Dijkstra ve hatta uygulamalarına bakın). A-Yıldız ).

Ancak bu sınırlamayı aşmak için çarpımdan toplama geçişin matematiksel bir yolu vardır: logaritma. Bir ürün logaritmanın altında görünüyorsa, logaritma toplamına dönüştürülebilir.

Bu denklemin sağ tarafında istenen sayının birden küçük olması bu sayının logaritmasının sıfırdan küçük olması gerektiğini gösterir:

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

Bu basit matematik hilesi, kenar uzunluğu çarpımı birden küçük olan bir çevrimi aramaktan, kenar uzunluklarının toplamının sıfırdan küçük olduğu bir çevrimi aramaya geçiş yapmamızı sağlar.

LogE(x)'e dönüştürülen ve noktadan sonra 2 rakamla yuvarlanan matris değerlerimiz artık şu şekilde görünür:

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

Artık bu problem klasik grafik algoritmaları kullanılarak daha çözülebilir hale geliyor. İhtiyacımız olan şey, en karlı değişim yolunu bulmak için grafiğin üzerinden geçmektir.

Grafik algoritmaları

Her algoritmanın sınırlamaları vardır. Bunlardan bazılarından önceki yazımda bahsetmiştim.

Burada klasik BFS, DFS ve hatta Dijkstra'yı uygulayamayız çünkü grafiğimiz negatif ağırlıklar içerebilir ve bu da grafiği geçerken Negatif Döngülere yol açabilir. Negatif döngüler, her yinelemede sürekli olarak daha iyi çözümler bulduğu için algoritmaya zorluk teşkil eder.

Bu sorunu çözmek için Bellman-Ford algoritması basitçe yineleme sayısını sınırlandırır. Grafiğin her bir kenarını bir döngü içinde geçer ve tüm kenarlar için V-1 katından fazla olmayan gevşeme uygular (burada V, düğüm sayısıdır).

Bu nedenle Bellman-Ford algoritması, grafikteki iki düğüm arasındaki iki temel kriteri karşılayan yolların keşfedilmesine olanak tanıdığı için bu Arbitraj sisteminin kalbinde yer alır: negatif ağırlıklar içerirler ve negatif döngülerin parçası değildirler.

Bu algoritma teorik olarak basit olsa da (ve bununla ilgili milyarlarca video bulabilirsiniz), ihtiyaçlarımıza yönelik pratik uygulama biraz çaba gerektirir. Hadi derinlemesine inceleyelim.

Bellman-Ford algoritmasının uygulanması

Bu yazının amacı bilgisayar bilimi olduğu için gerçekle alakası olmayan hayali döviz kurlarını kullanacağım.

Algoritmaya daha düzgün bir giriş için, hiç negatif döngü içermeyen bir grafik kullanalım:

 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

Aşağıdaki kod örneği, grafikte negatif döngüler bulunmadığında Bellman-Ford algoritmasını kullanarak iki düğüm arasındaki yolu bulur:

 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; } }

Çin Yuanı için bu kodu çalıştırmak _preciousVertex dizisini doldurur ve şuna benzer sonuçlar verir:

 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)

Gördüğünüz gibi CNY ile diğer çeşitli para birimleri arasındaki en uygun yolları belirliyor.

Ve yine, makalenin amacı değil, nispeten basit bir görev olduğu için yalnızca en iyi olanı bulmaya odaklanmayacağım.

Yukarıdaki uygulama ideal durumlarda iyi çalışır ancak negatif döngüler içeren grafiklerle uğraşırken yetersiz kalır.

Negatif döngüleri tespit etme

Gerçekten ihtiyacımız olan şey, bir grafiğin negatif döngüler içerip içermediğini tespit edebilme ve eğer öyleyse sorunlu bölümleri tam olarak belirleyebilme yeteneğidir. Bu bilgi, bu sorunları azaltmamıza ve sonuçta karlı zincirleri keşfetmemize olanak tanır.

Yineleme sayısının her zaman tam olarak V - 1'e ulaşması gerekmez. (N+1)'inci döngüde, N'inci döngüdekinden daha iyi bir yol keşfedilmezse bir çözüm bulunmuş sayılır. Bu nedenle, hafif bir optimizasyon için yer vardır.

Daha önce bahsedilen kod, yalnızca yolları bulmakla kalmayıp, aynı zamanda bahsettiğim optimizasyon da dahil olmak üzere grafiğin negatif döngüler içerip içermediğini tespit edecek şekilde geliştirilebilir:

 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; }

Şimdi negatif döngüleri içeren daha karmaşık bir grafikle oynuyoruz:

 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

Programımız basitçe durur ve bir mesaj görüntüler:

 Graph contains negative cycle.

Sorunu gösterebildik ancak grafiğin sorunlu bölümleri arasında gezinmemiz gerekiyor.

Negatif döngülerden kaçınmak

Bunu başarmak için negatif döngülerin parçası olan köşeleri sabit bir değer olan NEG_INF ile işaretleyeceğiz:

 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; }

Artık, _shortestPath dizisinde NEG_INF ile karşılaşırsak, bir mesaj görüntüleyebilir ve diğer para birimleri için en uygun çözümleri belirlerken o segmenti atlayabiliriz. Örneğin, Düğüm 0 ile (USD'yi temsil eder):

 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)

Vay be! Verilerimizin "biraz kirli" olmasına rağmen kodumuz bir dizi karlı zinciri tanımlamayı başardı. Test verileri de dahil olmak üzere yukarıda bahsettiğimiz tüm kod örnekleri GitHub'ımda sizlerle paylaşılıyor.

Küçük dalgalanmalar bile önemlidir

Şimdi öğrendiklerimizi pekiştirelim. Üç para biriminin döviz kurlarının bir listesi verildiğinde olumsuz döngüleri kolaylıkla tespit edebiliriz:

 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);

Sonuç:

 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).

Ancak döviz kurlarındaki küçük değişiklikler bile (yani matriste yapılan ayarlamalar) önemli farklılıklara yol açabilir:

 // 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);

Bakın karlı bir zincir bulduk:

 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)

Bu kavramları birden fazla para birimini içeren çok daha büyük grafiklere uygulayabiliriz:

 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);

Sonuç olarak, kar elde etmek için birden fazla aday bulabiliriz:

 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) 

Ancak iki önemli faktör var:

1. Zaman, özellikle döviz fiyatlarındaki hızlı dalgalanmalar nedeniyle, arbitraj süreçlerinin uygulanmasında kritik bir faktördür. Sonuç olarak, kesin bir bahsin ömrü son derece kısadır.

2. Platformlar her işlem için komisyon alır.

   
   

Bu nedenle, kesin bahsin uzunluğunu sınırlandırarak zaman maliyetlerini en aza indirmek ve komisyonları azaltmak çok önemlidir.

Ampirik deneyim, kabul edilebilir bir kesin bahis uzunluğunun genellikle 2 ila 3 çift arasında değiştiğini göstermektedir. Bunun ötesinde, hesaplama gereksinimleri artıyor ve ticaret platformları daha büyük komisyonlar uyguluyor.

Dolayısıyla gelir elde etmek için bu tür teknolojilere sahip olmak yeterli değildir, aynı zamanda düşük seviyeli komisyonlara da erişmeniz gerekir. Genellikle yalnızca büyük finans kuruluşlarının elinde böyle bir kaynak vardır.

Akıllı sözleşmeleri kullanarak otomasyon

FX işlemlerinin mantığını ve bunlardan nasıl kar elde edileceğini derinlemesine inceledim ancak bu işlemleri gerçekleştirmek için kullanılan teknolojilere değinmedim. Bu konu biraz rotadan sapsa da akıllı sözleşmelerden bahsetmeden geçemedim.

Akıllı sözleşmeleri kullanmak, günümüzde döviz işlemlerini yürütmenin en yenilikçi yollarından biridir. Akıllı sözleşmeler, gecikme veya insan müdahalesi olmadan (akıllı sözleşmenin oluşturulması hariç) gerçek zamanlı FX işlemlerine olanak tanır.

Solidity, kripto para birimlerini içeren finansal işlemleri otomatikleştiren akıllı sözleşmeler oluşturmaya yönelik özel bir programlama dilidir. Akıllı sözleşmelerin dünyası dinamiktir ve hızlı teknolojik değişimlere ve gelişen düzenlemelere tabidir. Bu, cüzdanlar ve yasal uyumlulukla ilgili oldukça heyecan verici ve önemli risklerin olduğu bir alandır.

Kuşkusuz bu alandan kazanç sağlayan yetenekli bireyler ve ekipler varken, aynı zamanda piyasa kurallarının uygulanmasını sağlamaya çalışan düzenleyici kurumlar da var.

Bunu neden araştırıyoruz?

Küresel ekonominin karmaşıklığına, belirsizliğine ve öngörülemezliğine rağmen Döviz, finans dünyasında gizli bir itici güç olmaya devam ediyor. Bu, dünya çapında binlerce şirketin ve milyonlarca bireyin sınırları aşarak barışçıl bir şekilde işbirliği yapmasını, hizmet sunmasını ve karşılıklı olarak birbirlerine fayda sağlamasını sağlayan çok önemli bir unsurdur.

Elbette politika, düzenlemeler ve merkez bankaları gibi çeşitli faktörler döviz kurlarını ve döviz verimliliğini etkiliyor. Bu karmaşıklıklar finansal ortamı karmaşık hale getiriyor. Ancak bu karmaşıklıkların kamu yararına daha büyük bir amaca hizmet ettiğine inanmak önemlidir.

Çok sayıda bilimsel makale, küresel ekonomide döviz kurlarının varlığını ve belirlenmesini araştırıyor; bunlardan birkaçını saymak gerekirse:

• İthalatçı, İhracatçı ve Döviz Kuru Bağlantısının Kesilmesi

• Para birimi seçimi ve döviz kuru geçişkenliği

• Döviz kuru bulmacaları ve politikaları

  
  

Bu makaleler, Dövizlerin anlaşılması ve tek bir modele oturtulması hala zor olan bazı temel mekanizmalarına ışık tutmaktadır.

Yine de kodla oynamak ve pratik bir soruna çözüm bulmaya çalışmak, bu konuda biraz daha ipucu edinmeme yardımcı oldu. Umarım siz de bu küçük keşif gezisinden benim kadar keyif alırsınız.

Bizi izlemeye devam edin!

Bağlantılar

• Tüm bu örnekleri içeren kaynak kodu
• Sedgewick R. - C'de Algoritmalar, Bölüm 5: Grafik Algoritmaları
• Bellman Ford Algoritması Kodunun Uygulanması
• William Fiset'in GitHub örnekleri - Bitişiklik Matrisi Üzerine Bellman Ford
• William Fiset'in GitHub örnekleri - Bellman Ford On Edge Listesinde