Optimização dos algoritmos. - página 7

Novo comentário
 
komposter:

Como pode ter tanta certeza?

O meu cheque mostra o contrário:

O guião mq4 está no anexo.

Parece que a divisão do laço funciona realmente mais rapidamente. Mas não percebo porquê, porque faz dois passes.
 
No entanto, ainda não é a opção mais rápida. Mas isto é um 'blá blá' da minha parte, uma vez que não vou escrever um rápido.
 
hrenfx:
No entanto, ainda não é a opção mais rápida. Mas é um 'blá blá' da minha parte, uma vez que não vou escrever um rápido.
Nem eu. Embora eu concorde - pode ser mais rápido.
 
hrenfx:
No entanto, ainda não é a opção mais rápida. Mas é um "blá blá" da minha parte, pois não vou escrever um "blá blá" rápido.
MetaDriver:
Eu também não o farei. Mas concordo - poderia ser mais rápido.

Bem, não o faça! Naufragado:(

Eu próprio vou escrever este algoritmo, já sei como. Só que agora estou doente, vou ter de adiar por uma semana.

 
TheXpert:
C.T.D. escreveu exactamente isso no seu primeiro post.
Não reivindicando a primazia, concordei de certa forma com a sugestão: "melhor para realmente dividir em 2 ciclos" )
 
C-4:
A divisão por ciclos parece funcionar mais rapidamente. Mas não compreendo porquê, uma vez que os passes se tornam dois.
Porque cada passe tem o dobro do número de verificações, e os próprios passes ficam muitas vezes mais curtos (interrompidos prematuramente).
 
MetaDriver:
E não o farei. Embora eu concorde - pode ser mais rápido.

Eu também não o farei, embora seja definitivamente possível mais depressa ;)

Acabei de reparar que falta uma pausa, por isso não posso ir mais fundo nisso agora.

 

Aqui está o código final. É apresentada uma função de pesquisa máxima. A função de encontrar os mínimos é semelhante:

private BitArray Up()
        {
            BitArray bits = new BitArray(MyQuotes.Count);
            double max = double.MinValue;
            int pperiod = (Period - 1) / 2;
            int bar = pperiod;
            int count = MyQuotes.Count - pperiod;
            //последняя позиция второго перебора.
            int pos = bar;
            bool rev = false;
            int rpos = bar;
            bool FirstEnter = false;
            while (bar < count - 1)
            {
                for (int i = 1; i <= pperiod; i++)
                {
                    max = MyQuotes.High[bar - i] > MyQuotes.High[bar + i]
                              ? MyQuotes.High[bar - i]
                              : MyQuotes.High[bar + i];
                    pos = bar + i;
                    if (max > MyQuotes.High[bar])
                    {
                        bar = pos;
                        break;
                    }
                    if (MyQuotes.High[bar + i] == MyQuotes.High[bar] && FirstEnter == false)
                    {
                        rev = true;
                        rpos = bar + i;
                        FirstEnter = true;
                    }
                    if (i == pperiod)
                    {
                        bits[bar] = true;
                        bar = rev ? rpos : pos;
                        rev = false;
                        FirstEnter = false;
                    }
                }
            }
            return bits;
        }

Aqui estão os testes de desempenho:

3       00:00:00.5070290
4       00:00:00.3920224
5       00:00:00.3960227
6       00:00:00.3620207
7       00:00:00.3570204
8       00:00:00.3230185
9       00:00:00.3350192
10      00:00:00.2820161
11      00:00:00.2910166
12      00:00:00.2730157
13      00:00:00.2990171
14      00:00:00.2450140
15      00:00:00.2770158
16      00:00:00.2890165
17      00:00:00.2480142
18      00:00:00.2400138
19      00:00:00.2530144
20      00:00:00.2410138
21      00:00:00.2660152
22      00:00:00.2310132
23      00:00:00.2350135
24      00:00:00.2290131
25      00:00:00.2300131
26      00:00:00.2390137
27      00:00:00.2290131
28      00:00:00.2350135
29      00:00:00.2290131
30      00:00:00.2530144
31      00:00:00.2200126
32      00:00:00.2680153
33      00:00:00.2250129
34      00:00:00.2260129
35      00:00:00.2360135
36      00:00:00.2240128
37      00:00:00.2240128
38      00:00:00.2260129
39      00:00:00.2160124
40      00:00:00.2390137
41      00:00:00.2190125
42      00:00:00.2270130
43      00:00:00.2210126
44      00:00:00.2090120
45      00:00:00.2360135
46      00:00:00.2210126
47      00:00:00.2550146
48      00:00:00.2170124
49      00:00:00.2220127
50      00:00:00.2180124
51      00:00:00.2090120
52      00:00:00.2180125
53      00:00:00.2380136
54      00:00:00.2170124
55      00:00:00.2270130
56      00:00:00.2070118
57      00:00:00.2200126
58      00:00:00.2230128
59      00:00:00.2080119
60      00:00:00.2400137
61      00:00:00.2160123
62      00:00:00.2100120
63      00:00:00.2240128
64      00:00:00.2220127
65      00:00:00.2170124
66      00:00:00.2100120
67      00:00:00.2100121
68      00:00:00.2260129
69      00:00:00.2160123
70      00:00:00.2240128
71      00:00:00.2110121
72      00:00:00.2190125
73      00:00:00.2140123
74      00:00:00.2110121
75      00:00:00.2260129
76      00:00:00.2090119
77      00:00:00.2230128
78      00:00:00.2080119
79      00:00:00.2070118
80      00:00:00.2510144
81      00:00:00.2180125
82      00:00:00.2080119
83      00:00:00.2070118
84      00:00:00.2060118
85      00:00:00.2060118
86      00:00:00.2070118
87      00:00:00.2100120
88      00:00:00.2060118
89      00:00:00.2080119
90      00:00:00.2710155
91      00:00:00.2180125
92      00:00:00.2110120
93      00:00:00.2080119
94      00:00:00.2060118
95      00:00:00.2060118
96      00:00:00.2020116
97      00:00:00.2080119
98      00:00:00.2100120
99      00:00:00.2090119

Pode-se ver que a velocidade de processamento aumentou qualitativamente e é agora independente do período do extremo. É verdade que para o N pequeno, especialmente para o período 3, a velocidade é ainda mais lenta, mas à medida que o N aumenta, a velocidade aumenta rapidamente e é quase duas vezes mais rápida do que para o N pequeno:

Isto parece dever-se ao facto de os saltos de ruptura e as transições de indexação levarem algum tempo e serem eficazes em longas distâncias. No N pequeno, a força bruta de frente revela-se mais rápida.

P.S. Coloquei a execução de ambas as funções Up() e Down() em modo assíncrono de execução. Ou seja, podem ser executados em ambos os núcleos simultaneamente. Mas não aumentou o desempenho. Aparentemente, os passes em si não são intensivos em recursos e a maior parte do tempo é gasto na preparação e análise dos dados, e não nas iterações em si.

 
hrenfx:
No entanto, ainda não é a opção mais rápida. Mas isto é "blá blá" da minha parte, uma vez que não vou escrever um rápido.

Continua a ser relevante.

P.S.

C-4:

Pode-se ver que a velocidade de processamento aumentou qualitativamente e é agora independente do período extremo.

Depende, e não mal. No seu caso, apenas tem um tal código fonte (CVR) que apenas termina no mínimo em N. Em geral, o gráfico de dependência da velocidade de execução em relação ao período pode ser surpreendentemente diferente do seu.
 
hrenfx:

Continua a ser relevante.

P.S.

Depende, e não mal. No seu caso, é apenas uma fonte (TSS) que termina no mínimo em N. Em geral, caso o gráfico de dependência da velocidade de execução em relação ao período pode diferir drasticamente do seu.

Uma declaração controversa. O algoritmo é de passo único e o número de iterações, e portanto a velocidade, é quase independente do N. Contudo, existe uma peculiaridade do algoritmo devido à qual os extremos de preços da BP são iguais entre si, causando uma queda significativa do desempenho. Em todos os outros casos, tenho a certeza de que a dependência deve ser preservada. Neste caso, uma caminhada clássica normalmente distribuída ao acaso foi tomada como BP.
12345678910
Novo comentário