Оптимизация алгоритмов. - страница 7

Новый комментарий
 
komposter:

Откуда такая уверенность?

Моя проверка показывает обратное:

 Скрипт mq4 в аттаче.

Похоже разделение на циклы действительно работает быстрее. Но не понимаю почему, ведь прохода становиться два.
 
Однако, это все равно не самый быстрый вариант. Но с моей стороны это "ля-ля", т.к. писать быстрый не буду.
 
hrenfx:
Однако, это все равно не самый быстрый вариант. Но с моей стороны это "ля-ля", т.к. писать быстрый не буду.
И я не буду. Хотя и согласен - можно быстрее.
 
hrenfx:
Однако, это все равно не самый быстрый вариант. Но с моей стороны это "ля-ля", т.к. писать быстрый не буду.
MetaDriver:
И я не буду. Хотя и согласен - можно быстрее.

Ну и не надо! Вредены:(

Я напишу этот алгоритм сам, уже знаю как. Только сейчас болею, придется отложить на недельку. 

 
TheXpert:
Ч.Т.Д. именно это и писал в первом же посте.
На первенство не претендую, я как-бы согласился с предложением: "лучше действительно разделить на 2 цикла" )
 
C-4:
Похоже разделение на циклы действительно работает быстрее. Но не понимаю почему, ведь прохода становиться два.
Потому что в каждом проходе в 2 раза меньше проверок, а сами проходы часто становятся короче (досрочно прерываются).
 
MetaDriver:
И я не буду. Хотя и согласен - можно быстрее.

Я тоже не буду, хотя быстрее можно - однозначно ;)

Просто заметил, что одного break-а не хватает, не углубляться же теперь в эту задачу с головой. 

 

Вот окончательный код. Представлена функция поиска максимумов. Функция поиска минимумов аналогичная:

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

Вот тесты производительности:

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

Видно, что скорость обработки качественно возрасла и теперь не зависит от периода экстремума. Правда на малых N, особенно для периода 3,  скорость  стала даже ниже, но с увеличением N, скорость быстро  увеличивается и чуть ли не вдвое выше скорости на малых N:

 

По всей видимости это связано с тем, что прыжки  break и переходы индексации занимают некоторое время и эффективны на больших расстояниях. На малых N лобовой перебор оказывается быстрее.

P.S. Выполнение обоих функций Up() и Down() я засунул в асинхронный режим выполнения. Т.е. они могут выполнятся на обоих ядрах одновременно. Производительности однако это не увеличило. Видимо, сами по себе проходы не ресурсоемки, и основное время уходит на подготовку и равертывание данных, а не на сами итерации.

 
hrenfx:
Однако, это все равно не самый быстрый вариант. Но с моей стороны это "ля-ля", т.к. писать быстрый не буду.

Актуально еще.

P.S.

C-4:

Видно, что скорость обработки качественно возрасла и теперь не зависит от периода экстремума.

Зависит и не хило. В вашем случае просто такой исходник (цВР) попался, у которого на минимальных N все и кончается. В общем случае график зависимости скорости выполнения от периода может разительно отличаться от вашего.
 
hrenfx:

Актуально еще.

P.S.

Зависит и не хило. В вашем случае просто такой исходник (цВР) попался, у которого на минимальных N все и кончается. В общем случае график зависимости скорости выполнения от периода может разительно отличаться от вашего.

 

Спорное утверждение. Алгоритм однопроходный и количество итераций, а значит и скорость, практически не зависит от N. Правда есть одна особенность алгоритма, из-за которой на BP ценовые экстремумы которого равны между собой будет существенный спад производительности. Во всех остальных случаях, уверен, зависимость должна сохраняться. В данном случае в качестве BP бралось классическое нормально распределенное случайное блуждание.
12345678910
Новый комментарий
Причина обращения: