알고리즘의 마법: 외환에서 그래프 이론 활용

FinTech 스타트업 산업에 대해 잘 알고 계시다면 영국 런던에 본사를 둔 유명한 FinTech 거대 기업인 Revolut에 대해 들어보셨을 것입니다. 2015년에 설립된 Revolut는 상당한 투자를 유치했으며 영국에서 가장 빠르게 성장하는 스타트업 중 하나가 되어 많은 유럽 시민들에게 은행 서비스를 제공하고 있습니다.

은행 운영은 수익 창출 방법과 관련하여 종종 수수께끼에 싸여 있지만 2020년과 2021년 Revolut에 대한 일부 주요 수치는 수입원에 대해 어느 정도 밝혀주었습니다.

그림에서 볼 수 있듯이 이 네오뱅크 수익의 상당 부분은 외환(FX), 자산 관리(암호화폐 포함) 및 카드 서비스에서 발생합니다. 특히 2021년에는 FX가 가장 수익성이 높은 부문이 되었습니다.

소프트웨어 엔지니어이기도 한 내 친구는 몇 년 전 Revolut의 소프트웨어 엔지니어링 부서에서의 기술 인터뷰에 대한 흥미로운 이야기를 공유한 적이 있습니다. 그는 하나 이상의 중간 통화를 사용하여 두 통화를 변환하는 가장 수익성 있는 방법을 식별하는 알고리즘을 개발하는 임무를 맡았습니다. 즉, 그들은 통화 차익거래에 대한 전략을 찾고 있었습니다.

통화 차익거래 는 통화 거래자가 여러 거래를 통해 특정 통화 쌍에 대해 브로커가 제공하는 다양한 스프레드를 활용하는 거래 전략입니다.

알고리즘의 기초가 그래프 이론에 뿌리를 두어야 한다는 점이 과제에서 명시적으로 언급되었습니다.

FX 기초

FX(외환거래소)는 글로벌 무역에서 중추적인 역할을 하며 상호 연결된 세계의 기능을 뒷받침합니다. FX가 은행을 가장 부유한 조직으로 만드는 데에도 중요한 역할을 한다는 것은 분명합니다.

외환에서 창출되는 이익은 주로 매수(BID) 가격과 매도(ASK) 가격 간의 차이 또는 스프레드입니다. 이러한 차이는 거래당 미미해 보일 수 있지만 일일 작업량을 고려하면 수백만 달러의 이익이 누적될 수 있습니다. 이를 통해 일부 회사는 고도로 자동화된 재무 운영만으로 성공할 수 있습니다.

FX(외환) 영역에서는 항상 EUR/USD와 같은 통화 쌍을 사용합니다. 대부분의 경우 이러한 교환은 양방향(예: EUR/USD 및 USD/EUR)이며 환율 값은 각 방향에서 다릅니다.

차익 거래 쌍은 두 통화(예: EUR 및 미국 달러)의 가치 사이의 수치 비율을 나타내며 두 통화 간의 환율을 결정합니다.

잠재적으로 우리는 확실한 베팅 으로 알려진 수익성 있는 거래를 위해 여러 중간 통화를 사용할 수 있습니다.

차익거래 확실한 베팅은 순환 방식으로 사용되는 쌍 세트입니다. 더 읽어보세요

많은 공급자는 자신의 이익을 확보하고 다른 사람이 이익을 얻지 못하도록 수학적 모델링 및 분석을 사용합니다. 따라서 여기서는 잠재적이라는 용어가 강조됩니다.

확실한 베팅 길이는 일련의 잠재적 차익거래 기회를 구성하는 쌍의 수를 나타냅니다.

실제 세계에서는 환율이 은행이나 거래소 플랫폼에 따라 다를 수 있습니다. 관광객들이 가장 좋은 요금을 찾기 위해 도시를 여행하는 것은 드문 일이 아닙니다. 컴퓨터 소프트웨어를 사용하면 제공자 목록에 액세스할 수 있을 때 이 프로세스가 밀리초 내에 완료될 수 있습니다.

실제 수익성 있는 거래에서는 여러 단계에 걸쳐 다양한 교환 플랫폼에서 다양한 통화를 통한 변환이 포함될 수 있습니다. 즉, 재정거래 서클은 상당히 광범위할 수 있습니다.

Arbitrage Circle 에는 통화 획득, 이를 다른 플랫폼으로 전송, 다른 통화 교환 수행 및 궁극적으로 원래 통화로 반환이 수반됩니다.

하나 이상의 중간 통화를 통한 두 통화 간의 환율은 이러한 중간 거래의 환율의 곱 으로 계산됩니다.

예

예를 들어, 스위스 프랑크를 미국 달러로 구매한 다음 프랑크를 일본 엔화로 교환하고 다시 엔화를 미국 달러로 판매한다고 가정해 보겠습니다. 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보다 작은 가치를 산출하면 일련의 거래에서 수익성이 높아집니다 .

 1.098901099 * 0.006128953 * 149.2537313 = 1.005240803

보시다시피 결과가 1보다 크므로 돈의 0.05%를 잃은 것처럼 보입니다. 그런데 정확히 몇 명인가요? 우리는 그것을 다음과 같이 정리할 수 있습니다:

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

따라서 처음에 1달러를 팔고 나면 결국에는 1달러 미만인 0.994를 얻게 됩니다.

간단히 말해서 차익거래 사이클은 동일한 통화 1단위 미만으로 1단위 통화를 얻을 수 있을 때 수익성이 높습니다.

초기 거래에서 1 미국 달러당 0.91 CHF 대신 0.92 CHF를 받을 수 있는 기회를 찾았다고 가정해 보겠습니다.

 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

Wuolah, 우리는 약간의 이익을 얻었습니다! 이제 그래프 분석을 사용하여 이를 자동화하는 방법을 살펴보겠습니다.

따라서 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

결과적으로 더 많은 교환 플랫폼과 리소스를 고려하면 단 두 가지 통화에 대해서도 테이블이 상당히 커질 수 있습니다.

실제 통화 차익거래 문제를 해결하기 위해 통화 시세에 대한 모든 관계를 포괄하는 완전한 그래프가 활용되는 경우가 많습니다. 3개 통화 교환표는 다음과 같이 나타날 수 있습니다.

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

이제 우리는 이 그래프를 탐색하고 가장 수익성이 높은 원을 찾는 방법만 알아내면 됩니다. 하지만 아직 한 가지 문제가 남아있습니다..

수학이 다시 우리를 구해줍니다

기존 그래프 알고리즘은 모서리 길이의 합으로 정의된 경로를 찾도록 설계되었기 때문에 모서리 길이의 곱을 사용하는 데 적합하지 않습니다(잘 알려진 기존 경로 찾기 알고리즘인 BFS, DFS, Dijkstra 또는 심지어 구현 참조). 에이스타 ).

그러나 이러한 제한을 피하기 위해 곱에서 합계로 전환하는 수학적 방법인 로그가 있습니다. 제품이 로그 아래에 나타나면 로그의 합으로 변환될 수 있습니다.

이 방정식의 오른쪽에서 원하는 숫자는 1보다 작습니다. 이는 이 숫자의 로그가 0보다 작아야 함을 나타냅니다.

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

이 간단한 수학적 트릭을 사용하면 모서리 길이 의 곱이 1보다 작은 사이클 을 검색하는 것에서 모서리 길이의 합이 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

이제 이 문제는 기존 그래프 알고리즘을 사용하여 더 쉽게 해결할 수 있습니다. 우리에게 필요한 것은 가장 수익성이 높은 교환 경로를 찾기 위해 그래프를 탐색하는 것입니다.

그래프 알고리즘

모든 알고리즘에는 한계가 있습니다. 나는 이전 기사 에서 그들 중 일부를 언급했습니다.

그래프에 음수 가중치가 포함되어 그래프를 순회하는 동안 음수 순환이 발생할 수 있으므로 여기서는 기존 BFS, DFS 또는 Dijkstra를 적용할 수 없습니다. 네거티브 사이클은 각 반복에서 더 나은 솔루션을 지속적으로 찾기 때문에 알고리즘에 문제를 제기합니다.

이 문제를 해결하기 위해 Bellman-Ford 알고리즘은 단순히 반복 횟수를 제한합니다. 이는 한 주기로 그래프의 각 가장자리를 순회하며 V-1회(V는 노드 수) 이하로 모든 가장자리에 완화를 적용합니다.

따라서 Bellman-Ford 알고리즘은 두 가지 필수 기준을 충족하는 그래프의 두 노드 사이의 경로를 발견할 수 있기 때문에 이 차익거래 시스템의 핵심입니다. 즉, 음수 가중치를 포함하고 음수 사이클의 일부가 아닙니다.

이 알고리즘은 이론적으로는 간단하지만(수억 개의 관련 동영상을 찾을 수 있음), 요구 사항을 실제로 구현하려면 약간의 노력이 필요합니다. 그것을 파헤쳐 보자.

Bellman-Ford 알고리즘 구현

이 글의 목적은 컴퓨터 과학이므로 실제 환율과 아무런 관련이 없는 가상의 환율을 사용하겠습니다.

알고리즘을 보다 원활하게 소개하기 위해 음의 순환이 전혀 포함되지 않은 그래프를 사용하겠습니다.

 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

아래 코드 예제는 그래프에 음수 사이클이 없을 때 Bellman-Ford 알고리즘을 사용하여 두 노드 사이의 경로를 찾습니다.

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

우와! 우리의 데이터가 "약간 더러운" 사실에도 불구하고 우리의 코드는 수익성 있는 여러 체인을 식별할 수 있었습니다. 테스트 데이터를 포함하여 위에서 언급한 모든 코드 예제는 내 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페어 범위입니다. 이 외에도 계산 요구 사항이 증가하고 거래 플랫폼은 더 큰 수수료를 부과합니다.

따라서, 그러한 기술을 보유하는 것만으로는 수익을 창출하는 것만으로는 충분하지 않지만 낮은 수준의 수수료에 대한 접근도 필요합니다. 일반적으로 대규모 금융 기관만이 그러한 자원을 보유하고 있습니다.

스마트 계약을 사용한 자동화

나는 FX 운영의 논리와 그로부터 이익을 얻는 방법을 탐구했지만 이러한 운영을 실행하는 데 사용되는 기술은 다루지 않았습니다. 이 주제는 약간 주제에서 벗어나 있지만 스마트 계약에 대한 언급을 생략할 수는 없습니다.

스마트 계약을 사용하는 것은 오늘날 FX 운영을 수행하는 가장 혁신적인 방법 중 하나입니다. 스마트 계약을 사용하면 지연이나 사람의 개입 없이 실시간 FX 작업이 가능합니다(스마트 계약 생성 제외).

Solidity는 암호화폐와 관련된 금융 운영을 자동화하는 스마트 계약을 생성하기 위한 전문 프로그래밍 언어입니다. 스마트 계약의 세계는 역동적이며 급격한 기술 변화와 진화하는 규정의 영향을 받습니다. 지갑 및 법률 준수와 관련하여 상당한 과장과 위험이 있는 영역입니다.

이 분야에서 이익을 얻는 의심할 여지 없이 재능 있는 개인과 팀이 있는 반면, 시장 규칙이 유지되도록 노력하는 규제 기관도 있습니다.

우리가 이것을 조사하는 이유는 무엇입니까?

글로벌 경제의 복잡성, 모호함, 예측 불가능성에도 불구하고 외환은 금융계의 숨겨진 원동력으로 남아 있습니다. 이는 전 세계 수천 개의 기업과 수백만 명의 개인이 국경을 초월하여 평화로운 방식으로 협력하고, 서비스를 제공하고, 상호 이익을 얻을 수 있도록 하는 중요한 요소입니다.

물론 정치, 규제, 중앙은행 등 다양한 요인이 환율과 외환효율성에 영향을 미칩니다. 이러한 복잡성으로 인해 금융 환경이 복잡해집니다. 그러나 이러한 복잡성이 공동선을 위한 더 큰 목적에 기여한다고 믿는 것이 중요합니다.

수많은 과학 논문은 세계 경제에서 환율의 존재와 결정을 탐구합니다. 그 중 몇 가지를 언급하면 다음과 같습니다.

• 수입업자, 수출업자 및 환율 연결 해제

• 통화 선택 및 환율 전달

• 환율 퍼즐 및 정책

  
  

이 논문은 여전히 이해하기 어렵고 하나의 모델에 적용하기 어려운 외환의 몇 가지 기본 메커니즘을 조명합니다.

하지만 코드를 가지고 놀면서 실제적인 문제에 대한 해결책을 찾으려고 노력하는 것은 제가 그것에 대한 좀 더 많은 단서를 얻는 데 도움이 되었습니다. 여러분도 저만큼 이 작은 탐험 여행을 즐겼기를 바랍니다.

계속 지켜봐 주시기 바랍니다!

연결

• 이 모든 예제가 포함된 소스 코드
• Sedgewick R. - C 알고리즘, 5부: 그래프 알고리즘
• Bellman Ford 알고리즘 코드 구현
• William Fiset의 GitHub 예제 - 인접 매트릭스에 대한 Bellman Ford
• William Fiset의 GitHub 예제 - Bellman Ford On Edge 목록