Optimisation des algorithmes. - page 7

Nouveau commentaire
 
komposter:

Comment pouvez-vous en être si sûr ?

Mon contrôle montre le contraire :

Le script mq4 est dans la pièce jointe.

Il semble que le fractionnement des boucles soit vraiment plus rapide. Mais je ne comprends pas pourquoi, car il fait deux passages.
 
Cependant, ce n'est toujours pas l'option la plus rapide. Mais il s'agit d'un "bla bla" de ma part, car je n'écrirai pas un rapide.
 
hrenfx:
Cependant, ce n'est toujours pas l'option la plus rapide. Mais c'est un "bla bla" de ma part, car je n'écrirai pas un rapide.
Moi non plus. Bien que je sois d'accord - cela peut être plus rapide.
 
hrenfx:
Cependant, ce n'est toujours pas l'option la plus rapide. Mais c'est un "bla bla" de ma part, car je n'en écrirai pas un rapide.
MetaDriver:
Je ne le ferai pas non plus. Mais je suis d'accord, il pourrait être plus rapide.

Eh bien, ne le faites pas ! Naufragés :(

Je vais écrire cet algorithme moi-même, je sais déjà comment faire. Seulement maintenant que je suis malade, je vais devoir le reporter d'une semaine.

 
TheXpert:
C.T.D. a écrit exactement ça dans son premier message.
Je ne revendique pas la primauté, je suis plutôt d'accord avec la suggestion : "mieux vaut vraiment diviser en 2 cycles" )
 
C-4:
La division du cycle semble fonctionner plus rapidement. Mais je ne comprends pas pourquoi, car les passes deviennent deux.
Parce que chaque passe comporte deux fois moins de contrôles, et que les passes elles-mêmes sont souvent plus courtes (interrompues prématurément).
 
MetaDriver:
Et je ne le ferai pas. Bien que je sois d'accord - cela peut être plus rapide.

Je ne le ferai pas non plus, bien qu'il soit tout à fait possible d'aller plus vite ;)

Je viens de remarquer qu'il manque une pause, je ne peux donc pas l'approfondir maintenant.

 

Voici le code final. Une fonction de recherche maximale est présentée. La fonction de recherche des minima est similaire :

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

Voici les tests de performance :

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

On constate que la vitesse de traitement a qualitativement augmenté et qu'elle est maintenant indépendante de la période de l'extremum. Il est vrai que pour les petits N, notamment pour la période 3, la vitesse est encore plus lente, mais lorsque N augmente, la vitesse augmente rapidement et est presque deux fois plus rapide que pour les petits N :

Cela semble être dû au fait que les sauts de rupture et les transitions d'indexation prennent un certain temps et sont efficaces sur de longues distances. Sur les petits N, le forçage brutal s'avère plus rapide.

P.S. J'ai mis l'exécution des deux fonctions Up() et Down() en mode d'exécution asynchrone. C'est-à-dire qu'ils peuvent être exécutés sur les deux cœurs simultanément. Mais cela n'a pas augmenté les performances. Apparemment, les passages eux-mêmes ne sont pas gourmands en ressources et la plupart du temps est consacré à la préparation et à l'analyse des données, et non aux itérations elles-mêmes.

 
hrenfx:
Cependant, ce n'est toujours pas l'option la plus rapide. Mais c'est du "bla-bla" de ma part puisque je ne vais pas en écrire un rapide.

Toujours d'actualité.

P.S.

C-4:

On peut constater que la vitesse de traitement a augmenté qualitativement et qu'elle est maintenant indépendante de la période extrême.

Cela dépend, et pas mal. Dans votre cas, vous avez juste un tel code source (CVR) qui se termine juste à N minimum. En général, le graphique de la dépendance de la vitesse d'exécution par rapport à la période peut être très différent du vôtre.
 
hrenfx:

Toujours d'actualité.

P.S.

Cela dépend, et pas mal. Dans votre cas, il s'agit juste d'une source (TSS) qui se termine au minimum N. En général, le graphique de la dépendance de la vitesse d'exécution en fonction de la période peut être radicalement différent du vôtre.

Une déclaration controversée. L'algorithme est à passage unique et le nombre d'itérations, et donc la vitesse, est presque indépendant de N. Il est vrai qu'il existe une particularité de l'algorithme en raison de laquelle les extrémités de prix de BP sont égales les unes aux autres, ce qui entraîne une baisse significative des performances. Dans tous les autres cas, je suis sûr que la dépendance doit être préservée. Dans ce cas, une marche aléatoire classique normalement distribuée a été prise comme BP.
12345678910
Nouveau commentaire