Hoje, vamos falar sobre a importância de otimizar a estrutura do código.

Para o arbitragem, as duas coisas mais importantes são: 1) a taxa de utilização dos fundos; 2) a velocidade de compra.

A rapidez de pedidos geralmente depende da proximidade do servidor da bolsa e da compra de uma rede melhor. Mas, na verdade, para a maioria dos novatos, apenas otimizar a estrutura do código pode fazer com que a estratégia seja dezenas de milissegundos mais rápida, não menos do que o efeito de trocar uma rede melhor.

No entanto, quando há apenas um par de transações, a estrutura de código optimizada geralmente aumenta menos de 1 ms, quase não há diferença.

O aumento da taxa de utilização de fundos, muitas vezes requer a mesma quantia de dinheiro para observar vários pares de transações ao mesmo tempo, o que provoca um aumento no número de ciclos lógicos, e os benefícios da otimização da estrutura do código são evidentes. Em geral, a complexidade da pesquisa de múltiplos transações em várias plataformas é de O (n), que pode ser reduzida a O (n) ou até mesmo O (n) por otimização.*m) ((m) Quando os pares de negociação chegam a centenas e a bolsa observa dezenas ao mesmo tempo.

Por exemplo, um problema com o qual me deparo com frequência é que existem duas rotas de arbitragem, A-C e A-B-C, e que não podem ser usadas para qualquer tipo de negócio. Os dois caminhos precisam ser calculados duas vezes, uma vez que o caminho pode trazer lucro, assumindo que são p1 e p2, uma vez que o caminho é calculado especificamente para cada bolsa e suas transações para o preço e o montante que precisam de notação específica.

A forma mais comum é escrever uma função, cuja função é calcular o lucro, especificamente mencionar price e amount. Em seguida, chame a função de forma circular, obtendo o lucro de cada caminho e, em seguida, escolha o lucro mais alto para negociar.

É óbvio que só precisamos de calcular o lucro na comparação, sem ter que começar a calcular o preço e o montante do cartão.

Assim, na otimização, pode ser dividido em 2 funções profit e invocar ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

Então, se você analisar o código mais a fundo, descobrirá que, em geral, uma vez que um caminho tem lucro, ele é negociado por outros. Portanto, é muito difícil que haja vários caminhos que tenham lucro ao mesmo tempo.

Então, podemos melhorar ainda mais a estratégia, configurando um loop, um loop de declarações if, e se encontrarmos um caminho com um lucro, vamos quebrar e calcular o número de referências e o preço desse caminho.

Então a complexidade é reduzida de O (n+1) para O (m+1), m < n. Quando as oportunidades de negociação são iguais, m é aproximadamente igual a n/2, ou seja, a complexidade é reduzida para O (n/2+1)

Isto é, através de uma simples função de divisão, analisando a estrutura de otimização lógica, a complexidade de tempo pode ser reduzida de O (((2n) para O (((n/2+1) }}.

Na verdade, quando escrevo código, há uma grande quantidade de cenários que podem ser otimizados, e eu costumo escrever o código depois de terminado, e costumo descobrir que a lógica de otimização existe para otimizar algum O (n!) para O (n).*(n+1)). Às vezes, é possível até mesmo otimizar uma lógica que precisa de centenas de milissegundos para ser executada em menos de 1 ms.

Como um pequeno esforço de tempo, podemos reduzir drasticamente o intervalo entre as pesquisas de estratégia, mas também recomendamos que otimizemos a estrutura do código.