Thuật toán thuật toán: Khai thác lý thuyết đồ thị trong ngoại hối

Nếu quen thuộc với ngành khởi nghiệp FinTech, bạn có thể đã nghe nói đến Revolut, một gã khổng lồ FinTech nổi tiếng có trụ sở tại London, Vương quốc Anh. Được thành lập vào năm 2015, Revolut đã thu hút được những khoản đầu tư đáng kể và trở thành một trong những công ty khởi nghiệp phát triển nhanh nhất ở Anh, cung cấp dịch vụ ngân hàng cho nhiều công dân Châu Âu.

Mặc dù hoạt động ngân hàng thường bị che giấu trong bí ẩn về cách chúng tạo ra doanh thu, một số số liệu quan trọng về Revolut trong năm 2020 và 2021 đã làm sáng tỏ nguồn thu nhập của họ:

Như đã minh họa, một phần đáng kể doanh thu của neobank này đến từ Ngoại hối (FX), quản lý tài sản (bao gồm cả tiền điện tử) và dịch vụ thẻ. Đáng chú ý, năm 2021, FX trở thành lĩnh vực sinh lời nhiều nhất.

Một người bạn của tôi, cũng là kỹ sư phần mềm, từng chia sẻ một câu chuyện hấp dẫn về cuộc phỏng vấn kỹ thuật của anh ấy tại bộ phận Kỹ thuật phần mềm của Revolut vài năm trước. Ông được giao nhiệm vụ phát triển một thuật toán để xác định cách có lợi nhất để chuyển đổi hai loại tiền tệ bằng cách sử dụng một hoặc nhiều loại tiền tệ trung gian. Nói cách khác, họ đang tìm kiếm một chiến lược cho Arbitrage tiền tệ.

Arbitrage tiền tệ là một chiến lược giao dịch trong đó một nhà giao dịch tiền tệ tận dụng các mức chênh lệch khác nhau do các nhà môi giới cung cấp cho một cặp tiền tệ cụ thể thông qua nhiều giao dịch.

Nó đã được đề cập rõ ràng trong nhiệm vụ rằng nền tảng của thuật toán phải bắt nguồn từ lý thuyết đồ thị.

Khái niệm cơ bản về FX

FX, hay Ngoại hối, đóng một vai trò then chốt trong thương mại toàn cầu, củng cố hoạt động của thế giới kết nối của chúng ta. Rõ ràng là FX cũng đóng một vai trò quan trọng trong việc đưa ngân hàng trở thành một trong những tổ chức giàu có nhất.

Lợi nhuận tạo ra từ ngoại hối chủ yếu là chênh lệch hoặc chênh lệch giữa giá mua (BID) và giá bán (ASK). Mặc dù sự khác biệt này có thể xuất hiện rất nhỏ trên mỗi giao dịch nhưng nó có thể tích lũy thành hàng triệu đô la lợi nhuận dựa trên khối lượng hoạt động hàng ngày. Điều này cho phép một số công ty phát triển mạnh mẽ chỉ dựa vào các hoạt động tài chính tự động hóa cao này.

Trong lĩnh vực FX (Ngoại hối), chúng tôi luôn làm việc với các cặp tiền tệ, chẳng hạn như EUR/USD. Trong hầu hết các trường hợp, các sàn giao dịch này là hai chiều (tức là EUR/USD và USD/EUR) và giá trị tỷ giá hối đoái khác nhau theo mỗi hướng.

Cặp chênh lệch giá đại diện cho tỷ lệ số giữa giá trị của hai loại tiền tệ (ví dụ: EUR và Đô la Mỹ), xác định tỷ giá hối đoái giữa chúng.

Có khả năng, chúng ta có thể sử dụng nhiều loại tiền tệ trung gian để giao dịch có lợi nhuận, được gọi là đặt cược chắc chắn .

Cược chắc chắn bằng chênh lệch giá là một tập hợp các cặp được sử dụng theo cách vòng tròn. Đọc thêm

Nhiều nhà cung cấp sử dụng mô hình toán học và phân tích để đảm bảo lợi nhuận của chính họ và ngăn chặn người khác thu lợi từ họ. Do đó, thuật ngữ tiềm năng được nhấn mạnh ở đây.

Độ dài đặt cược chắc chắn đề cập đến số lượng các cặp tạo thành một tập hợp các cơ hội chênh lệch giá tiềm năng.

Trong thế giới thực, tỷ giá hối đoái có thể khác nhau giữa các ngân hàng hoặc nền tảng trao đổi khác nhau. Không có gì lạ khi khách du lịch đi ngang qua một thành phố để tìm được mức giá tốt nhất có thể. Với phần mềm máy tính, quá trình này có thể được thực hiện trong vòng một phần nghìn giây khi bạn có quyền truy cập vào danh sách nhà cung cấp.

Trong các giao dịch có lợi nhuận thực tế, nhiều bước có thể liên quan đến chuyển đổi thông qua nhiều loại tiền tệ khác nhau trên các nền tảng trao đổi khác nhau. Nói cách khác, Vòng tròn Arbitrage có thể khá rộng.

Vòng tròn chênh lệch giá đòi hỏi phải có được một loại tiền tệ, chuyển nó sang nền tảng khác, tiến hành trao đổi với các loại tiền tệ khác và cuối cùng quay trở lại loại tiền ban đầu.

Tỷ giá hối đoái giữa hai đồng tiền thông qua một hoặc nhiều đồng tiền trung gian được tính bằng tích của tỷ giá hối đoái của các giao dịch trung gian này .

Một ví dụ

Ví dụ: hãy tưởng tượng chúng ta muốn mua Frank Thụy Sĩ bằng Đô la Mỹ, sau đó đổi Frank sang Yên Nhật, sau đó bán lại Yên lấy Đô la Mỹ. Vào mùa thu năm 2023, chúng tôi có tỷ giá hối đoái sau:

1. Chúng ta có thể mua 0,91 CHF (Frank Thụy Sĩ) với giá 1 USD.

2. Chúng ta có thể mua 163,16 Yên Nhật với giá 1 CHF.

3. Chúng ta có thể mua 0,0067 USD cho 1 Yên Nhật.

   
   

Hãy trình bày nó với một bảng:

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

Bây giờ, chúng ta cần tìm tích của những giá trị đó. Một chuỗi các giao dịch sẽ có lãi khi sản phẩm này mang lại giá trị nhỏ hơn một :

 1.098901099 * 0.006128953 * 149.2537313 = 1.005240803

Như chúng ta có thể thấy, kết quả lớn hơn một, nên có vẻ như chúng ta đã mất 0,05% số tiền của mình. Nhưng chính xác có bao nhiêu? Chúng ta có thể sắp xếp nó như thế này:

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

Vì vậy, sau khi bán 1 đô la Mỹ lúc đầu, chúng tôi nhận được 0,994 - cuối cùng ít hơn 1 đô la Mỹ.

Nói một cách đơn giản hơn, Chu kỳ chênh lệch giá có lãi khi có thể thu được một đơn vị tiền tệ với ít hơn một đơn vị cùng loại tiền tệ.

Hãy tưởng tượng chúng ta đã tìm thấy cơ hội kiếm được 0,92 CHF trên 1 Đô la Mỹ trong giao dịch ban đầu, thay vì 0,91 CHF:

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

Một sản phẩm sẽ nhỏ hơn 1:

 1.086956522 * 0.006128953 * 149.2537313 = 0.994314272

Điều đó có nghĩa là, bằng tiền thật, nó sẽ mang lại cho chúng ta nhiều hơn 1 Đô la Mỹ:

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

Wuolah, chúng tôi đã nhận được một số LỢI NHUẬN! Bây giờ, hãy xem cách tự động hóa việc này bằng cách sử dụng phân tích biểu đồ.

Vì vậy, công thức để kiểm tra lãi hoặc lỗ trong Vòng tròn chênh lệch giá gồm 3 cặp chênh lệch giá sẽ như sau:

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

Biểu diễn đồ thị

Để tự động hóa các quy trình đó, chúng ta có thể sử dụng biểu đồ. Các bảng được đề cập trước đó có thể được chuyển đổi một cách tự nhiên thành biểu diễn ma trận của biểu đồ, trong đó các nút biểu thị tiền tệ và các cạnh biểu thị trao đổi hai chiều.

Do đó, có thể dễ dàng biểu diễn hai cặp trao đổi trong ma trận như sau:

 EUR USD 1 1 EUR 1 1 USD

Tùy thuộc vào số lượng cặp liên quan, ma trận của chúng tôi có thể mở rộng:

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

Do đó, bảng của chúng tôi có thể trở nên lớn hơn đáng kể, thậm chí chỉ đối với hai loại tiền tệ, nếu chúng tôi tính đến nhiều nền tảng và tài nguyên trao đổi hơn.

Để giải quyết các vấn đề chênh lệch giá tiền tệ thực, một biểu đồ hoàn chỉnh bao gồm tất cả các mối quan hệ về báo giá tiền tệ thường được sử dụng. Bảng trao đổi ba loại tiền tệ có thể xuất hiện như sau:

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

Chúng ta có thể sử dụng cấu trúc dữ liệu biểu đồ đơn giản để thể hiện các cặp tiền tệ trong bộ nhớ:

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

Bây giờ, chúng ta chỉ cần tìm ra cách đi qua biểu đồ này và tìm ra vòng tròn có lợi nhất. Nhưng vẫn còn một vấn đề...

Toán học lại cứu chúng ta

Các thuật toán đồ thị cổ điển không phù hợp để làm việc với tích có độ dài cạnh vì chúng được thiết kế để tìm các đường dẫn được xác định bằng tổng của các độ dài này (xem phần triển khai của bất kỳ thuật toán tìm đường cổ điển nổi tiếng nào BFS, DFS, Dijkstra hoặc thậm chí A-Star ).

Tuy nhiên, để tránh hạn chế này, có một cách toán học để chuyển từ tích thành tổng: logarit. Nếu một tích xuất hiện dưới dạng logarit, nó có thể được chuyển đổi thành tổng logarit.

Ở bên phải của phương trình này, số mong muốn nhỏ hơn một, cho biết logarit của số này phải nhỏ hơn 0:

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

Thủ thuật toán học đơn giản này cho phép chúng ta chuyển từ tìm kiếm một chu trình có tích độ dài cạnh nhỏ hơn một sang tìm kiếm một chu trình trong đó tổng độ dài các cạnh nhỏ hơn 0 .

Các giá trị ma trận của chúng tôi được chuyển đổi thành LogE(x) và được làm tròn với 2 chữ số sau dấu phẩy, bây giờ trông như thế này:

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

Bây giờ vấn đề này trở nên dễ giải quyết hơn bằng cách sử dụng thuật toán đồ thị cổ điển. Những gì chúng ta cần là duyệt qua biểu đồ để tìm con đường trao đổi có lợi nhất.

Thuật toán đồ thị

Mọi thuật toán đều có những hạn chế của nó. Tôi đã đề cập đến một số trong số họ trong bài viết trước của tôi .

Chúng tôi không thể áp dụng BFS, DFS cổ điển hoặc thậm chí Dijkstra ở đây vì biểu đồ của chúng tôi có thể chứa các trọng số âm, điều này có thể dẫn đến Chu kỳ âm khi nó đi qua biểu đồ. Chu kỳ âm đặt ra thách thức cho thuật toán vì nó liên tục tìm ra giải pháp tốt hơn trên mỗi lần lặp.

Để giải quyết vấn đề này, thuật toán Bellman-Ford chỉ giới hạn số lần lặp. Nó đi qua từng cạnh của đồ thị theo một chu kỳ và áp dụng sự thư giãn cho tất cả các cạnh không quá V-1 lần (trong đó V là một số nút).

Do đó, thuật toán Bellman-Ford nằm ở trung tâm của hệ thống Arbitrage này, vì nó cho phép khám phá các đường dẫn giữa hai nút trong biểu đồ đáp ứng hai tiêu chí thiết yếu: chúng chứa trọng số âm và không phải là một phần của chu kỳ âm.

Mặc dù thuật toán này đơn giản về mặt lý thuyết (và bạn có thể tìm thấy hàng tỷ video về nó), nhưng việc triển khai thực tế cho nhu cầu của chúng ta đòi hỏi một chút nỗ lực. Hãy đi sâu vào nó.

Triển khai thuật toán Bellman-Ford

Vì mục đích của bài viết này là khoa học máy tính nên tôi sẽ sử dụng tỷ giá hối đoái ảo không liên quan gì đến tỷ giá thực.

Để giới thiệu thuật toán dễ dàng hơn, hãy sử dụng biểu đồ hoàn toàn không chứa chu kỳ â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

Ví dụ mã bên dưới tìm đường dẫn giữa hai nút bằng thuật toán Bellman-Ford khi biểu đồ thiếu chu kỳ âm:

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

Chạy mã này cho Nhân dân tệ Trung Quốc sẽ điền vào mảng _previousVertex và mang lại kết quả như sau:

 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)

Như bạn có thể quan sát, nó xác định đường đi tối ưu giữa CNY và nhiều loại tiền tệ khác.

Và một lần nữa, tôi sẽ không tập trung vào việc chỉ tìm một cái tốt nhất, vì đây là nhiệm vụ tương đối đơn giản và không phải là mục tiêu của bài viết.

Việc triển khai ở trên hoạt động tốt trong các trường hợp lý tưởng nhưng lại không hiệu quả khi xử lý các biểu đồ chứa chu kỳ âm.

Phát hiện chu kỳ tiêu cực

Điều chúng ta thực sự cần là khả năng xác định xem biểu đồ có chứa các chu kỳ âm hay không và nếu có, hãy xác định chính xác các phân đoạn có vấn đề. Kiến thức này cho phép chúng tôi giảm thiểu những vấn đề này và cuối cùng khám phá ra các chuỗi có lợi nhuận.

Số lần lặp không phải lúc nào cũng phải đạt chính xác V - 1. Một giải pháp được coi là tìm thấy nếu trên chu kỳ (N+1)-th, không có đường đi nào tốt hơn đường đi trong chu kỳ thứ N được phát hiện. Vì vậy, có chỗ để tối ưu hóa một chút.

Mã được đề cập trước đó có thể được cải tiến để không chỉ tìm đường dẫn mà còn phát hiện xem biểu đồ có chứa chu kỳ âm hay không, bao gồm cả tối ưu hóa mà tôi đã đề cập:

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

Và bây giờ chúng ta chơi với một biểu đồ phức tạp hơn bao gồm các chu kỳ âm:

 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

Chương trình của chúng tôi chỉ đơn giản là tạm dừng và hiển thị một thông báo:

 Graph contains negative cycle.

Tuy nhiên, chúng tôi đã có thể chỉ ra vấn đề, chúng tôi cần điều hướng xung quanh các phân đoạn có vấn đề của biểu đồ.

Tránh chu kỳ tiêu cực

Để thực hiện điều này, chúng ta sẽ đánh dấu các đỉnh là một phần của chu kỳ âm bằng giá trị không đổi, 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; }

Bây giờ, nếu chúng ta gặp NEG_INF trong mảng _shortestPath, chúng ta có thể hiển thị thông báo và bỏ qua phân đoạn đó trong khi vẫn xác định các giải pháp tối ưu cho các loại tiền tệ khác. Ví dụ: với Node 0 (đại diện cho USD):

 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)

Chao ôi! Mã của chúng tôi có thể xác định một số chuỗi có lợi nhuận mặc dù thực tế là dữ liệu của chúng tôi "hơi bẩn". Tất cả các ví dụ về mã được đề cập ở trên bao gồm cả dữ liệu thử nghiệm đều được chia sẻ với bạn trên GitHub của tôi .

Ngay cả những biến động nhỏ cũng quan trọng

Bây giờ chúng ta hãy củng cố những gì chúng ta đã học được. Đưa ra danh sách tỷ giá hối đoái của ba loại tiền tệ, chúng ta có thể dễ dàng phát hiện các chu kỳ tiêu cực:

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

Kết quả:

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

Tuy nhiên, ngay cả những thay đổi nhỏ trong tỷ giá hối đoái (tức là điều chỉnh ma trận) cũng có thể dẫn đến những khác biệt đáng kể:

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

Hãy nhìn xem, chúng tôi đã tìm thấy một chuỗi có lợi nhuận:

 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)

Chúng ta có thể áp dụng những khái niệm này cho các biểu đồ lớn hơn nhiều, liên quan đến nhiều loại tiền tệ:

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

Do đó, chúng tôi có thể tìm thấy nhiều ứng viên để nhận được lợi nhuận:

 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) 

Tuy nhiên, có hai yếu tố quan trọng:

1. Thời gian là một yếu tố quan trọng trong việc thực hiện các quy trình chênh lệch giá, chủ yếu là do sự biến động nhanh chóng của giá tiền tệ. Kết quả là, thời gian tồn tại của một cược chắc chắn là cực kỳ ngắn.

2. Nền tảng tính phí hoa hồng cho mỗi giao dịch.

   
   

Do đó, việc giảm thiểu chi phí thời gian và giảm hoa hồng là điều tối quan trọng, đạt được bằng cách giới hạn thời gian đặt cược chắc chắn.

Kinh nghiệm thực nghiệm cho thấy rằng độ dài đặt cược chắc chắn có thể chấp nhận được thường dao động từ 2 đến 3 cặp. Ngoài ra, các yêu cầu tính toán sẽ tăng cao và các nền tảng giao dịch sẽ áp đặt mức hoa hồng lớn hơn.

Vì vậy, để kiếm thu nhập thì chỉ cần có những công nghệ như vậy là chưa đủ mà bạn còn cần có quyền truy cập vào các khoản hoa hồng cấp thấp. Thông thường, chỉ có các tổ chức tài chính lớn mới có trong tay nguồn lực như vậy.

Tự động hóa bằng hợp đồng thông minh

Tôi đã đi sâu vào logic của hoạt động ngoại hối và cách kiếm lợi nhuận từ chúng, nhưng tôi chưa đề cập đến các công nghệ được sử dụng để thực hiện các hoạt động này. Mặc dù chủ đề này hơi chệch hướng nhưng tôi không thể bỏ qua việc đề cập đến hợp đồng thông minh.

Sử dụng hợp đồng thông minh là một trong những cách sáng tạo nhất để tiến hành các hoạt động FX hiện nay. Hợp đồng thông minh cho phép hoạt động ngoại hối theo thời gian thực mà không bị chậm trễ hoặc không có sự can thiệp của con người (ngoại trừ việc tạo hợp đồng thông minh).

Solidity là ngôn ngữ lập trình chuyên dụng để tạo các hợp đồng thông minh tự động hóa các hoạt động tài chính liên quan đến tiền điện tử. Thế giới hợp đồng thông minh rất năng động và chịu sự thay đổi nhanh chóng về công nghệ cũng như các quy định ngày càng phát triển. Đó là một lĩnh vực có sự cường điệu đáng kể và rủi ro đáng kể liên quan đến ví tiền và việc tuân thủ pháp luật.

Mặc dù chắc chắn có những cá nhân và nhóm tài năng đang thu lợi nhuận từ lĩnh vực này, nhưng cũng có những cơ quan quản lý đang cố gắng đảm bảo các quy tắc thị trường được tuân thủ.

Tại sao chúng ta lại xem xét điều này?

Bất chấp sự phức tạp, mơ hồ và khó đoán của kinh tế toàn cầu, Ngoại hối vẫn là một động lực tiềm ẩn trong thế giới tài chính. Đó là một yếu tố quan trọng cho phép hàng nghìn công ty và hàng triệu cá nhân trên toàn thế giới cộng tác, cung cấp dịch vụ và cùng có lợi cho nhau một cách hòa bình, xuyên biên giới.

Tất nhiên, có nhiều yếu tố khác nhau, chẳng hạn như chính trị, quy định và ngân hàng trung ương, ảnh hưởng đến tỷ giá hối đoái và hiệu quả ngoại hối. Những sự phức tạp này làm cho bối cảnh tài chính trở nên phức tạp. Tuy nhiên, điều cần thiết là phải tin rằng những sự phức tạp này phục vụ mục đích lớn hơn cho lợi ích chung.

Nhiều bài báo khoa học đi sâu vào sự tồn tại và quy định của tỷ giá hối đoái trong nền kinh tế toàn cầu, có thể kể đến một số:

• Nhà nhập khẩu, nhà xuất khẩu và tỷ giá hối đoái Ngắt kết nối

• Lựa chọn tiền tệ và truyền dẫn tỷ giá hối đoái

• Câu đố và chính sách tỷ giá hối đoái

  
  

Những bài viết này làm sáng tỏ một số cơ chế cơ bản của Ngoại hối, những cơ chế này vẫn khó hiểu và khó phù hợp với một mô hình.

Tuy nhiên, việc chơi với mã và cố gắng tìm ra giải pháp cho một vấn đề thực tế đã giúp tôi có thêm một chút manh mối về nó. Tôi hy vọng bạn cũng thích chuyến đi khám phá nhỏ này giống như tôi.

Giữ nguyên!

Liên kết

• Mã nguồn với tất cả các ví dụ này
• Sedgewick R. - Thuật toán trong C, Phần 5: Thuật toán đồ thị
• Triển khai mã thuật toán Bellman Ford
• Ví dụ về GitHub của William Fiset - Bellman Ford On Adjacency Matrix
• Ví dụ về GitHub của William Fiset - Danh sách Bellman Ford On Edge