算法的优化。 - 页 7

新评论
 
komposter:

你怎么能如此肯定？

我的检查显示并非如此。

mq4脚本在附件中。

看来，循环拆分的效果确实比较好。但我不明白为什么，因为它有两个通道。
 
然而，这仍然不是最快的选择。但这是我的'胡说八道'，因为我不会写一个快速的。
 
hrenfx:
然而，这仍然不是最快的选择。但这是我的'胡说八道'，因为我不会写快报。
我也不会。虽然我同意--它可以更快。
 
hrenfx:
然而，这仍然不是最快的选择。但这是我的 "胡说八道"，因为我不会写一个快速的。
MetaDriver。
我也不会。不过我同意--它可以更快。

好了，不要了!失事了:(

我自己来写这个算法，我已经知道怎么做了。只是现在我生病了，我不得不推迟一周。

 
TheXpert:
C.T.D.在他的第一个帖子中正是这样写的。
我并不要求优先权，我有点同意这个建议。"最好真的 分成两个周期")
 
C-4:
循环分割似乎确实工作得更快。但我不明白为什么，因为通行证变成了两个。
因为每个通道的检查次数是原来的两倍，而且通道本身经常变短（过早中断）。
 
MetaDriver:
而我不会。虽然我同意--它可以更快。

我也不会，虽然更快是绝对可能的；)

我刚刚注意到，有一个断点没有了，所以我现在不能深入研究。

 

以下是最终的代码。提出了一个最大搜索函数。寻找最小值的功能是类似的。

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的两倍。

这似乎是由于断裂跳跃和分度转换需要一些时间，而且在长距离上是有效的。在小N上，迎面而来的暴力逼迫被证明是更快的。

P.S. 我已经把Up()和Down()这两个函数的执行放到了异步执行模式。也就是说，它们可以同时在两个核心上执行。但它并没有提高性能。显然，传递本身并不是资源密集型的，大部分时间 花在数据的准备和解析上，而不是花在迭代本身。

 
hrenfx:
然而，它仍然不是最快的选择。但这是我的 "胡说八道"，因为我不打算写一个快速。

仍有意义。

P.S.

C-4:

可以看出，处理速度有了质的提高，现在与极值期无关。

这取决于，而且不坏。在你的案例中，你只是有这样一个源代码（CVR），只是在最小的N处结束。在一般情况下，执行速度与周期的关系图可能与你的有明显的不同。
 
hrenfx:

仍有意义。

P.S.

这取决于，而且不坏。在 你的情况下，它只是一个来源（TSS），在最小N处结束。在一般情况下，执行速度与周期的关系图可能与你的有很大的不同。

一个有争议的声明。该算法是单通道的，迭代次数，以及因此而产生的速度，几乎与N无关。诚然，该算法有一个特殊性，由于BP价格极值彼此相等，将导致性能的显著下降。在所有其他情况下，我确信应该保留这种依赖性。在这种情况下，经典的正态分布随机行走被当作BP。
12345678910
新评论