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ı. , 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. Döviz Arbitrajı 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. 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. Arbitraj Çifti, Potansiyel olarak, karlı ticaret için, olarak bilinen birden fazla ara para birimini kullanabiliriz. kesin bahis dairesel bir şekilde kullanılacak bir dizi çifttir. Arbitraj kesin bahis, 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. bir dizi potansiyel arbitraj fırsatı oluşturan çiftlerin sayısını ifade eder. Kesin bahis uzunluğu, 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. , 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. Arbitraj Çemberi Bir veya daha fazla ara para birimi aracılığıyla iki para birimi arasındaki döviz kuru olarak hesaplanır. , bu ara işlemlerin döviz kurlarının çarpımı 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 USD karşılığında 0,91 CHF (İsviçre Frankı) alabiliyoruz. 1 CHF karşılığında 163,16 Japon Yeni alabiliyoruz. 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, Şimdi grafik analizini kullanarak bunu nasıl otomatikleştireceğimizi görelim. biraz KÂR elde ettik! 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 kullanabiliriz: grafik veri yapısı class GraphNode { public: string Name; }; class Graph { public: vector > Matrix; vector 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ı, ile çalışmak için pek uygun değildir çünkü bunlar olarak tanımlanan yolları bulmak için tasarlanmıştır (iyi bilinen herhangi bir klasik yol bulma algoritmasının uygulamalarına bakın). ). kenar uzunluklarının çarpımı , bu uzunlukların toplamı BFS, DFS, Dijkstra ve hatta 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 birden küçük olan bir çevrimi geçiş yapmamızı sağlar. çarpımı aramaktan, kenar uzunluklarının toplamının sıfırdan küçük olduğu bir çevrimi aramaya 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 bahsetmiştim. önceki yazımda 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 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. Negatif Döngülere 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 _shortestPath; vector _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 _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 dizisini doldurur ve şuna benzer sonuçlar verir: _preciousVertex 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 _shortestPath; vector _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 _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 _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 _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 _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 sizlerle paylaşılıyor. GitHub'ımda 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: 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. Platformlar her işlem için komisyon alır. Bu nedenle, kesin bahsin uzunluğunu sınırlandırarak ve çok önemlidir. zaman maliyetlerini en aza indirmek komisyonları azaltmak 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 da yayınlandı. Burada