ForoSecciones

Optimización de algoritmos. - página 7

Nuevo comentario
komposter:

¿Cómo puedes estar tan seguro?

Mi comprobación muestra lo contrario:

El script mq4 está en el archivo adjunto.

Parece que la división del bucle funciona realmente más rápido. Pero no entiendo por qué, porque hace dos pases.
Sin embargo, sigue sin ser la opción más rápida. Pero esto es un "bla bla" por mi parte, ya que no voy a escribir uno rápido.
hrenfx:
Sin embargo, sigue sin ser la opción más rápida. Pero es un "bla bla" por mi parte, ya que no voy a escribir uno rápido.
Yo tampoco. Aunque estoy de acuerdo: puede ser más rápido.
hrenfx:
Sin embargo, sigue sin ser la opción más rápida. Pero es un "bla bla" por mi parte, ya que no voy a escribir uno rápido.
MetaDriver:
Yo tampoco lo haré. Sin embargo, estoy de acuerdo en que podría ser más rápido.

¡Pues no lo hagas! Naufragado:(

Escribiré este algoritmo yo mismo, ya sé cómo. Sólo que ahora estoy enfermo, tendré que posponerlo una semana.

TheXpert:
C.T.D. escribió exactamente eso en su primer post.
No estoy reclamando la primacía, sino que estoy de acuerdo con la sugerencia: "mejor dividir realmente en 2 ciclos" )
C-4:
La división del ciclo parece funcionar más rápido. Pero no entiendo por qué, ya que los pases se convierten en dos.
Porque cada pase tiene el doble de controles, y los propios pases suelen ser más cortos (se interrumpen prematuramente).
MetaDriver:
Y no lo haré. Aunque estoy de acuerdo: puede ser más rápido.

Yo tampoco, aunque más rápido es posible ;)

Acabo de darme cuenta de que falta un descanso, así que no puedo profundizar en él ahora.

Aquí está el código final. Se presenta una función de búsqueda máxima. La función para encontrar los mínimos es similar:

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

Aquí están las pruebas de rendimiento:

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

Se puede observar que la velocidad de procesamiento ha aumentado cualitativamente y ahora es independiente del periodo del extremo. Es cierto que para N pequeños, especialmente para el período 3, la velocidad es aún más lenta, pero a medida que N aumenta, la velocidad aumenta rápidamente y es casi el doble de rápida que para N pequeños:

Esto parece deberse al hecho de que los saltos de ruptura y las transiciones de indexación llevan cierto tiempo y son eficaces en distancias largas. En N pequeños, la fuerza bruta frontal resulta ser más rápida.

P.D. He puesto la ejecución de ambas funciones Up() y Down() en modo de ejecución asíncrono. Es decir, pueden ejecutarse en ambos núcleos simultáneamente. Pero no aumentó el rendimiento. Aparentemente, los pases en sí no consumen muchos recursos y la mayor parte del tiempo se dedica a la preparación y el análisis de los datos, no a las iteraciones en sí.

hrenfx:
Sin embargo, sigue sin ser la opción más rápida. Pero esto es un "bla bla" por mi parte ya que no voy a escribir una rápida.

Sigue siendo relevante.

P.D.

C-4:

Se puede observar que la velocidad de procesamiento ha aumentado cualitativamente y ahora es independiente del periodo extremo.

Depende, y no está mal. En tu caso sólo tienes un código fuente de este tipo (CVR) que sólo termina en el mínimo N. En el caso general, el gráfico de la dependencia de la velocidad de ejecución con respecto al periodo puede ser sorprendentemente diferente al suyo.
hrenfx:

Sigue siendo relevante.

P.D.

Depende, y no está mal. En su caso es sólo una fuente (TSS) que termina en el mínimo N. En el caso general, el gráfico de dependencia de la velocidad de ejecución con respecto al periodo puede diferir drásticamente del suyo.

Una declaración controvertida. El algoritmo es de paso único y el número de iteraciones, y por tanto la velocidad, es casi independiente de N. Sin embargo, hay una peculiaridad del algoritmo debido a la cual los extremos de los precios de BP son iguales entre sí, lo que causará una caída significativa del rendimiento. En todos los demás casos, estoy seguro de que la dependencia debería conservarse. En este caso se tomó como BP un paseo aleatorio clásico con distribución normal.
12345678910
Nuevo comentario