鼎元C++量化程式码技术指标源码C++版模板【C++期货技术指标模板，建议在test.h和test.cpp中同步至最新，方便统一调用和使用，一次编辑多次使用！】

第一部分：使用、调用办法

1. RsqBar(sPeriod, sInst);//申请bar数据
   
2. atr = avgtruerange(sPeriod, sInst, length);//指标调用

复制代码

第二部分：使用程式码模块

1、开始、结束模块；
2、tick模块、bar模块；
.
第三部分：疑问咨询解决办法

1、疑问、咨询、报错解决专用版：http://www.qhlt.cn/forum-244-1.html；

2、管理员微信、QQ、群

C++微信群： ； QQ群： ；管理员微信：；管理员QQ：

现有的C++技术指标公式、使用方式及源码汇总集锦：

1、简单移动均线：http://www.qhlt.cn/thread-159054-1-1.html；

2、最高highest,最低lowest：http://www.qhlt.cn/thread-160007-1-1.html；

3、平均真实波动幅度（averagetruerange，atr）指标公式：http://www.qhlt.cn/thread-160002-1-1.html；

4、加权移动均线ema调用：http://www.qhlt.cn/thread-160008-1-1.html；

5、布林带(bollingerbands,BOLL)计算方法及调用方法：http://www.qhlt.cn/thread-160288-1-1.html；

6、平滑异同移动平均线(Moving Average Convergence Divergence,MACD)，并形成模块化，可以在指标和策略中方便调用：http://www.qhlt.cn/thread-160291-1-1.html；

7、方差(variance)、标准差(standard deviation,sdev)计算方法及调用方法：http://www.qhlt.cn/thread-160300-1-1.html；

为了更新方方便，在下楼分别更新C++头文件和C++源文件技术指标程式码模块。可以不时更新一下，这样可以得到最新的技术指标模块。

1. //指标公式变量声明******************************************************************test头文件指标公式变量名称模块开始（修改与编辑指标参数变量）
   
2.         double iff(bool cond1, int num, int ref);//iff函数
   
3.         double max2(double a, double b);//返回a,b中较大值
   
4.         double max3(double a, double b, double c);//返回a,b,c中最大值
   
5.         double min2(double a, double b); //返回a,b中较小值
   
6.         double min3(double a, double b, double c);//返回a,b,c中最小值
   
7.         double waverage(string period, string inst, int num);//计算Weighted Moving Average，加权移动平均线
   
8.         double average(string period, string inst, int num); //average,ma函数变量,atr计算功能
   
9.         double highest(string period, string inst, int num);//计算NUM周期最高价格
   
10.         double highestN(string period, string inst, int num, int ref);//计算REF前个bar的num周期最高价格
    
11.     double lowest(string period, string inst, int num); //计算NUM周期最低价格
    
12.         double lowestN(string period, string inst, int num, int ref);//计算ref前个bar的num周期的最低价格
    
13.         double closeN(string period, string inst, int ref);//计算ref前个bar的收盘价格
    
14.         double avgtruerange(string period, string inst, int num); //计算真实波动幅度平均值(average true range)
    
15.         double Variance(string period, string inst, int num);//计算方差公式变量
    
16.         double StandardDev(string period, string inst, int num);//计算标准差公式变量
    
17.         double Volatility(string period, string inst, int num);//计算历史波动率（CALCULATING HISTORICAL VOLATILITY）
    
18.         double bollingerbands(string period, string inst, int num, int ref); //计算boll布林带变量
    
19.         //指数移动平均返回具体数据时调用xaverage,返回数组时则用ema调用。数组形式多用于指标计算中间变量
    
20.         double xaverage(string period, string inst, int num);//计算num周期指数移动平均(Exponential Moving Average)值
    
21.         vector<double>ema(vector<double>pc, int num);//ema计算返回数组vector形式指数移动平均
    
22.         //指数移动平均返回具体数据时调用xaverage,返回数组时则用ema调用。数组形式多用于指标计算中间变量
    
23.         vector<double>EMAvectorCaL(vector<double>pc, int num);//EMA容器计算形式
    
24.         vector<double>MACDcalculate(vector<double>pc, int shortPeriod, int longPeriod);//计算MACD
    
25.         double mav(vector<double>pc, int num);//计算简单MA数组形式
    
26.         double hhv(vector<double> pc, int num);
    
27.         double llv(vector<double> pc, int num);
    
28.         double AEMA(string period, string inst, int num, int pds);//自适应移动平均线（Adaptive Exponential Moving Average, AEMA）
    
29.         vector<double>aema, highs, lows; //vector变量容器
    
30.         double a0, a1, a2, a3, a4, value2, value3, mltp1, mltp2, rate, aema1, aema2;//必要变量,自适应移动平均线
    
31. 
    
32. //指标公式变量声明******************************************************************test头文件指标公式变量名称模块结束（修改与编辑指标参数变量）

复制代码

1. //****************************************************************外部引用文件开始（谨慎修改）
   
2. #include "pch.h"
   
3. #include "test.h"
   
4. #include <vector>
   
5. #include <windows.h>
   
6. #include <fstream>
   
7. #include <stdio.h>
   
8. #include <mmsystem.h>
   
9. #include <thread>
   
10. #pragma comment(lib,"winmm.lib")
    
11. #include <algorithm> // For std::min_element and std::max_element
    
12. #include <deque>
    
13. using namespace std;
    
14. //****************************************************************主程序指标公式function计算模块（公式编辑与设计区）
    
15. // iff功能函数开始
    
16. double test::iff(bool cond1, int num, int ref)
    
17. {
    
18.         int d = 0;
    
19.         if (cond1)
    
20.         {
    
21.                 d = num;
    
22.         }
    
23.         else
    
24.         {
    
25.                 d = ref;
    
26.         }
    
27. 
    
28.         return d;
    
29. }
    
30. 
    
31. //max2(a,b)比较a,b两个数字
    
32. double test::max2(double a, double b)
    
33. {
    
34.         double c = 0;
    
35.         if (a >= b)
    
36.         {
    
37.                 c = a;
    
38.         }
    
39.         else
    
40.         {
    
41.                 c = b;
    
42.         }
    
43.         return c;
    
44. }
    
45. 
    
46. //max3(a,b)比较a,b,c三个数字
    
47. double test::max3(double a, double b, double c)
    
48. {
    
49.         double d = 0;
    
50. 
    
51.         if (a >= b)
    
52.         {
    
53.                 d = a;
    
54.         }
    
55.         else if (a < b)
    
56.         {
    
57.                 d = b;
    
58.         }
    
59.         if (d < c)
    
60.         {
    
61.                 d = c;
    
62.         }
    
63.         return d;
    
64. }
    
65. 
    
66. //min2(a,b)比较两个数字大小
    
67. double test::min2(double a, double b)
    
68. {
    
69.         double c = 0;
    
70.         if (a >= b)
    
71.         {
    
72.                 c = b;
    
73.         }
    
74.         else
    
75.         {
    
76.                 c = a;
    
77.         }
    
78.         return c;
    
79. }
    
80. 
    
81. //min3(a,b,c)比较三个数字大小
    
82. double test::min3(double a, double b, double c)
    
83. {
    
84.         double d = 0;
    
85. 
    
86.         if (a >= b)
    
87.         {
    
88.                 d = b;
    
89.         }
    
90.         else if (a < b)
    
91.         {
    
92.                 d = a;
    
93.         }
    
94.         if (d > c)
    
95.         {
    
96.                 d = c;
    
97.         }
    
98.         return d;
    
99. }
    
100. 
     
101. //均线average计算公式开始
     
102. double test::average(string period, string inst, int num)
     
103. {
     
104.         int key = 0;
     
105.         double sump = 0;
     
106.         if (mapK[period][inst].size() < num) return 0;
     
107.         map<string, TKVALUE>::reverse_iterator it;
     
108.         for (it = mapK[sPeriod][sInst].rbegin(); it != mapK[sPeriod][sInst].rend(); it++)
     
109.         {
     
110.                 sump = sump + it->second.dClose;
     
111.                 key++;
     
112.                 if (key >= num)break;
     
113.         }
     
114.         return sump / num;
     
115. }
     
116. //计算num周期内bar最高价格
     
117. double test::highest(string period, string inst, int num)
     
118. {
     
119.         double hiprice = 0;
     
120.         int key = 0;
     
121.         map<string, TKVALUE>::reverse_iterator it; //建立逆向迭代器从右往左
     
122.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++) //FOR循环遍历
     
123.         {
     
124.                 if (hiprice < it->second.dHigh) hiprice = it->second.dHigh; //如果hiprice值小于遍历的bar的最高价，则将最高价赋值给hiprice
     
125.                 key++;//计算循环次数
     
126.                 if (key >= num)break; //达到num个bar后跳出循环
     
127.         }
     
128.         return hiprice;//将获取的最高价格值返回
     
129. }
     
130. //计算num周期内bar的最低价格
     
131. double test::lowest(string period, string inst, int num)
     
132. {
     
133.         double lowprice = 0;
     
134.         int key = 0;
     
135.         map<string, TKVALUE>::reverse_iterator it;
     
136.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
137.         {
     
138.                 if (lowprice == 0)lowprice = it->second.dLow;
     
139.                 if (lowprice > it->second.dLow)lowprice = it->second.dLow;
     
140.                 key++;
     
141.                 if (key >= num)break;
     
142.         }
     
143.         return lowprice;
     
144. }
     
145. 
     
146. //计算历史波动率（calculating historical volatility）
     
147. double test::Volatility(string period, string inst, int num)
     
148. {
     
149.         double PreClose = 0;//获取每个bar前一个bar的收盘价
     
150.         double tr = 0; //tr的值计算
     
151.         int key = 0; //计数器
     
152.         vector<double>vtr; //建立一个数组,用来存放每个bar对应的truerange值，它们的下标号与bar的是一致的
     
153.         if (mapK[period][inst].size() < num) return 0; //如果数据数量不够返回0；
     
154.         map<string, TKVALUE >::iterator it; //建立正迭代器，标号从0开始，从左向右开始
     
155.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); ++it) //从第一开始的bar数据开始遍历
     
156.         {
     
157.                 if (PreClose != 0) //如果值不为0说明是在中间的bar,开始在bar数据要素中采集需要的变量数值
     
158.                 {
     
159.                         double dHL = it->second.dHigh - it->second.dLow; //当根bar的最高减最低
     
160.                         double dHC = abs(it->second.dHigh - PreClose); //当根bar最高减昨日收盘
     
161.                         double dLC = abs(it->second.dLow - PreClose); //当根bar最低减昨日收盘
     
162.                         double e = max3(dHL, dHC, dLC); //获得每一个bar对应的truerange值(上面三者之最大者)
     
163.                         vtr.push_back(e); //将上面e的值放到tr的vector(数组)里面供下面使用
     
164.                 }
     
165.                 PreClose = it->second.dClose; //将当前bar的收盘价数值赋给此变量供下一个bar使用
     
166.         }
     
167.         //计算tr的num周期指数移动平均值
     
168.         if (key <= num)
     
169.         {
     
170.                 tr = 0;
     
171.                 key++;
     
172.         }
     
173.         else
     
174.         {
     
175.                 tr = (vtr[vtr.size() - 1]) * 2 / (num + 1) + tr * (num - 1) / (num + 1); // 2/(num + 1)指数移动平均线的平滑因子
     
176.                 //tr = (2 * vtr[vtr.size()-1] + (num - 1) * tr)/(num + 1); //第二种计算vtr指数移动平均方式，平滑因子不变
     
177.         }
     
178.         return tr;
     
179. }
     
180. 
     
181. //计算真实波动幅度平均值(average true range)
     
182. double test::avgtruerange(string period, string inst, int num)
     
183. {
     
184.         double preclose = 0; //设计一个局部变量存储上一日收盘价
     
185.         double sumatr = 0;  // 设计一个加总变量, 存储atr的值
     
186.         vector<double>vatr;//设计一个vector变量，存储tr值
     
187.         if (mapK[period][inst].size() < num) return 0; //如果数据不够用返回0
     
188.         map<string, TKVALUE>::iterator it;//建立一个正向迭代器
     
189.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); it++) //建立 for 循环采集需要的要素数据
     
190.         {
     
191.                 if (preclose != 0) //这次不是第一次循环
     
192.                 {
     
193.                         double dHL = it->second.dHigh - it->second.dLow; //当天最高价减当天最低价
     
194.                         double dHC = abs(it->second.dHigh - preclose);  //当天最高价减昨天收盘价
     
195.                         double dLC = abs(it->second.dLow - preclose);   //当天最低价减昨天收盘价
     
196.                         vatr.push_back(max3(dHL, dHC, dLC)); //将上面三个值中最大值加入到vector里面
     
197.                 }
     
198.                 preclose = it->second.dClose; //每次遍历后将当天的收盘价赋值给preclose供下次遍历使用
     
199.         }
     
200.         for (int i = 1; i <= length; i++)
     
201.         {
     
202.                 sumatr = sumatr + vatr[vatr.size() - i];//将vatr中的数据从右至左依顺序加总num个
     
203.         }
     
204.         return sumatr / num;
     
205. }
     
206. //方差计算公式
     
207. double test::Variance(string period, string inst, int num)
     
208. {
     
209.         double ma = average(sPeriod, sInst, num);//中间均线
     
210.         int key = 0;
     
211.         double sumdev = 0;
     
212.         double madev = 0;
     
213.         if (mapK[period][inst].size() < num) return 0;
     
214.         map<string, TKVALUE>::reverse_iterator it;
     
215.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
216.         {
     
217.                 sumdev += pow(it->second.dClose - ma, 2); //计算偏离平方和
     
218.                 key++;
     
219.                 if (key >= num)break; //num次循环后跳出
     
220.         }
     
221.         return sumdev / num;
     
222. }
     
223. 
     
224. //标准差计算公式
     
225. double test::StandardDev(string period, string inst, int num)
     
226. {
     
227.         double value1 = 0;
     
228.         if (mapK[period][inst].size() < num) return 0;
     
229.         value1 = Variance(sPeriod, sInst, num);
     
230. 
     
231.         return sqrt(value1);
     
232. }
     
233. //boll布林带计算公式
     
234. double test::bollingerbands(string period, string inst, int num, int ref)
     
235. {
     
236.         double ma = average(sPeriod, sInst, num); //获取num周期平均线ma
     
237.         int key = 0;
     
238.         double sumdev = 0;
     
239.         double madev = 0;
     
240.         if (mapK[period][inst].size() < num) return 0;
     
241.         map<string, TKVALUE>::reverse_iterator it;
     
242.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
243.         {
     
244.                 sumdev += pow(it->second.dClose - ma, 2);
     
245.                 key++;
     
246.                 if (key >= num)break;
     
247.         }
     
248.         madev = sqrt(sumdev / num); //获得标准差
     
249. 
     
250.         return ma + ref * madev;
     
251. }
     
252. 
     
253. //计算num周期指数移动平均(Exponential Moving Average)值
     
254. double test::xaverage(string period, string inst, int num)
     
255. {
     
256.         double n = 0;
     
257.         double ema = 0;
     
258.         if (mapK[period][inst].size() < num) return 0;
     
259.         map<string, TKVALUE>::iterator it;
     
260.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); it++)
     
261.         {
     
262.                 if (n < num)
     
263.                 {
     
264.                         ema = (ema + it->second.dClose) / (n + 1);
     
265.                         n++;
     
266.                 }
     
267.                 else
     
268.                 {
     
269.                         ema = (2 * it->second.dClose + (n - 1) * ema) / (n + 1); //指数移动平均计算核心公式,ema = a*close + (1-a)*ema[1],a为加权因子,通常=2/(N+1)
     
270.                 }
     
271.         }
     
272.         return ema;
     
273. }
     
274. 
     
275. //计算Weighted Moving Average,加权移动平均
     
276. double test::waverage(string period, string inst, int num)
     
277. {
     
278.         double sumwma = 0;
     
279.         int i = 0;
     
280.         if (mapK[period][inst].size() < num) return 0; //bar数量小于num个时返回0
     
281.         map<string, TKVALUE>::reverse_iterator it;
     
282.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
283.         {
     
284.                 sumwma += (num-i) * it->second.dClose; //计算num*close + (num-1)*close[1] +...+ 1*close[num-1]的总和
     
285.                 i++;
     
286.                 if(i >= num) break;
     
287.          }
     
288.         double d = (num+1)*num * 0.5; //计算num从1到num的总和
     
289.         return sumwma / d;
     
290. }
     
291. //ema计算返回数组vector形式指数移动平均
     
292. vector<double>test::ema(vector<double>pc, int num)
     
293. {
     
294.         vector<double>emav;
     
295.         double emavector = 0;
     
296.         int i = 0;
     
297. 
     
298.         for (int it = 0; it < pc.size(); it++)
     
299.         {
     
300.                 if (i < num)
     
301.                 {
     
302.                         emavector = (emavector + pc[it])/(i+1);
     
303.                         i++;
     
304.                         emav.push_back(emavector);
     
305.                 }
     
306.                 else
     
307.                 {
     
308. //                        emavector = (2*pc[it]+(num-1)*emavector)/(num+1);//ema均线计算公式
     
309.                         emavector = emavector + 2 * (pc[it] - emavector) / (num + 1);
     
310.                         emav.push_back(emavector);
     
311.                 }
     
312.         }
     
313.         return emav;
     
314. }
     
315. //计算REF前个bar的num周期最高价格
     
316. double test::highestN(string period, string inst, int num, int ref)
     
317. {
     
318.         double d = 0;
     
319.         int n = 0;
     
320.         int r = 0;
     
321.         map<string, TKVALUE>::reverse_iterator it;
     
322.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
323.         {
     
324.                 r++;
     
325.                 if (r <= ref)continue; //需要跳过的bar数
     
326.                 if (d < it->second.dHigh)d = it->second.dHigh; //将最大值赋值给d
     
327.                 n++;
     
328.                 if (n >= num) break; //num 次循环后跳出（从0开始，所以从num-1个后就退出）
     
329.         }
     
330.         return d; //返回d
     
331. }
     
332. //计算ref前个bar的num周期的最低价格
     
333. double test::lowestN(string period, string inst, int num, int ref)
     
334. {
     
335.         double d = 0;
     
336.         int n = 0;
     
337.         int r = 0;
     
338.         map<string, TKVALUE>::reverse_iterator it;
     
339.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
340.         {
     
341.         r++;
     
342.         if (r <= ref) continue; //需要跳过的bar数
     
343.         if (d == 0)d = it->second.dLow; //判断是否是第一次循环
     
344.         if (d > it->second.dLow)d = it->second.dLow; //将低最值赋给d
     
345.         n++;
     
346.         if (n >= num)break; //num个循环后退出
     
347.         }
     
348.         return d; //返回d值
     
349. }
     
350. //返回ref个bar前的收盘价
     
351. double test::closeN(string period, string inst, int ref)
     
352. {
     
353.         double d = 0;
     
354.         int r = 0;
     
355.         int n = 0;
     
356.         map<string, TKVALUE>::reverse_iterator it;
     
357.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
358.         {
     
359.                 r++;
     
360.                 if (r <= ref)continue; //跳过ref个bar
     
361.                 d = it->second.dClose; //将ref个bar前一个bar的收盘价赋值给d ;
     
362.                 break;
     
363.         }
     
364.         return d;
     
365. }
     
366. ////////////////////////////////////////////////////////////////////////////////////////////////////////////MACD公式计算
     
367. vector<double>test::EMAvectorCaL(vector<double>pc, int num)//EMA容器计算形式
     
368. {
     
369.         vector<double> ema(pc.size());
     
370.         double multiplier = 2.0 / (num + 1);
     
371.         ema[0] = pc[0]; // 初始化第一值为价格的第一个值
     
372.         for (int i = 1; i < pc.size(); i++) {
     
373.                 ema[i] = (pc[i] - ema[i - 1]) * multiplier + ema[i - 1];
     
374.         }
     
375.         return ema;
     
376. }
     
377. vector<double>test::MACDcalculate(vector<double>pc, int shortPeriod, int longPeriod)
     
378. {
     
379.         // 计算快线和慢线的 EMA
     
380.         vector<double> shortEMA = EMAvectorCaL(pc, shortPeriod);
     
381.         vector<double> longEMA = EMAvectorCaL(pc, longPeriod);
     
382. 
     
383.         // 计算 DIFF
     
384.         vector<double> diff(pc.size());
     
385.         for (int i = 0; i < pc.size(); i++)
     
386.         {
     
387.                 diff[i] = shortEMA[i] - longEMA[i];
     
388.         }
     
389.         return diff;
     
390. }
     
391. ////////////////////////////////////////////////////////////////////////////////////////////////////////////MACD公式计算
     
392. 
     
393. ////////////////////////////////////////////////////////////////////////////////////////////////////////////KDJ公式计算
     
394. double test::hhv(vector<double> pc, int num)
     
395. {
     
396.         double d = 0;
     
397.         for (size_t i = pc.size() - 1; i >= pc.size() - num; i--)
     
398.         {
     
399.                 d = max2(d, pc[i]);
     
400.         }
     
401.         return d;
     
402. }
     
403. 
     
404. double test::llv(vector<double> pc, int num)
     
405. {
     
406.         double d = 999999;
     
407.         for (size_t i = pc.size() - 1; i >= pc.size() - num; i--)
     
408.         {
     
409.                 d = min2(d, pc[i]);
     
410.         }
     
411.         return d;
     
412. }
     
413. ////////////////////////////////////////////////////////////////////////////////////////////////////////////KDJ公式计算
     
414. 
     
415. double test::mav(vector<double>pc, int num)//计算简单MA数组形式
     
416. {
     
417.         if (pc.size() <2) return 0;
     
418.         double d = 0;
     
419.         for (size_t i = pc.size() - 1; i >= pc.size() - num; i--)
     
420.         {
     
421.                 d = d + pc[i];
     
422.         }
     
423.         return d / num;
     
424. }
     
425. 
     
426. //自适应移动平均线（Adaptive Exponential Moving Average, AEMA）
     
427. double test::AEMA(string period, string inst, int num, int pds)//自适应移动平均线（Adaptive Exponential Moving Average, AEMA）
     
428. {
     
429.         int key = 0;
     
430.         mltp1 = 2/(pds+1);
     
431.         mltp2 = 0;
     
432.         rate = 0;
     
433.         aema1 = 0;
     
434.         aema2 = 0;
     
435.         value2 = -99999;
     
436.         value3 = 99999;
     
437.         map<string, TKVALUE>::iterator it;
     
438.         for (it = mapK[sPeriod][sInst].begin(); it != mapK[sPeriod][sInst].end(); it++)
     
439.         {
     
440.                 highs.push_back(it->second.dHigh);//将最高价装入vector中
     
441.                 lows.push_back(it->second.dLow); //将最低价装入vector中
     
442.                 a0 = it->second.dClose;
     
443.                 if (key < num)
     
444.                 {
     
445.                         aema1 = aema1 + a0;//收盘价总和
     
446.                         aema2 = aema1 / (key + 1);
     
447.                         key++;
     
448.                 }
     
449.                 else
     
450.                 {
     
451.                         for (int i = 0; i < pds; i++) //将近10个周期的bar最高值装入vector
     
452.                         {
     
453.                                 value2 = max2(value2, highs[key - 1 - i]); //遍历最近10个最高价找到最大的那个值放入value2
     
454.                                 value3 = min2(value3, lows[key - 1 - i]);
     
455.                         }
     
456.                         a1 = (a0 - value3);
     
457.                         a2 = (value2 - a0);
     
458.                         a3 = value2 - value3;
     
459.                         a4 = abs(a1 - a2);
     
460.                         if (a3 != 0)mltp2 = a4 / a3;
     
461.                         rate = (1 + mltp2) * 2 / 11;
     
462.                         aema2 = aema2 + rate * (it->second.dClose - aema2);
     
463.                         key++;
     
464.                 }
     
465.         }
     
466.         return aema2;
     
467. }

复制代码

2024.11.13日增加c++语言下的布林带(bollingerbans,BOLL)指标的编写，并形成模块化，可以在指标和策略中方便调用：http://www.qhlt.cn/thread-160288-1-1.html；

2024.11.13 新增C++编程语言下的MACD指标公式程式码，平滑异同移动平均线(Moving Average Convergence Divergence,MACD)，并形成模块化，可以在指标和策略中方便调用：http://www.qhlt.cn/thread-160291-1-1.html；

2024.11.13 新增C++编程语言下的方差(variance)、标准差(standard deviation,sdev)计算公式，方便设计像boll带这样的指标时直接调用。【方差(variance)、标准差(standard deviation,sdev)计算方法及调用方法】：http://www.qhlt.cn/thread-160300-1-1.html；

2024.12.12新增：

鼎元C++量化程式码指标与函数模块系列之【指数移动平均(Exponential Moving Average,ema)计算方法及调用方法】：http://www.qhlt.cn/thread-160997-1-1.html；

鼎元C++量化程式码指标与函数模块系列之【加权移动平均线（Weighted Moving Average，WMA）的计算方法及调用方法】：http://www.qhlt.cn/thread-161023-1-1.html；

鼎元C++量化程式码指标与函数模块系列之【highest[N]、lowest[N]及close[N]的计算方法及调用方法】:http://www.qhlt.cn/thread-161180-1-1.html;

C++程序化/量化学习视频教程系列 第050节：鼎元C++量化指标封装之【市场强度函数(marketstrength)计算方法及调用方法】【C++量化指标公式开发系列】:http://www.qhlt.cn/thread-161582-1-1.html;

2025.01.16 新增【动量指标(Momentum Index,MTM)计算方法及调用方法】：http://www.qhlt.cn/thread-161650-1-1.html；

2025.04.02  更新并优化了一下MACD指标的调用：http://www.qhlt.cn/thread-162976-1-1.html；

并且加到了指标模块中。

2025年4.12日我重新整理的函数公式变量声明和模板

test.h头文件声明部分：

1. //指标公式变量声明******************************************************************test头文件指标公式变量名称模块开始（修改与编辑指标参数变量）
   
2.         double iff(bool cond1, int num, int ref);//iff函数
   
3.         double max2(double a, double b);//返回a,b中较大值
   
4.         double max3(double a, double b, double c);//返回a,b,c中最大值
   
5.         double min2(double a, double b); //返回a,b中较小值
   
6.         double min3(double a, double b, double c);//返回a,b,c中最小值
   
7.         double waverage(string period, string inst, int num);//计算Weighted Moving Average，加权移动平均线
   
8.         double average(string period, string inst, int num); //average,ma函数变量,atr计算功能
   
9.         double highest(string period, string inst, int num);//计算NUM周期最高价格
   
10.         double highestN(string period, string inst, int num, int ref);//计算REF前个bar的num周期最高价格
    
11.     double lowest(string period, string inst, int num); //计算NUM周期最低价格
    
12.         double lowestN(string period, string inst, int num, int ref);//计算ref前个bar的num周期的最低价格
    
13.         double closeN(string period, string inst, int ref);//计算ref前个bar的收盘价格
    
14.         double avgtruerange(string period, string inst, int num); //计算真实波动幅度平均值(average true range)
    
15.         double Variance(string period, string inst, int num);//计算方差公式变量
    
16.         double StandardDev(string period, string inst, int num);//计算标准差公式变量
    
17.         double Volatility(string period, string inst, int num);//计算历史波动率（CALCULATING HISTORICAL VOLATILITY）
    
18.         double bollingerbands(string period, string inst, int num, int ref); //计算boll布林带变量
    
19.         //指数移动平均返回具体数据时调用xaverage,返回数组时则用ema调用。数组形式多用于指标计算中间变量
    
20.         double xaverage(string period, string inst, int num);//计算num周期指数移动平均(Exponential Moving Average)值
    
21.         vector<double>ema(vector<double>pc, int num);//ema计算返回数组vector形式指数移动平均
    
22.         //指数移动平均返回具体数据时调用xaverage,返回数组时则用ema调用。数组形式多用于指标计算中间变量
    
23.         vector<double>EMAvectorCaL(vector<double>pc, int num);//EMA容器计算形式
    
24.         vector<double>MACDcalculate(vector<double>pc, int shortPeriod, int longPeriod);//计算MACD
    
25.         double mav(vector<double>pc, int num);//计算简单MA数组形式
    
26.         double hhv(vector<double> pc, int num);
    
27.         double llv(vector<double> pc, int num);
    
28.         double AEMA(string period, string inst, int num, int pds);//自适应移动平均线（Adaptive Exponential Moving Average, AEMA）
    
29.         vector<double>aema, highs, lows; //vector变量容器
    
30.         double a0, a1, a2, a3, a4, value2, value3, mltp1, mltp2, rate, aema1, aema2;//必要变量,自适应移动平均线
    
31.         double marketstrength(string period,string inst, int num);//marketstrength函数调用与计算
    
32.         double Momentum(string period, string inst, int num); //动量指标(Momentum Index,MTM)计算与指标调用
    
33. //指标公式变量声明******************************************************************test头文件指标公式变量名称模块结束（修改与编辑指标参数变量）

复制代码

函数模板模块：

1. //****************************************************************外部引用文件开始（谨慎修改）
   
2. #include "pch.h"
   
3. #include "test.h"
   
4. #include <vector>
   
5. #include <windows.h>
   
6. #include <fstream>
   
7. #include <stdio.h>
   
8. #include <mmsystem.h>
   
9. #include <thread>
   
10. #pragma comment(lib,"winmm.lib")
    
11. #include <algorithm> // For std::min_element and std::max_element
    
12. #include <deque>
    
13. using namespace std;
    
14. //****************************************************************主程序指标公式function计算模块（公式编辑与设计区）
    
15. // iff功能函数开始
    
16. double test::iff(bool cond1, int num, int ref)
    
17. {
    
18.         int d = 0;
    
19.         if (cond1)
    
20.         {
    
21.                 d = num;
    
22.         }
    
23.         else
    
24.         {
    
25.                 d = ref;
    
26.         }
    
27. 
    
28.         return d;
    
29. }
    
30. 
    
31. //max2(a,b)比较a,b两个数字
    
32. double test::max2(double a, double b)
    
33. {
    
34.         double c = 0;
    
35.         if (a >= b)
    
36.         {
    
37.                 c = a;
    
38.         }
    
39.         else
    
40.         {
    
41.                 c = b;
    
42.         }
    
43.         return c;
    
44. }
    
45. 
    
46. //max3(a,b)比较a,b,c三个数字
    
47. double test::max3(double a, double b, double c)
    
48. {
    
49.         double d = 0;
    
50. 
    
51.         if (a >= b)
    
52.         {
    
53.                 d = a;
    
54.         }
    
55.         else if (a < b)
    
56.         {
    
57.                 d = b;
    
58.         }
    
59.         if (d < c)
    
60.         {
    
61.                 d = c;
    
62.         }
    
63.         return d;
    
64. }
    
65. 
    
66. //min2(a,b)比较两个数字大小
    
67. double test::min2(double a, double b)
    
68. {
    
69.         double c = 0;
    
70.         if (a >= b)
    
71.         {
    
72.                 c = b;
    
73.         }
    
74.         else
    
75.         {
    
76.                 c = a;
    
77.         }
    
78.         return c;
    
79. }
    
80. 
    
81. //min3(a,b,c)比较三个数字大小
    
82. double test::min3(double a, double b, double c)
    
83. {
    
84.         double d = 0;
    
85. 
    
86.         if (a >= b)
    
87.         {
    
88.                 d = b;
    
89.         }
    
90.         else if (a < b)
    
91.         {
    
92.                 d = a;
    
93.         }
    
94.         if (d > c)
    
95.         {
    
96.                 d = c;
    
97.         }
    
98.         return d;
    
99. }
    
100. 
     
101. //均线average计算公式开始
     
102. double test::average(string period, string inst, int num)
     
103. {
     
104.         int key = 0;
     
105.         double sump = 0;
     
106.         if (mapK[period][inst].size() < num) return 0;
     
107.         map<string, TKVALUE>::reverse_iterator it;
     
108.         for (it = mapK[sPeriod][sInst].rbegin(); it != mapK[sPeriod][sInst].rend(); it++)
     
109.         {
     
110.                 sump = sump + it->second.dClose;
     
111.                 key++;
     
112.                 if (key >= num)break;
     
113.         }
     
114.         return sump / num;
     
115. }
     
116. //计算num周期内bar最高价格
     
117. double test::highest(string period, string inst, int num)
     
118. {
     
119.         double hiprice = 0;
     
120.         int key = 0;
     
121.         map<string, TKVALUE>::reverse_iterator it; //建立逆向迭代器从右往左
     
122.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++) //FOR循环遍历
     
123.         {
     
124.                 if (hiprice < it->second.dHigh) hiprice = it->second.dHigh; //如果hiprice值小于遍历的bar的最高价，则将最高价赋值给hiprice
     
125.                 key++;//计算循环次数
     
126.                 if (key >= num)break; //达到num个bar后跳出循环
     
127.         }
     
128.         return hiprice;//将获取的最高价格值返回
     
129. }
     
130. //计算num周期内bar的最低价格
     
131. double test::lowest(string period, string inst, int num)
     
132. {
     
133.         double lowprice = 0;
     
134.         int key = 0;
     
135.         map<string, TKVALUE>::reverse_iterator it;
     
136.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
137.         {
     
138.                 if (lowprice == 0)lowprice = it->second.dLow;
     
139.                 if (lowprice > it->second.dLow)lowprice = it->second.dLow;
     
140.                 key++;
     
141.                 if (key >= num)break;
     
142.         }
     
143.         return lowprice;
     
144. }
     
145. 
     
146. //计算历史波动率（calculating historical volatility）
     
147. double test::Volatility(string period, string inst, int num)
     
148. {
     
149.         double PreClose = 0;//获取每个bar前一个bar的收盘价
     
150.         double tr = 0; //tr的值计算
     
151.         int key = 0; //计数器
     
152.         vector<double>vtr; //建立一个数组,用来存放每个bar对应的truerange值，它们的下标号与bar的是一致的
     
153.         if (mapK[period][inst].size() < num) return 0; //如果数据数量不够返回0；
     
154.         map<string, TKVALUE >::iterator it; //建立正迭代器，标号从0开始，从左向右开始
     
155.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); ++it) //从第一开始的bar数据开始遍历
     
156.         {
     
157.                 if (PreClose != 0) //如果值不为0说明是在中间的bar,开始在bar数据要素中采集需要的变量数值
     
158.                 {
     
159.                         double dHL = it->second.dHigh - it->second.dLow; //当根bar的最高减最低
     
160.                         double dHC = abs(it->second.dHigh - PreClose); //当根bar最高减昨日收盘
     
161.                         double dLC = abs(it->second.dLow - PreClose); //当根bar最低减昨日收盘
     
162.                         double e = max3(dHL, dHC, dLC); //获得每一个bar对应的truerange值(上面三者之最大者)
     
163.                         vtr.push_back(e); //将上面e的值放到tr的vector(数组)里面供下面使用
     
164.                 }
     
165.                 PreClose = it->second.dClose; //将当前bar的收盘价数值赋给此变量供下一个bar使用
     
166.         }
     
167.         //计算tr的num周期指数移动平均值
     
168.         if (key <= num)
     
169.         {
     
170.                 tr = 0;
     
171.                 key++;
     
172.         }
     
173.         else
     
174.         {
     
175.                 tr = (vtr[vtr.size() - 1]) * 2 / (num + 1) + tr * (num - 1) / (num + 1); // 2/(num + 1)指数移动平均线的平滑因子
     
176.                 //tr = (2 * vtr[vtr.size()-1] + (num - 1) * tr)/(num + 1); //第二种计算vtr指数移动平均方式，平滑因子不变
     
177.         }
     
178.         return tr;
     
179. }
     
180. 
     
181. //计算真实波动幅度平均值(average true range)
     
182. double test::avgtruerange(string period, string inst, int num)
     
183. {
     
184.         double preclose = 0; //设计一个局部变量存储上一日收盘价
     
185.         double sumatr = 0;  // 设计一个加总变量, 存储atr的值
     
186.         vector<double>vatr;//设计一个vector变量，存储tr值
     
187.         if (mapK[period][inst].size() < num) return 0; //如果数据不够用返回0
     
188.         map<string, TKVALUE>::iterator it;//建立一个正向迭代器
     
189.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); it++) //建立 for 循环采集需要的要素数据
     
190.         {
     
191.                 if (preclose != 0) //这次不是第一次循环
     
192.                 {
     
193.                         double dHL = it->second.dHigh - it->second.dLow; //当天最高价减当天最低价
     
194.                         double dHC = abs(it->second.dHigh - preclose);  //当天最高价减昨天收盘价
     
195.                         double dLC = abs(it->second.dLow - preclose);   //当天最低价减昨天收盘价
     
196.                         vatr.push_back(max3(dHL, dHC, dLC)); //将上面三个值中最大值加入到vector里面
     
197.                 }
     
198.                 preclose = it->second.dClose; //每次遍历后将当天的收盘价赋值给preclose供下次遍历使用
     
199.         }
     
200.         for (int i = 1; i <= length; i++)
     
201.         {
     
202.                 sumatr = sumatr + vatr[vatr.size() - i];//将vatr中的数据从右至左依顺序加总num个
     
203.         }
     
204.         return sumatr / num;
     
205. }
     
206. //方差计算公式
     
207. double test::Variance(string period, string inst, int num)
     
208. {
     
209.         double ma = average(sPeriod, sInst, num);//中间均线
     
210.         int key = 0;
     
211.         double sumdev = 0;
     
212.         double madev = 0;
     
213.         if (mapK[period][inst].size() < num) return 0;
     
214.         map<string, TKVALUE>::reverse_iterator it;
     
215.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
216.         {
     
217.                 sumdev += pow(it->second.dClose - ma, 2); //计算偏离平方和
     
218.                 key++;
     
219.                 if (key >= num)break; //num次循环后跳出
     
220.         }
     
221.         return sumdev / num;
     
222. }
     
223. 
     
224. //标准差计算公式
     
225. double test::StandardDev(string period, string inst, int num)
     
226. {
     
227.         double value1 = 0;
     
228.         if (mapK[period][inst].size() < num) return 0;
     
229.         value1 = Variance(sPeriod, sInst, num);
     
230. 
     
231.         return sqrt(value1);
     
232. }
     
233. //boll布林带计算公式
     
234. double test::bollingerbands(string period, string inst, int num, int ref)
     
235. {
     
236.         double ma = average(sPeriod, sInst, num); //获取num周期平均线ma
     
237.         int key = 0;
     
238.         double sumdev = 0;
     
239.         double madev = 0;
     
240.         if (mapK[period][inst].size() < num) return 0;
     
241.         map<string, TKVALUE>::reverse_iterator it;
     
242.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
243.         {
     
244.                 sumdev += pow(it->second.dClose - ma, 2);
     
245.                 key++;
     
246.                 if (key >= num)break;
     
247.         }
     
248.         madev = sqrt(sumdev / num); //获得标准差
     
249. 
     
250.         return ma + ref * madev;
     
251. }
     
252. 
     
253. //计算num周期指数移动平均(Exponential Moving Average)值
     
254. double test::xaverage(string period, string inst, int num)
     
255. {
     
256.         double n = 0;
     
257.         double ema = 0;
     
258.         if (mapK[period][inst].size() < num) return 0;
     
259.         map<string, TKVALUE>::iterator it;
     
260.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); it++)
     
261.         {
     
262.                 if (n < num)
     
263.                 {
     
264.                         ema = (ema + it->second.dClose) / (n + 1);
     
265.                         n++;
     
266.                 }
     
267.                 else
     
268.                 {
     
269.                         ema = (2 * it->second.dClose + (n - 1) * ema) / (n + 1); //指数移动平均计算核心公式,ema = a*close + (1-a)*ema[1],a为加权因子,通常=2/(N+1)
     
270.                 }
     
271.         }
     
272.         return ema;
     
273. }
     
274. 
     
275. //计算Weighted Moving Average,加权移动平均
     
276. double test::waverage(string period, string inst, int num)
     
277. {
     
278.         double sumwma = 0;
     
279.         int i = 0;
     
280.         if (mapK[period][inst].size() < num) return 0; //bar数量小于num个时返回0
     
281.         map<string, TKVALUE>::reverse_iterator it;
     
282.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
283.         {
     
284.                 sumwma += (num-i) * it->second.dClose; //计算num*close + (num-1)*close[1] +...+ 1*close[num-1]的总和
     
285.                 i++;
     
286.                 if(i >= num) break;
     
287.         }
     
288.         double d = (num+1)*num * 0.5; //计算num从1到num的总和
     
289.         return sumwma / d;
     
290. }
     
291. //ema计算返回数组vector形式指数移动平均
     
292. vector<double>test::ema(vector<double>pc, int num)
     
293. {
     
294.         vector<double>emav;
     
295.         double emavector = 0;
     
296.         int i = 0;
     
297. 
     
298.         for (int it = 0; it < pc.size(); it++)
     
299.         {
     
300. //                if (i < num)
     
301. //                {
     
302. //                        emavector = (emavector + pc[it])/(i+1);
     
303. //                        i++;
     
304. //                        emav.push_back(emavector);
     
305. //                }
     
306. //                else
     
307. //                {
     
308. ////                        emavector = (2*pc[it]+(num-1)*emavector)/(num+1);//ema均线计算公式
     
309. //                        emavector = emavector + 2 * (pc[it] - emavector) / (num + 1);
     
310. //                        emav.push_back(emavector);
     
311. //                }
     
312.                 if (it == 0)
     
313.                 {
     
314.                         emavector = emavector + pc[it];
     
315.                         emav.push_back(pc[0]);
     
316.                 }else
     
317.                 {
     
318. //                        emavector = (2*pc[it]+(num-1)*emavector)/(num+1);//ema均线计算公式
     
319.                         emavector = emavector + 2 * (pc[it] - emavector) / (num + 1);
     
320.                         emav.push_back(emavector);
     
321.                 }
     
322.         }
     
323.         return emav;
     
324. }
     
325. //计算REF前个bar的num周期最高价格
     
326. double test::highestN(string period, string inst, int num, int ref)
     
327. {
     
328.         double d = 0;
     
329.         int n = 0;
     
330.         int r = 0;
     
331.         map<string, TKVALUE>::reverse_iterator it;
     
332.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
333.         {
     
334.                 r++;
     
335.                 if (r <= ref)continue; //需要跳过的bar数
     
336.                 if (d < it->second.dHigh)d = it->second.dHigh; //将最大值赋值给d
     
337.                 n++;
     
338.                 if (n >= num) break; //num 次循环后跳出（从0开始，所以从num-1个后就退出）
     
339.         }
     
340.         return d; //返回d
     
341. }
     
342. //计算ref前个bar的num周期的最低价格
     
343. double test::lowestN(string period, string inst, int num, int ref)
     
344. {
     
345.         double d = 0;
     
346.         int n = 0;
     
347.         int r = 0;
     
348.         map<string, TKVALUE>::reverse_iterator it;
     
349.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
350.         {
     
351.         r++;
     
352.         if (r <= ref) continue; //需要跳过的bar数
     
353.         if (d == 0)d = it->second.dLow; //判断是否是第一次循环
     
354.         if (d > it->second.dLow)d = it->second.dLow; //将低最值赋给d
     
355.         n++;
     
356.         if (n >= num)break; //num个循环后退出
     
357.         }
     
358.         return d; //返回d值
     
359. }
     
360. //返回ref个bar前的收盘价
     
361. double test::closeN(string period, string inst, int ref)
     
362. {
     
363.         double d = 0;
     
364.         int r = 0;
     
365.         int n = 0;
     
366.         map<string, TKVALUE>::reverse_iterator it;
     
367.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
368.         {
     
369.                 r++;
     
370.                 if (r <= ref)continue; //跳过ref个bar
     
371.                 d = it->second.dClose; //将ref个bar前一个bar的收盘价赋值给d ;
     
372.                 break;
     
373.         }
     
374.         return d;
     
375. }
     
376. ////////////////////////////////////////////////////////////////////////////////////////////////////////////MACD公式计算
     
377. vector<double>test::EMAvectorCaL(vector<double>pc, int num)//EMA容器计算形式
     
378. {
     
379.         vector<double> ema(pc.size());
     
380.         double multiplier = 2.0 / (num + 1);
     
381.         ema[0] = pc[0]; // 初始化第一值为价格的第一个值
     
382.         for (int i = 1; i < pc.size(); i++) {
     
383.                 ema[i] = (pc[i] - ema[i - 1]) * multiplier + ema[i - 1];
     
384.         }
     
385.         return ema;
     
386. }
     
387. vector<double>test::MACDcalculate(vector<double>pc, int shortPeriod, int longPeriod)
     
388. {
     
389.         // 计算快线和慢线的 EMA
     
390.         vector<double> shortEMA = EMAvectorCaL(pc, shortPeriod);
     
391.         vector<double> longEMA = EMAvectorCaL(pc, longPeriod);
     
392. 
     
393.         // 计算 DIFF
     
394.         vector<double> diff(pc.size());
     
395.         for (int i = 0; i < pc.size(); i++)
     
396.         {
     
397.                 diff[i] = shortEMA[i] - longEMA[i];
     
398.         }
     
399.         return diff;
     
400. }
     
401. ////////////////////////////////////////////////////////////////////////////////////////////////////////////MACD公式计算
     
402. 
     
403. ////////////////////////////////////////////////////////////////////////////////////////////////////////////KDJ公式计算
     
404. double test::hhv(vector<double> pc, int num)
     
405. {
     
406.         double d = 0;
     
407.         for (size_t i = pc.size() - 1; i >= pc.size() - num; i--)
     
408.         {
     
409.                 d = max2(d, pc[i]);
     
410.         }
     
411.         return d;
     
412. }
     
413. 
     
414. double test::llv(vector<double> pc, int num)
     
415. {
     
416.         double d = 999999;
     
417.         for (size_t i = pc.size() - 1; i >= pc.size() - num; i--)
     
418.         {
     
419.                 d = min2(d, pc[i]);
     
420.         }
     
421.         return d;
     
422. }
     
423. ////////////////////////////////////////////////////////////////////////////////////////////////////////////KDJ公式计算
     
424. 
     
425. double test::mav(vector<double>pc, int num)//计算简单MA数组形式
     
426. {
     
427.         if (pc.size() <2) return 0;
     
428.         double d = 0;
     
429.         for (size_t i = pc.size() - 1; i >= pc.size() - num; i--)
     
430.         {
     
431.                 d = d + pc[i];
     
432.         }
     
433.         return d / num;
     
434. }
     
435. 
     
436. //自适应移动平均线（Adaptive Exponential Moving Average, AEMA）
     
437. double test::AEMA(string period, string inst, int num, int pds)//自适应移动平均线（Adaptive Exponential Moving Average, AEMA）
     
438. {
     
439.         int key = 0;
     
440.         mltp1 = 2/(pds+1);
     
441.         mltp2 = 0;
     
442.         rate = 0;
     
443.         aema1 = 0;
     
444.         aema2 = 0;
     
445.         value2 = -99999;
     
446.         value3 = 99999;
     
447.         map<string, TKVALUE>::iterator it;
     
448.         for (it = mapK[sPeriod][sInst].begin(); it != mapK[sPeriod][sInst].end(); it++)
     
449.         {
     
450.                 highs.push_back(it->second.dHigh);//将最高价装入vector中
     
451.                 lows.push_back(it->second.dLow); //将最低价装入vector中
     
452.                 a0 = it->second.dClose;
     
453.                 if (key < num)
     
454.                 {
     
455.                         aema1 = aema1 + a0;//收盘价总和
     
456.                         aema2 = aema1 / (key + 1);
     
457.                         key++;
     
458.                 }
     
459.                 else
     
460.                 {
     
461.                         for (int i = 0; i < pds; i++) //将近10个周期的bar最高值装入vector
     
462.                         {
     
463.                                 value2 = max2(value2, highs[key - 1 - i]); //遍历最近10个最高价找到最大的那个值放入value2
     
464.                                 value3 = min2(value3, lows[key - 1 - i]);
     
465.                         }
     
466.                         a1 = (a0 - value3);
     
467.                         a2 = (value2 - a0);
     
468.                         a3 = value2 - value3;
     
469.                         a4 = abs(a1 - a2);
     
470.                         if (a3 != 0)mltp2 = a4 / a3;
     
471.                         rate = (1 + mltp2) * 2 / 11;
     
472.                         aema2 = aema2 + rate * (it->second.dClose - aema2);
     
473.                         key++;
     
474.                 }
     
475.         }
     
476.         return aema2;
     
477. }
     
478. //marketstrength函数调用与计算
     
479. double test::marketstrength(string period, string inst, int num)
     
480. {
     
481.         double val1 = 0;
     
482.         double val2 = 0;
     
483.         double val3 = 0;
     
484.         int key = 0;
     
485.         double marketstrength = 0;
     
486.         map<string, TKVALUE>::reverse_iterator it; //建立逆向迭代
     
487.         for (it = mapK[sPeriod][sInst].rbegin(); it != mapK[sPeriod][sInst].rend(); it++) //遍历
     
488.         {
     
489.                 pc.push_back(it->second.dClose); //将收盘价装入pc容器,注意是反向的,越靠前数据越新,比方说pc[0]是最新价格
     
490.                 if (key > length)break; //截取前0-11个收盘价,一共12个数据
     
491.                 key++;
     
492.         }
     
493.         for (int i = 0; i <= num; i++)
     
494.         {
     
495.                 val1 += iff(pc[i] > pc[i + 1], pc[i], -pc[i]);
     
496.                 val2 += iff(pc[i] > pc[i + 1], pc[i], 0);
     
497.                 val3 += iff(pc[i] > pc[i + 1], 0, pc[i]);
     
498.         }
     
499. 
     
500.         if (val1 >= 0)
     
501.         {
     
502.                 marketstrength = 100 * val1 / val2;
     
503.         }
     
504.         else
     
505.         {
     
506.                 marketstrength = 100 * val1 / val3;
     
507.         }
     
508.         return marketstrength;
     
509. }
     
510. //动量指标(Momentum Index,MTM)计算与指标调用
     
511. double test::Momentum(string period, string inst, int num)
     
512. {
     
513.         double d = 0;
     
514.         int r = 0;
     
515.         int n = 0;
     
516.         map<string, TKVALUE>::reverse_iterator it;
     
517.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); it++)
     
518.         {
     
519.                 if (r == 0) n = it->second.dClose;
     
520.                 r++;
     
521.                 if (r < num)continue; //跳过NUM个bar
     
522.                 d = it->second.dClose; //将ref个bar前一个bar的收盘价赋值给d ;
     
523.                 break;
     
524.         }
     
525.         return n - d;
     
526. }

复制代码

2025.04.20日更新模板：

test.h声明变量：

1.         //公式指标(function)变量设计(开始)******************************************
   
2.         double iff(bool cond1, int num, int ref);//iff函数
   
3.         double max2(double a, double b);//返回a,b中较大值
   
4.         double max3(double a, double b, double c);//返回a,b,c中最大值
   
5.         double min2(double a, double b); //返回a,b中较小值
   
6.         double min3(double a, double b, double c);//返回a,b,c中最小值
   
7.         double average(string period, string inst, int num); //均线函数变量
   
8.         double averageref(string period, string inst, int num, int ref); //均线average[1]功能函数变量
   
9.         double highest(string period, string inst, int num); //最高价highest函数变量
   
10.         double highestref(string period, string inst, int num, int ref);//最高high[1]功能函数变量
    
11.         double lowest(string period, string inst, int num); //最低价lowest函数变量
    
12.         double lowestref(string period, string inst, int num, int ref);//最低lowest[1] 功能函数变量
    
13.         double avgtruerange(string period, string inst, int num); //averagetruerange函数变量,atr计算功能
    
14.         double bollingerbands(string period, string inst, int num,int ref);//BOLL计算公式；
    
15.         double Variance(string period, string inst, int num);//方差计算公式变量
    
16.         double StandardDev(string period, string inst, int num);//标准差计算公式变量
    
17.         double xaverage(string period, string inst, int num);//xaverage计算公式；
    
18.         double ema(string period, string inst, int num);//ema计算公式；
    
19.         vector<double>emaseries(vector<double> pc, int num); //ema计算公式(返回数组)；
    
20.         vector<double>averagearray(vector<double> pc, int num); //ema计算公式(返回数组)；
    
21.         double closeref(string period, string inst, int ref);//获得close[ref]值
    
22.         double macd(string period, string inst, int num, int num1, int num2);//macd计算公式变量
    
23.         double aema(string period, string inst, int num, int pds);//自适应移动平均线（Adaptive Exponential Moving Average, AEMA）
    
24.         double highestseries(vector<double> pc, int num);//求数组容器形式的highest(high,length)
    
25.         double lowestseries(vector<double> pc, int num); //求数组容器形式的lowest(low,length)
    
26.         vector<double>smaseries(vector<double>pc, int num, int num2);//指数平滑移动平均函数(SMA,sma(x,N,M),即x变量的N周期平均，最新值权重为M，即SMAt = SMAt-1 * (N-M)/N + x*M/N )返回数组形式
    
27.         //公式指标(function)变量设计(结束)******************************************

复制代码

function模块区或主程序区指标模块：

1. //******************************************************************公式(function)模块(开始)*******************************************************************/
   
2. // iff功能函数开始
   
3. double test::iff(bool cond1, int num, int ref)
   
4. {
   
5.         int d = 0;
   
6.         if (cond1)
   
7.         {
   
8.                 d = num;
   
9.         }
   
10.         else
    
11.         {
    
12.                 d = ref;
    
13.         }
    
14.         return d;
    
15. }
    
16. //max2(a,b)比较a,b两个数字
    
17. double test::max2(double a, double b)
    
18. {
    
19.         double c = 0;
    
20.         if (a >= b)
    
21.         {
    
22.                 c = a;
    
23.         }
    
24.         else
    
25.         {
    
26.                 c = b;
    
27.         }
    
28.         return c;
    
29. }
    
30. //max3(a,b)比较a,b,c三个数字
    
31. double test::max3(double a, double b, double c)
    
32. {
    
33.         double d = 0;
    
34. 
    
35.         if (a >= b)
    
36.         {
    
37.                 d = a;
    
38.         }
    
39.         else if (a < b)
    
40.         {
    
41.                 d = b;
    
42.         }
    
43.         if (d < c)
    
44.         {
    
45.                 d = c;
    
46.         }
    
47.         return d;
    
48. }
    
49. //min2(a,b)比较两个数字大小
    
50. double test::min2(double a, double b)
    
51. {
    
52.         double c = 0;
    
53.         if (a >= b)
    
54.         {
    
55.                 c = b;
    
56.         }
    
57.         else
    
58.         {
    
59.                 c = a;
    
60.         }
    
61.         return c;
    
62. }
    
63. //min3(a,b,c)比较三个数字大小
    
64. double test::min3(double a, double b, double c)
    
65. {
    
66.         double d = 0;
    
67.         if (a >= b)
    
68.         {
    
69.                 d = b;
    
70.         }
    
71.         else if (a < b)
    
72.         {
    
73.                 d = a;
    
74.         }
    
75.         if (d > c)
    
76.         {
    
77.                 d = c;
    
78.         }
    
79.         return d;
    
80. }
    
81. //均线average计算公式开始
    
82. double test::average(string period, string inst, int num)
    
83. {
    
84.         double d = 0;
    
85.         int n = 0;
    
86.         map<string, TKVALUE>::reverse_iterator it;
    
87.         //  InsertLog(to_string(mapK[period][inst].size()));
    
88.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); ++it)
    
89.         {
    
90.                 d += it->second.dClose;
    
91.                 n++;
    
92.                 if (n >= num)break;
    
93.         }
    
94.         return d / n;
    
95. }
    
96. //均线average[1]计算公式开始
    
97. double test::averageref(string period, string inst, int num, int ref)
    
98. {
    
99.         double d = 0;
    
100.         int n = 0;
     
101.         int r = 0;
     
102.         map<string, TKVALUE>::reverse_iterator it;
     
103.         //  InsertLog(to_string(mapK[period][inst].size()));
     
104.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); ++it)
     
105.         {
     
106.                 r++;
     
107.                 if (r <= ref)continue;
     
108.                 d += it->second.dClose;
     
109.                 n++;
     
110.                 if (n >= num)break;
     
111.         }
     
112.         return d / n;
     
113. }
     
114. //最高价highest计算公式开始
     
115. double test::highest(string period, string inst, int num)
     
116. {
     
117.         double d = 0;
     
118.         int n = 0;
     
119.         map<string, TKVALUE>::reverse_iterator it;
     
120.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); ++it)
     
121.         {
     
122.                 if (d < it->second.dHigh)d = it->second.dHigh;
     
123.                 n++;
     
124.                 if (n >= num)break;
     
125.         }
     
126.         return d;
     
127. }
     
128. //最高价highest[1]计算公式开始
     
129. double test::highestref(string period, string inst, int num, int ref)
     
130. {
     
131.         double d = 0;
     
132.         int n = 0;
     
133.         int r = 0;
     
134.         map<string, TKVALUE>::reverse_iterator it;
     
135.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); ++it)
     
136.         {
     
137.                 r++;
     
138.                 if (r <= ref)continue;
     
139.                 if (d < it->second.dHigh)d = it->second.dHigh;
     
140.                 n++;
     
141.                 if (n >= num)break;
     
142.         }
     
143.         return d;
     
144. }
     
145. //最低价lowest计算公式
     
146. double test::lowest(string period, string inst, int num)
     
147. {
     
148.         double d = 0;
     
149.         int n = 0;
     
150.         map<string, TKVALUE>::reverse_iterator it;
     
151.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); ++it)
     
152.         {
     
153.                 if (d == 0)d = it->second.dLow;
     
154.                 if (d > it->second.dLow)d = it->second.dLow;
     
155.                 n++;
     
156.                 if (n >= num)break;
     
157.         }
     
158.         return d;
     
159. }
     
160. //最低价lowest[1]计算公式开始
     
161. double test::lowestref(string period, string inst, int num, int ref)
     
162. {
     
163.         double d = 0;
     
164.         int n = 0;
     
165.         int r = 0;
     
166.         map<string, TKVALUE>::reverse_iterator it;
     
167.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); ++it)
     
168.         {
     
169.                 r++;
     
170.                 if (r <= ref)continue;
     
171.                 if (d == 0)d = it->second.dLow;
     
172.                 if (d > it->second.dLow)d = it->second.dLow;
     
173.                 n++;
     
174.                 if (n >= num)break;
     
175.         }
     
176.         return d;
     
177. }
     
178. //ATR,averagetruerange计算公式开始
     
179. double test::avgtruerange(string period, string inst, int num)
     
180. {
     
181.         double dPreClose = 0;
     
182.         int n = 0;
     
183.         double sumatr = 0;
     
184.         vector<double>vAtr;
     
185.         if (mapK[period][inst].size() < num) return 0;
     
186.         map<string, TKVALUE >::iterator it;
     
187.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); ++it)
     
188.         {
     
189. 
     
190.                 if (dPreClose != 0)
     
191.                 {
     
192.                         double d = it->second.dHigh - it->second.dLow;
     
193.                         double dHC = abs(it->second.dHigh - dPreClose);
     
194.                         double dLC = abs(it->second.dLow - dPreClose);
     
195.                         if (d < dHC)d = dHC;
     
196.                         if (d < dLC)d = dLC;
     
197.                         vAtr.push_back(d);
     
198.                 }
     
199.                 dPreClose = it->second.dClose;
     
200.         }
     
201.         for (int i = 1; i <= num; i++)
     
202.         {
     
203.                 sumatr += vAtr[vAtr.size() - i];
     
204.         }
     
205.         return  sumatr / num;
     
206. }
     
207. 
     
208. //布林带(bollingerbands)开始
     
209. double test::bollingerbands(string period, string inst, int num, int ref)
     
210. {
     
211.         double avg1 = average(sPeriod, sInst,num);//中间均线
     
212.         int n = 0;
     
213.         double sumdev = 0;
     
214.         double madev = 0;
     
215.         if(mapK[period][inst].size()<num) return 0;
     
216.         map<string, TKVALUE>::reverse_iterator it;
     
217.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); ++it)
     
218.         {
     
219.                 sumdev += pow(it->second.dClose - avg1,2); //diff平方加总
     
220.                 n++;
     
221.                 if (n >= num)break;
     
222.         }
     
223.           madev = sqrt(sumdev/num); //得到方差后再取标准差
     
224.    return avg1 + ref*madev;
     
225. }
     
226. 
     
227. //方差计算公式开始
     
228. double test::Variance(string period, string inst, int num)
     
229. {
     
230.         double avg1 = average(sPeriod, sInst, num);//中间均线
     
231.         int n = 0;
     
232.         double sumdev = 0;
     
233.         double madev = 0;
     
234.         if (mapK[period][inst].size() < num) return 0;
     
235.         map<string, TKVALUE>::reverse_iterator it;
     
236.         for (it = mapK[period][inst].rbegin(); it != mapK[period][inst].rend(); ++it)
     
237.         {
     
238.                 sumdev += pow(it->second.dClose - avg1, 2); //偏离平方加总
     
239.                 n++;
     
240.                 if (n >= num)break;
     
241.         }
     
242.         return sumdev/n;
     
243. }
     
244. 
     
245. // 方差计算公式结束
     
246. //标准差计算公式开始
     
247. double test::StandardDev(string period, string inst, int num)
     
248. {
     
249.         double value1 = 0;
     
250.         if (mapK[period][inst].size() < num) return 0;
     
251.         value1 = Variance(sPeriod, sInst, num);
     
252.         return sqrt(value1);
     
253. }
     
254. // 标准差计算公式结束
     
255. //获得close[ref]值
     
256. double test::closeref(string period, string inst, int ref)
     
257. {
     
258.         int d = 0;
     
259.         int r = 0;
     
260.         map<string, TKVALUE>::reverse_iterator it;//逆向迭代
     
261.         for (it = mapK[sPeriod][sInst].rbegin(); it != mapK[sPeriod][sInst].rend(); it++) //逆向遍历所有K线
     
262.         {
     
263.                 r++;
     
264.                 if (r <= ref)continue; //跳过ref个bar
     
265.                 d = it->second.dClose; //将ref个bar前一个bar的收盘价赋值给d ;
     
266.                 break;
     
267.         }
     
268.         return d;
     
269. }
     
270. //xaverage计算公式(跟下面ema函数为同一函数,方便大家偏好)
     
271. double test::xaverage(string period, string inst, int num)
     
272. {
     
273.         double d = 0;
     
274.         int r = 0;
     
275.         map<string, TKVALUE >::iterator it;
     
276.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); ++it)
     
277.         {
     
278.                 if (r < num)//当数据不够num个bar时用总和/(bar个数加1)
     
279.                 {
     
280.                         d = (d + it->second.dClose) / (r + 1);
     
281.                         r++;
     
282.                 }
     
283.                 else //当bar的总个数大于num个周期时,ema = a*close + (1-a)*ema[1],a一般为2/(num+1)
     
284.                 {
     
285.                         d = (2 * it->second.dClose + (num - 1) * d) / (num + 1);
     
286.                 }
     
287.         }
     
288.         return d;
     
289. }
     
290. //ema计算公式开始
     
291. double test::ema(string period, string inst, int num)
     
292. {
     
293.         double d = 0;
     
294.         int r = 0;
     
295.         map<string, TKVALUE >::iterator it;
     
296.         for (it = mapK[period][inst].begin(); it != mapK[period][inst].end(); ++it)
     
297.         {
     
298.                 if (r < num)//当数据不够num个bar时用总和/(bar个数加1)
     
299.                 {
     
300.                         d=(d+it->second.dClose)/(r+1);
     
301.                         r++;
     
302.                 }
     
303.                 else //当bar的总个数大于num个周期时,ema = a*close + (1-a)*ema[1],a一般为2/(num+1)
     
304.                 {
     
305.                         d=(2*it->second.dClose+(num-1)*d)/(num+1);
     
306.                 }
     
307.         }
     
308.         return d;
     
309. }
     
310. //ema计算公式开始(返回数组)
     
311. vector<double> test::emaseries(vector<double> pc, int num)
     
312. {
     
313.         vector<double> r;
     
314.         double d = 0;
     
315. 
     
316.         for (int i = 0; i < pc.size(); i++)
     
317.         {
     
318.                 if (i == 0)
     
319.                 {
     
320.                         d = pc[0];
     
321.                         r.push_back(d);
     
322.                 }
     
323.                 else
     
324.                 {
     
325.                         d = (2*pc[i]+(num-1)*d)/(num+1);
     
326.                         r.push_back(d);
     
327.                 }
     
328.         }
     
329.         return r;
     
330. }
     
331. //averagearray计算公式开始(返回数组)
     
332. vector<double> test::averagearray(vector<double> pc, int num)
     
333. {
     
334.         vector<double> re;
     
335.         int r = 0;
     
336.         double d = 0;
     
337.         double e = 0;
     
338.         for (int i = 0; i < pc.size(); i++)
     
339.         {
     
340.                 if (r < num) //如果bar的数目不够基本的周期,则返回加总除以bar数目代替
     
341.                 {
     
342.                         d = (d + pc[i])/(r);
     
343.                         r++;
     
344.                         re.push_back(d);
     
345.                 }
     
346.                 else //如何bar数目大于基本周期num个数据，则通过for循环向前加总num个数组除num周期得均线值
     
347.                 {
     
348.                         for (size_t j = 0; j < num ; j++) //循环num次
     
349.                         {
     
350.                                 e = e + pc[i - j]; //从现有bar向左加总num个数据
     
351.                         }
     
352.                         d = e/num;
     
353.                         re.push_back(d);
     
354.                         e = 0;//将e重置成0方便下一个bar继续循环使用
     
355.                 }
     
356.         }
     
357.         return re;
     
358. }
     
359. //macd计算公式开始
     
360. double test::macd(string period, string inst, int num, int num1, int num2)
     
361. {
     
362.         double diff = ema(sPeriod, sInst, num) - ema(sPeriod, sInst, num1);//diff = ema(12)-ema(26);
     
363.         double dea = ema(sPeriod, sInst, num2);//dea
     
364.         return (diff - dea) * 2;
     
365. }
     
366. //自适应移动平均线（Adaptive Exponential Moving Average,AEMA）返回数值模式
     
367. double test::aema(string period, string inst, int num, int pds)//自适应移动平均线（Adaptive Exponential Moving Average, AEMA）
     
368. {
     
369.         //批量声明计算参数
     
370.         int key = 0;
     
371.         double j = num + 1;
     
372.         double mltp1 = 2 / j;//权重系数
     
373.         double mltp2 = 0;
     
374.         double rate = 0;
     
375.         double aema1 = 0;
     
376.         double aema2 = 0;
     
377.         double value2 = -99999;
     
378.         double value3 = 99999;
     
379.         vector<double>aemavector, hs, ls; //声明vector变量容器
     
380.         double a0, a1, a2, a3, a4;//声明计算变量
     
381.         map<string, TKVALUE>::iterator it;
     
382.         for (it = mapK[sPeriod][sInst].begin(); it != mapK[sPeriod][sInst].end(); it++)
     
383.         {
     
384.                 hs.push_back(it->second.dHigh);//将最高价装入vector中
     
385.                 ls.push_back(it->second.dLow); //将最低价装入vector中
     
386.                 a0 = it->second.dClose;
     
387.                 if (key < num)
     
388.                 {
     
389.                         aema1 = aema1 + a0;//收盘价总和
     
390.                         aema2 = aema1 / length;
     
391.                         key++;
     
392.                 }
     
393.                 else
     
394.                 {
     
395.                         for (int i = 0; i < pds; i++) //将近10个周期的bar最高值装入vector
     
396.                         {
     
397.                                 value2 = max2(value2, hs[key - 1 - i]); //遍历最近10个最高价找到最大的那个值放入value2
     
398.                                 value3 = min2(value3, ls[key - 1 - i]);
     
399.                         }
     
400.                         a1 = (a0 - value3);
     
401.                         a2 = (value2 - a0);
     
402.                         a3 = value2 - value3;
     
403.                         a4 = abs(a1 - a2);
     
404.                         if (a3 != 0)mltp2 = a4 / a3;
     
405.                         rate = (1 + mltp2) * mltp1;
     
406.                         aema2 = aema2 + rate * (it->second.dClose - aema2);
     
407.                         key++;
     
408.                 }
     
409.         }
     
410.         return aema2;
     
411. }
     
412. // 求数组容器形式的highest(high, length)
     
413. double test::highestseries(vector<double> pc, int num)
     
414. {
     
415.         double d = 0;
     
416.         for (int i = 0; i < pc.size(); i++)
     
417.         {
     
418.                 if (i >= num)break;
     
419.                 d = max2(d, pc[pc.size() - 1 - i]);
     
420. 
     
421.         }
     
422.         return d;
     
423. }
     
424. //求数组容器形式的lowest(low,length)
     
425. double test::lowestseries(vector<double> pc, int num)
     
426. {
     
427.         double d1 = 999999;
     
428.         for (int i = 0; i < pc.size(); i++)
     
429.         {
     
430.                 if (i >= num)break;
     
431.                 d1 = min2(d1, pc[pc.size() - 1 - i]);
     
432.         }
     
433.         return d1;
     
434. }
     
435. 
     
436. //指数平滑移动平均函数(SMA,sma(x,N,M),即x变量的N周期平均，最新值权重为M，即SMAt = SMAt-1 * (N-M)/N + x*M/N )返回数组形式
     
437. vector<double> test::smaseries(vector<double> pc, int num,int num2)
     
438. {
     
439.         vector<double>smav; //声明一个设计变量容器
     
440.         for (int i = 0; i < pc.size(); i++)
     
441.         {
     
442.                 if (i < num)
     
443.                 {
     
444.                         smav.push_back(pc[i]);
     
445.                 }
     
446.                 else
     
447.                 {
     
448.                         smav.push_back( smav[i-1]* (num - num2) /num  + pc[i]/num);
     
449.                 }
     
450.         }
     
451.         return smav;
     
452. }
     
453. ////////////////////////////////////////////////////////////////////////////////////////////////////////////KDJ公式计算
     
454. //******************************************************************公式(function)模块(结束)*******************************************************************/

复制代码