第七部分、数组基本运算函数运算：加,减,乘,除,移位【参数数组为正序,返回数组也为正序，适合做中间变量计算用】

头文件声明变量：

1.         //第七部分 数组基本运算函数(开始)加,减,乘,除,移位【参数数组为正序,返回数组也为正序】
   
2.         vector<double>SeriesSummation(vector<double> pc, int num); //数组前NUM项元素加总计算(返回数组前NUM项的和,返回的仍然是数组形式)
   
3.         vector<double>SeriesPlusN(vector<double> pc, double num); //数组每一项+N计算(返回所有项+N后的数组，如果N为负值,则为相减)
   
4.         vector<double>SeriestimesN(vector<double> pc, double num); //数组每一项乘N计算(返回所有项乘N后的数组)
   
5.         vector<double>SeriesDivideN(vector<double> pc, double num); //数组每一项除N计算(返回所有项除N后的数组)
   
6.         vector<double>SeriesPlus(vector<double> pc, vector<double> pc2);  //pc[i]+pc2[i](返回两个数组相加后的新数组)
   
7.         vector<double>SeriesMinus(vector<double> pc, vector<double> pc2); //pc[i]-pc2[i](返回两个数组相减后的新数组)
   
8.         vector<double>SeriesTimes(vector<double> pc, vector<double> pc2); //pc[i]*pc2[i](返回两个数组相乘后的新数组)
   
9.         vector<double>SeriesDivide(vector<double> pc, vector<double> pc2);//pc[i]/pc2[i](返回两个数组相除后的新数组)
   
10.         vector<double>SeriesSelfMinus(vector<double> pc, int num); //数组与自己第前NUM项相减(应用场景:momentum计算类及涉及价格处于涨势或跌势,当前价格与第num个价格相减)
    
11.         vector<double>SeriesSelfDivide(vector<double> pc, int num); //数组与自己第前NUM项相除(应用场景:momentum计算类及涉及价格处于涨势或跌势,当前价格与第num个价格相除)
    
12.         vector<double>SeriesForwardref(vector<double> pc, int ref); //数组元素往右移ref位,为保证与原来的数组数目一致，要从最新size()-ref个。)
    
13.         vector<double>SeriesAbs(vector<double> pc); //数组元素进行绝对值计算
    
14.         vector<double>SeriesPowerN(vector<double> pc, int num); //数组元素进行幂函数计算
    
15.         vector<double>Seriessquareroot(vector<double> pc); //数组元素进行开平方计算
    
16.         vector<double>SeriesReciprocal(vector<double> pc); //数组元素取倒数计算
    
17.         vector<double>SeriesNDivide(int num, vector<double> pc); //数值除数组元素各元素计算
    
18.         vector<double>SeriesNegation(vector<double> pc); //数组元素取负计算
    
19.         vector<double>SeriesNMinus(int num, vector<double> pc); //数组元素分别被N减计算
    
20.         //数组基本运算函数(开始)加,减,乘,除,移位【参数数组为正序,返回数组也为正序】

复制代码

公式模块增加：

1. //第七部分 数组基本运算函数(开始)加,减,乘,除,移位【参数数组为正序,返回数组也为正序】
   
2. //数组前NUM项元素加总计算【参数数组为正序,返回数组也为正序】
   
3. vector<double> test::SeriesSummation(vector<double> pc, int num)
   
4. {
   
5.         vector<double> sumvector;//声明一个存储和的容器变量
   
6.         double sum = 0;
   
7.         for (size_t i = 0; i < pc.size(); i++)
   
8.         {
   
9.                 if (i == 0)
   
10.                 {
    
11.                         sumvector.push_back(pc[i]);;
    
12.                 }
    
13.                 else if (i < num) //如果数据数目小于周期要求的最低bar数量
    
14.                 {
    
15.                         sum = 0;
    
16.                         for (size_t j = 0; j < i; j++)
    
17.                         {
    
18.                                 sum = sum + pc[i - j];//前num个数值相加
    
19.                         }
    
20.                         sumvector.push_back(sum); //用简单平均代替并存入容器中
    
21.                 }
    
22.                 else //pc数目大于num周期后正常计算方法
    
23.                 {
    
24.                         sum = 0;//重置加总变量
    
25.                         for (size_t j = 0; j < num; j++)
    
26.                         {
    
27.                                 sum = sum + pc[i - j];//加总从pc[i]往左数num个pc的数值
    
28.                         }
    
29.                         sumvector.push_back(sum);
    
30.                 }
    
31.         }
    
32.        
    
33.         return sumvector;
    
34. }
    
35. //数组所有项元素都乘N(N非0)【参数数组为正序,返回数组也为正序】
    
36. vector<double> test::SeriestimesN(vector<double> pc, double num)
    
37. {
    
38.         vector<double>PcTimesN;
    
39.         for (size_t i = 0; i < pc.size(); i++)
    
40.         {
    
41.                 PcTimesN.push_back(pc[i] * num);
    
42.         }
    
43.         return PcTimesN;
    
44. }
    
45. //数组所有项元素都除N(N非0)【参数数组为正序,返回数组也为正序】
    
46. vector<double> test::SeriesDivideN(vector<double> pc, double num)
    
47. {
    
48.         vector<double>PcDivideN;
    
49.         for (size_t i = 0; i < pc.size(); i++)
    
50.         {
    
51.                 PcDivideN.push_back(pc[i] / num);
    
52.         }
    
53.         return PcDivideN;
    
54. }
    
55. //两个数组的相加函数【参数数组为正序,返回数组也为正序】
    
56. vector<double> test::SeriesPlus(vector<double> pc, vector<double> pc2)
    
57. {
    
58.         //if (pc.size() != pc2.size())return 0;//两个数组中的元素数量必须得相等,否则无法相加
    
59.         vector<double> sumvector;// 声明一个新的数组变量存储和的值
    
60.         for (size_t i = 0; i < pc.size(); i++)
    
61.         {
    
62.                 sumvector.push_back(pc[i] + pc2[i]);
    
63.         }
    
64.         return sumvector;
    
65. }
    
66. //两个数组相减函数【参数数组为正序,返回数组也为正序】
    
67. vector<double> test::SeriesMinus(vector<double> pc, vector<double> pc2)
    
68. {
    
69.         //if (pc.size() != pc2.size())return 0;//两个数组中的元素数量必须得相等,否则无法相减
    
70.         vector<double> minusvector;// 声明一个新的数组变量存储差的值
    
71.         for (size_t i = 0; i < pc.size(); i++)
    
72.         {
    
73.                 minusvector.push_back(pc[i] - pc2[i]);
    
74.         }
    
75.         return minusvector;
    
76. }
    
77. //两个数组内元素相乘【参数数组为正序,返回数组也为正序】
    
78. vector<double> test::SeriesTimes(vector<double> pc, vector<double> pc2)
    
79. {
    
80.         //if (pc.size() != pc2.size())return 0;//两个数组中的元素数量必须得相等,否则无法相乘
    
81.         vector<double> Timesvector;// 声明一个新的数组变量存储积的值
    
82.         for (size_t i = 0; i < pc.size(); i++)
    
83.         {
    
84.                 Timesvector.push_back(pc[i] * pc2[i]);
    
85.         }
    
86.         return Timesvector;
    
87. }
    
88. //两个数组内元素相除【参数数组为正序,返回数组也为正序】
    
89. vector<double> test::SeriesDivide(vector<double> pc, vector<double> pc2)
    
90. {
    
91.         //if (pc.size() != pc2.size())return 0;//两个数组中的元素数量必须得相等,否则无法相除
    
92.         vector<double> Dividevector;// 声明一个新的数组变量存储积的值
    
93.         for (size_t i = 0; i < pc.size(); i++)
    
94.         {
    
95.                 if (pc2[i] == 0)//如果被除数为0时处理方法
    
96.                 {
    
97.                         if (i == 0)//又是第一项
    
98.                         {
    
99.                                 Dividevector.push_back(0);//用0代替
    
100.                         }
     
101.                         else //其它项
     
102.                         {
     
103.                                 Dividevector.push_back(Dividevector[i-1]);//用上一个值代替
     
104.                         }
     
105.                 }
     
106.                 else
     
107.                 {
     
108.                         Dividevector.push_back(pc[i] / pc2[i]);//正常处理
     
109.                 }
     
110.         }
     
111.         return Dividevector;
     
112. }
     
113. //数组与自己第前NUM项相减(应用场景:momentom计算类及涉及价格处于涨势或跌势)【参数数组为正序,返回数组也为正序】
     
114. vector<double> test::SeriesSelfMinus(vector<double> pc, int num)
     
115. {
     
116.         vector<double>self;
     
117.         for (size_t i = 0; i < pc.size(); i++)
     
118.         {
     
119.                 if (i < num)//数据不够时
     
120.                 {
     
121.                         self.push_back((int)0);// 用0代替
     
122.                 }
     
123.                 else//数据量足够时
     
124.                 {
     
125.                         self.push_back(pc[i] - pc[i - num]);
     
126.                 }
     
127.         }
     
128.         return self;
     
129. }
     
130. //数组与自己第前NUM项相除(应用场景:momentom计算类及涉及价格处于涨势或跌势)与相减相比此处为比率形式【参数数组为正序,返回数组也为正序】
     
131. vector<double> test::SeriesSelfDivide(vector<double> pc, int num)
     
132. {
     
133.         vector<double>self;
     
134.         for (size_t i = 0; i < pc.size(); i++)
     
135.         {
     
136.                 if (i < num)//数据不够时
     
137.                 {
     
138.                         self.push_back((int)0);// 用0代替
     
139.                 }
     
140.                 else//数据量足够时
     
141.                 {
     
142.                         if (pc[i - num] == 0)//如果[i - num]项数值为0时，即除数为0时处理方法
     
143.                         {
     
144.                                 self.push_back(pc[i - num - 1]);// 用前一项代替
     
145.                         }
     
146.                         else //正常状态下
     
147.                         {
     
148.                                 self.push_back(pc[i] / pc[i - num]);//正常两个数值相除
     
149.                         }
     
150.                 }
     
151.         }
     
152.         return self;
     
153. }
     
154. 
     
155. //Vctor数组元素往右挪N位【参数数组为正序,返回数组也为正序】
     
156. vector<double> test::SeriesForwardref(vector<double> pc, int ref)
     
157. {
     
158.         vector<double>newself;
     
159.         for (size_t i = 0; i < pc.size(); i++) //因为前ref项已经单独设置为0,为了保证后面使用过程中数组元素数量相同,最新的ref项我们删除不使用
     
160.         {
     
161. 
     
162.                 if (i < ref)//当循环项为小于右移的项数时
     
163.                 {
     
164.                         newself.push_back((int)0);//前ref项都设置为0
     
165.                 }
     
166.                 else
     
167.                 {
     
168.                         newself.push_back(pc[i - ref]);//将pc第i项数据pc[i]存入newself[i+1]项中
     
169.                 }
     
170.         }
     
171. 
     
172.         return newself;// 返回新的数组,因为前面加了ref项,后面减了ref项,所以新的数组与原来的数组数量是一致的
     
173. }
     
174. //Vctor数组元素取绝对值【参数数组为正序,返回数组也为正序】
     
175. vector<double> test::SeriesAbs(vector<double> pc)
     
176. {
     
177.         vector<double>absvevctor;
     
178.         for (size_t i = 0; i < pc.size(); i++)
     
179.         {
     
180.                 absvevctor.push_back(abs(pc[i]));
     
181.         }
     
182.         return absvevctor;
     
183. }
     
184. //Vector幂次方数组计算【参数数组为正序,返回数组也为正序】
     
185. vector<double> test::SeriesPowerN(vector<double> pc, int num)
     
186. {
     
187.         vector<double>newvector;//声明新变量容器
     
188.         for (size_t i = 0; i < pc.size(); i++)
     
189.         {
     
190.                 newvector.push_back(pow(pc[i], num));//pow(x,y)
     
191.         }
     
192.         return newvector;
     
193. }
     
194. //平方根计算【参数数组为正序,返回数组也为正序】
     
195. vector<double> test::Seriessquareroot(vector<double> pc)
     
196. {
     
197.         vector<double>vector1;//中间变量,临时存储数组
     
198.         for (size_t i = 0; i < pc.size(); i++)
     
199.         {
     
200.                 vector1.push_back(sqrt(pc[i]));
     
201.         }
     
202.         return vector1;
     
203. }
     
204. vector<double> test::SeriesReciprocal(vector<double> pc)
     
205. {
     
206.         vector<double>newvector;
     
207.         for (size_t i = 0; i < pc.size(); i++)
     
208.         {
     
209.                 if (i == 0) //第一个元素代替为pc[0]
     
210.                 {
     
211.                         newvector.push_back(pc[i]);
     
212.                 }
     
213.                 else //中间元素处理方法
     
214.                 {
     
215.                         if (pc[i] == 0)newvector.push_back(newvector[i - 1]);//若是pc[i] = 0 则用前一值(newvector[i-1])代替
     
216.                         if (pc[i] != 0)newvector.push_back(1 / pc[i]);//若是pc[i] != 0 则 用1除pc[i]值即可
     
217.                 }
     
218.         }
     
219.         return newvector;
     
220. }
     
221. //数值除数组元素各元素计算【参数数组为正序,返回数组也为正序】
     
222. vector<double> test::SeriesNDivide(int num, vector<double> pc)
     
223. {
     
224.         vector<double>newvector;
     
225.         for (size_t i = 0; i < pc.size(); i++)
     
226.         {
     
227.                 newvector.push_back(num / pc[i]);
     
228.         }
     
229.         return newvector;
     
230. }
     
231. //数组元素取负计算【参数数组为正序,返回数组也为正序】
     
232. vector<double> test::SeriesNegation(vector<double> pc)
     
233. {
     
234.         vector<double>newvector2;
     
235.         for (size_t i = 0; i < pc.size(); i++)
     
236.         {
     
237.                 newvector2.push_back(-(pc[i]));
     
238.         }
     
239.         return newvector2;
     
240. }
     
241. //数组元素分别被N减计算【参数数组为正序,返回数组也为正序】
     
242. vector<double> test::SeriesNMinus(int num, vector<double> pc)
     
243. {
     
244.         vector<double>newvector;
     
245.         for (size_t i = 0; i < pc.size(); i++)
     
246.         {
     
247.                 newvector.push_back(num - pc[i]);
     
248.         }
     
249.         return newvector;
     
250. }
     
251. //第七部分 数组基本运算函数(开始)加,减,乘,除,移位【参数数组为正序,返回数组也为正序】

复制代码