Ottimizzazione degli algoritmi. - pagina 7

Nuovo commento
 
komposter:

Come può essere così sicuro?

Il mio controllo dimostra il contrario:

Lo script mq4 è nell'allegato.

Sembra che la divisione dei cicli funzioni davvero più velocemente. Ma non capisco perché, perché fa due passaggi.
 
Tuttavia, non è ancora l'opzione più veloce. Ma questo è un 'blah blah' da parte mia, perché non scriverò un veloce.
 
hrenfx:
Tuttavia, non è ancora l'opzione più veloce. Ma è un 'blah blah' da parte mia, dato che non scriverò un veloce.
Nemmeno io. Anche se sono d'accordo - può essere più veloce.
 
hrenfx:
Tuttavia, non è ancora l'opzione più veloce. Ma è un "blah blah" da parte mia, dato che non scriverò un veloce.
MetaDriver:
Non lo farò nemmeno io. Sono d'accordo però - potrebbe essere più veloce.

Beh, non farlo! Distrutto:(

Scriverò io stesso questo algoritmo, so già come fare. Solo che ora sono malato, dovrò rimandare di una settimana.

 
TheXpert:
C.T.D. ha scritto esattamente questo nel suo primo post.
Non sto rivendicando il primato, sono più o meno d'accordo con il suggerimento: "meglio dividere davvero in 2 cicli" )
 
C-4:
Il frazionamento del ciclo sembra funzionare più velocemente. Ma non capisco perché, visto che i passaggi diventano due.
Perché ogni passaggio ha il doppio dei controlli, e i passaggi stessi spesso si accorciano (interrotti prematuramente).
 
MetaDriver:
E non lo farò. Anche se sono d'accordo - può essere più veloce.

Nemmeno io, anche se più veloce è sicuramente possibile ;)

Ho appena notato che manca una pausa, quindi non posso approfondire ora.

 

Ecco il codice finale. Viene presentata una funzione di ricerca massima. La funzione per trovare i minimi è simile:

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

Ecco i test delle prestazioni:

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

Si può vedere che la velocità di elaborazione è qualitativamente aumentata ed è ora indipendente dal periodo dell'estremo. È vero che per piccoli N, specialmente per il periodo 3, la velocità è ancora più lenta, ma all'aumentare di N, la velocità aumenta rapidamente ed è quasi il doppio che per piccoli N:

Questo sembra essere dovuto al fatto che i salti di rottura e le transizioni di indicizzazione richiedono un certo tempo e sono efficaci sulle lunghe distanze. Su piccoli N, il brute-forcing frontale risulta essere più veloce.

P.S. Ho messo l'esecuzione di entrambe le funzioni Up() e Down() in modalità di esecuzione asincrona. Cioè, possono essere eseguiti su entrambi i core simultaneamente. Ma non ha aumentato le prestazioni. Apparentemente, i passaggi stessi non sono ad alta intensità di risorse e la maggior parte del tempo è speso nella preparazione e nell'analisi dei dati, non nelle iterazioni stesse.

 
hrenfx:
Tuttavia, non è ancora l'opzione più veloce. Ma questo è "blah blah" da parte mia, dato che non ho intenzione di scriverne uno veloce.

Ancora rilevante.

P.S.

C-4:

Si può vedere che la velocità di elaborazione è aumentata qualitativamente ed è ora indipendente dal periodo dell'estremo.

Dipende, e non male. Nel vostro caso avete solo un tale codice sorgente (CVR) che finisce al minimo N. In generale il grafico della dipendenza della velocità di esecuzione dal periodo può essere molto diverso dal vostro.
 
hrenfx:

Ancora rilevante.

P.S.

Dipende, e non male. Nel vostro caso è solo una fonte (TSS) che finisce al minimo N. In generale, il grafico della dipendenza della velocità di esecuzione dal periodo può differire drasticamente dal vostro.

Una dichiarazione controversa. L'algoritmo è single-pass e il numero di iterazioni, e quindi la velocità, è quasi indipendente da N. È vero che c'è una peculiarità dell'algoritmo a causa della quale gli estremi dei prezzi BP sono uguali tra loro, causeranno un calo significativo delle prestazioni. In tutti gli altri casi sono sicuro che la dipendenza dovrebbe essere conservata. In questo caso è stato preso come BP un classico cammino casuale normalmente distribuito.
12345678910
Nuovo commento
Motivazione: