第五部分、bar数据元素常用到的基本计算函数【逆序版，适合直接做逻辑判断用】

头文件声明变量：

1.         //第五部分 基本函数(开始)【常用函数】【返回逆序数组变量,适合直接做逻辑判断用】
   
2.         vector<double>Summation(vector<double> pc, int num); //数组前NUM项元素加总计算(返回数组前NUM项的和,返回的仍然是数组形式)
   
3.         vector<double>Average(vector<double> pc, int num); //average(pc[i],N)数组前NUM项元素加总计算(返回数组前NUM项的和,返回的仍然是数组形式)
   
4.         vector<double>Xaverage(vector<double> pc, int num); //Xaverage(ema)计算公式(返回数组)
   
5.         vector<double>Highest(vector<double> pc, int num); //high(pc[i],N)返回数组的num周期的最大值元素并存入新的数组(功能等同SeriesHigh)
   
6.         vector<double>Lowest(vector<double> pc, int num); //low(pc[i],N)返回数组的num周期的最小值元素并存入新的数组(功能等同SeriesLow)
   
7.         vector<double>AvgTruerange(int num); //数组型Truerange计算公式
   
8.         vector<double>Truerange(); //数组型Truerange计算公式
   
9.         //基本函数(结束)【常用函数】【返回逆序数组变量】

复制代码

公式模块增加：

1. //第五类函数(常用到的基本计算函数,逆序版，适合直接做逻辑判断用)
   
2. //数组前NUM项元素加总计算(返回逆序数组形式,最新序列号是[0])
   
3. vector<double> test::Summation(vector<double> pc, int num)
   
4. {
   
5.         reverse(pc.begin(), pc.end());//恢复计算变量为正序以方便下面的计算
   
6.         vector<double> sumvector;//声明一个存储和的容器变量
   
7.         double sum = 0;
   
8.         for (size_t i = 0; i < pc.size(); i++)
   
9.         {
   
10.                 if (i == 0)
    
11.                 {
    
12.                         sumvector.push_back(pc[i]);;
    
13.                 }
    
14.                 else if (i < num) //如果数据数目小于周期要求的最低bar数量
    
15.                 {
    
16.                         sum = 0;
    
17.                         for (size_t j = 0; j < i; j++)
    
18.                         {
    
19.                                 sum = sum + pc[i - j];//前num个数值相加
    
20.                         }
    
21.                         sumvector.push_back(sum); //用简单平均代替并存入容器中
    
22.                 }
    
23.                 else //pc数目大于num周期后正常计算方法
    
24.                 {
    
25.                         sum = 0;//重置加总变量
    
26.                         for (size_t j = 0; j < num; j++)
    
27.                         {
    
28.                                 sum = sum + pc[i - j];//加总从pc[i]往左数num个pc的数值
    
29.                         }
    
30.                         sumvector.push_back(sum);
    
31.                 }
    
32.         }
    
33.         reverse(sumvector.begin(), sumvector.end());//再次调转逆序与行业规范统一
    
34.         return sumvector;
    
35. }
    
36. //数组前NUM项元素简单加总计算(返回数组前NUM项的和,返回的仍然是数组形式)(返回逆序数组形式,最新序列号是[0])
    
37. vector<double> test::Average(vector<double> pc, int num)
    
38. {
    
39.         reverse(pc.begin(), pc.end());//恢复计算变量为正序以方便下面的计算
    
40.         vector<double> avgvector;//声明一个存储和的容器变量
    
41.         avgvector.clear();
    
42.         double sum = 0;
    
43.         for (size_t i = 0; i < pc.size(); i++)
    
44.         {
    
45.                 if (i == 0)
    
46.                 {
    
47.                         avgvector.push_back(pc[i]);;
    
48.                 }
    
49.                 else if (i < num) //如果数据数目小于周期要求的最低bar数量
    
50.                 {
    
51.                         sum = 0;
    
52.                         for (size_t j = 0; j < i; j++)
    
53.                         {
    
54.                                 sum = sum + pc[i - j];//前num个数值相加
    
55.                         }
    
56.                         avgvector.push_back(sum / (i + 1)); //用简单平均代替并存入容器中
    
57.                 }
    
58.                 else //pc数目大于num周期后正常计算方法
    
59.                 {
    
60.                         sum = 0;//重置加总变量
    
61.                         for (size_t j = 0; j < num; j++)
    
62.                         {
    
63.                                 sum = sum + pc[i - j];//加总从pc[i]往左数num个pc的数值
    
64.                         }
    
65.                         avgvector.push_back(sum / num);
    
66.                 }
    
67.         }
    
68.         reverse(avgvector.begin(), avgvector.end());//再次调转逆序与行业规范统一
    
69.         return avgvector;
    
70. }
    
71. //Xaverage(ema)计算公式(返回数组)(返回逆序数组形式,最新序列号是[0])
    
72. vector<double> test::Xaverage(vector<double> pc, int num)
    
73. {
    
74.         reverse(pc.begin(), pc.end());//恢复计算变量为正序以方便下面的计算
    
75.         vector<double> r;
    
76.         double d = 0;
    
77.         for (int i = 0; i < pc.size(); i++)
    
78.         {
    
79.                 if (i == 0)
    
80.                 {
    
81.                         d = pc[0];
    
82.                         r.push_back(d);
    
83.                 }
    
84.                 else
    
85.                 {
    
86.                         d = (2 * pc[i] + (num - 1) * d) / (num + 1);
    
87.                         r.push_back(d);
    
88.                 }
    
89.         }
    
90.         reverse(r.begin(), r.end());//再次调转逆序与行业规范统一
    
91.         return r;
    
92. }
    
93. //寻找数组中前N个数中的最大值,返回的仍然是数组形式(返回逆序数组形式,最新序列号是[0])
    
94. vector<double> test::Highest(vector<double> pc, int num)
    
95. {
    
96.         reverse(pc.begin(), pc.end());//恢复计算变量为正序以方便下面的计算
    
97.         vector<double> highvector;//声明一个临时存储最高价的变量容器
    
98.         for (size_t i = 0; i < pc.size(); i++)
    
99.         {
    
100.                 if (i == 0)//第一项
     
101.                 {
     
102.                         highvector.push_back(pc[i]);//pc容器第一个元素代替
     
103.                 }
     
104.                 else if (i < num)//不是第一个元素,但是数据数目不够num周期的
     
105.                 {
     
106.                         double r = 0; //声明一个存储最大值的临时变量
     
107.                         for (size_t j = 0; j < i; j++)
     
108.                         {
     
109.                                 r = max2(r, pc[i - j]);// 用上面声明的r变量与PC[i] 从i 到0 共 i+1个数据对比，将大值赋给r
     
110.                         }
     
111.                         highvector.push_back(r);//将上面循环中得到最大值代替
     
112.                 }
     
113.                 else//当i的数目大于或等于要求的num个时
     
114.                 {
     
115.                         double r = 0;//声明一个存储最大值的临时变量
     
116.                         for (size_t k = 0; k < num; k++)
     
117.                         {
     
118.                                 r = max2(r, pc[i - k]); //从pc[i]向左数num个元素分别与r比较,将最大的那个值赋给r
     
119.                         }
     
120.                         highvector.push_back(r);//将上面的r值增加到数组中。
     
121.                 }
     
122.         }
     
123.         reverse(highvector.begin(), highvector.end());//再次调转逆序与行业规范统一
     
124.         return highvector; //返回最高价数组
     
125. }
     
126. //寻找数组中前N个数中的最小值,返回的仍然是数组形式(返回逆序数组形式,最新序列号是[0])
     
127. vector<double> test::Lowest(vector<double> pc, int num)
     
128. {
     
129.         reverse(pc.begin(), pc.end());//恢复计算变量为正序以方便下面的计算
     
130.         vector<double> lowvector;//声明一个临时存储最低价的变量容器
     
131.         for (size_t i = 0; i < pc.size(); i++)
     
132.         {
     
133.                 if (i == 0)//第一项
     
134.                 {
     
135.                         lowvector.push_back(pc[i]);//pc容器第一个元素代替
     
136.                 }
     
137.                 else if (i < num)//不是第一个元素,但是数据数目不够num周期的
     
138.                 {
     
139.                         double r = pc[i]; //声明一个存储最大值的临时变量,初始值为pc最新元素值pc[i]
     
140.                         for (size_t j = 0; j < i; j++)
     
141.                         {
     
142.                                 r = min2(r, pc[i - j]);// 用上面声明的r变量与PC[i] 从i 到0 共 i+1个数据对比，将最小值赋给r
     
143.                         }
     
144.                         lowvector.push_back(r);//将上面循环中得到最小值代替
     
145.                 }
     
146.                 else//当i的数目大于或等于要求的num个时
     
147.                 {
     
148.                         double r = pc[i]; //声明一个存储最大值的临时变量,初始值为pc最新元素值pc[i]
     
149.                         for (size_t k = 0; k < num; k++)
     
150.                         {
     
151.                                 r = min2(r, pc[i - k]); //从pc[i]向左数num个元素分别与r比较,将最小的那个值赋给r
     
152.                         }
     
153.                         lowvector.push_back(r);//将上面的r值增加到数组中。
     
154.                 }
     
155.         }
     
156.         reverse(lowvector.begin(), lowvector.end());//再次调转逆序与行业规范统一
     
157.         return lowvector; //返回最高价数组
     
158. }
     
159. //数组型Truerange的N周期平均计算公式(返回逆序数组形式,最新序列号是[0])
     
160. vector<double> test::AvgTruerange(int num)
     
161. {
     
162.         double dPreClose = 0;
     
163.         vector<double>vAtr, avgatr;
     
164.         RsqBar(sPeriod, sInst);
     
165.         map<string, TKVALUE >::iterator it;
     
166.         for (it = mapK[sPeriod][sInst].begin(); it != mapK[sPeriod][sInst].end(); ++it)
     
167.         {
     
168.                 if (dPreClose != 0) //后续bar的计算
     
169.                 {
     
170.                         double d = it->second.dHigh - it->second.dLow;
     
171.                         double dHC = abs(it->second.dHigh - dPreClose);
     
172.                         double dLC = abs(it->second.dLow - dPreClose);
     
173.                         if (d < dHC)d = dHC;
     
174.                         if (d < dLC)d = dLC;
     
175.                         vAtr.push_back(d);
     
176.                 }
     
177.                 dPreClose = it->second.dClose; //第一次运行先将收盘价赋值给dpreclose,方便后同的计算
     
178.         }
     
179. 
     
180.         for (size_t i = 0; i < vAtr.size(); i++)
     
181.         {
     
182.                 if (i < num) //数量小于周期时用0代替
     
183.                 {
     
184.                         avgatr.push_back((int)0);
     
185.                 }
     
186.                 else
     
187.                 {
     
188.                         double sumatr = 0;
     
189.                         for (size_t j = 0; j < num; j++)
     
190.                         {
     
191.                                 sumatr += vAtr[i - j];
     
192.                         }
     
193.                         avgatr.push_back(sumatr / num);
     
194.                 }
     
195.         }
     
196.         reverse(avgatr.begin(), avgatr.end());//调转数组顺序以与行业规范统一
     
197.         return avgatr;
     
198. }
     
199. //数组型Truerange计算公式(返回逆序数组形式,最新序列号是[0])
     
200. vector<double> test::Truerange()
     
201. {
     
202.         double dPreClose = 0;
     
203.         double sumatr = 0;
     
204.         vector<double>vAtr;
     
205.         RsqBar(sPeriod, sInst);
     
206.         map<string, TKVALUE >::iterator it;
     
207.         for (it = mapK[sPeriod][sInst].begin(); it != mapK[sPeriod][sInst].end(); ++it)
     
208.         {
     
209.                 if (dPreClose != 0) //后续bar的计算
     
210.                 {
     
211.                         double d = it->second.dHigh - it->second.dLow;
     
212.                         double dHC = abs(it->second.dHigh - dPreClose);
     
213.                         double dLC = abs(it->second.dLow - dPreClose);
     
214.                         if (d < dHC)d = dHC;
     
215.                         if (d < dLC)d = dLC;
     
216.                         vAtr.push_back(d);
     
217.                 }
     
218.                 dPreClose = it->second.dClose; //第一次运行先将收盘价赋值给dpreclose,方便后同的计算
     
219.         }
     
220.         reverse(vAtr.begin(), vAtr.end());//调转数组顺序以与行业规范统一
     
221.         return vAtr;
     
222. }
     
223. //第五类函数(常用到的基本计算函数,逆序版，适合直接做逻辑判断用)

复制代码

这里有一个说明特例，即在在当函数中数据也是用逆序的价格数据即可。