Code Coverage for P:\Projects\PHP\phpTraderNative\source/TALib/Core/MomentumIndicators.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 30	CRAP	74.64% covered (warning)	74.64%	1451 / 1944
LupeCode\phpTraderNative\TALib\Core\MomentumIndicators	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 30	6308.04	74.64% covered (warning)	74.64%	1451 / 1944
adx				0.00% covered (danger)	0.00%	0 / 1	80.79	75.18% covered (warning)	75.18%	106 / 141
adxr				0.00% covered (danger)	0.00%	0 / 1	10.58	73.08% covered (warning)	73.08%	19 / 26
apo				0.00% covered (danger)	0.00%	0 / 1	11.64	61.54% covered (warning)	61.54%	8 / 13
aroon				0.00% covered (danger)	0.00%	0 / 1	16.33	89.09% covered (warning)	89.09%	49 / 55
aroonOsc				0.00% covered (danger)	0.00%	0 / 1	16.33	89.09% covered (warning)	89.09%	49 / 55
bop				0.00% covered (danger)	0.00%	0 / 1	4.10	81.82% covered (warning)	81.82%	9 / 11
cci				0.00% covered (danger)	0.00%	0 / 1	18.91	81.25% covered (warning)	81.25%	39 / 48
cmo				0.00% covered (danger)	0.00%	0 / 1	97.85	52.63% covered (warning)	52.63%	50 / 95
dx				0.00% covered (danger)	0.00%	0 / 1	39.08	88.50% covered (warning)	88.50%	100 / 113
macd				0.00% covered (danger)	0.00%	0 / 1	14.00	70.83% covered (warning)	70.83%	17 / 24
macdExt				0.00% covered (danger)	0.00%	0 / 1	46.93	65.85% covered (warning)	65.85%	54 / 82
macdFix				0.00% covered (danger)	0.00%	0 / 1	5.16	81.25% covered (warning)	81.25%	13 / 16
mfi				0.00% covered (danger)	0.00%	0 / 1	39.39	70.10% covered (warning)	70.10%	68 / 97
minusDI				0.00% covered (danger)	0.00%	0 / 1	78.18	67.21% covered (warning)	67.21%	82 / 122
minusDM				0.00% covered (danger)	0.00%	0 / 1	25.57	78.21% covered (warning)	78.21%	61 / 78
mom				0.00% covered (danger)	0.00%	0 / 1	9.73	70.00% covered (warning)	70.00%	14 / 20
plusDI				0.00% covered (danger)	0.00%	0 / 1	78.18	67.21% covered (warning)	67.21%	82 / 122
plusDM				0.00% covered (danger)	0.00%	0 / 1	57.53	56.41% covered (warning)	56.41%	44 / 78
ppo				0.00% covered (danger)	0.00%	0 / 1	8.66	78.26% covered (warning)	78.26%	18 / 23
roc				0.00% covered (danger)	0.00%	0 / 1	11.01	70.83% covered (warning)	70.83%	17 / 24
rocP				0.00% covered (danger)	0.00%	0 / 1	11.01	70.83% covered (warning)	70.83%	17 / 24
rocR				0.00% covered (danger)	0.00%	0 / 1	11.01	70.83% covered (warning)	70.83%	17 / 24
rocR100				0.00% covered (danger)	0.00%	0 / 1	11.01	70.83% covered (warning)	70.83%	17 / 24
rsi				0.00% covered (danger)	0.00%	0 / 1	95.33	53.19% covered (warning)	53.19%	50 / 94
stoch				0.00% covered (danger)	0.00%	0 / 1	40.19	80.00% covered (warning)	80.00%	76 / 95
stochF				0.00% covered (danger)	0.00%	0 / 1	34.61	81.18% covered (warning)	81.18%	69 / 85
stochRsi				0.00% covered (danger)	0.00%	0 / 1	22.48	73.33% covered (warning)	73.33%	44 / 60
trix				0.00% covered (danger)	0.00%	0 / 1	20.51	70.97% covered (warning)	70.97%	44 / 62
ultOsc				0.00% covered (danger)	0.00%	0 / 1	48	95.43% covered (success)	95.43%	167 / 175
willR				0.00% covered (danger)	0.00%	0 / 1	17.51	87.93% covered (warning)	87.93%	51 / 58

1	<?php
2
3	/**
4	* This is a PHP port of the Trader extension for PHP, which is a port of the TA-LIB C code.
5	*
6	* This port is written in PHP and without any other requirements.
7	* The goal is that this library can be used by those whom cannot install the PHP Trader extension.
8	*
9	* Below is the copyright information for TA-LIB found in the source code.
10	*/
11
12	/* TA-LIB Copyright (c) 1999-2007, Mario Fortier
13	* All rights reserved.
14	*
15	* Redistribution and use in source and binary forms, with or
16	* without modification, are permitted provided that the following
17	* conditions are met:
18	*
19	* - Redistributions of source code must retain the above copyright
20	* notice, this list of conditions and the following disclaimer.
21	*
22	* - Redistributions in binary form must reproduce the above copyright
23	* notice, this list of conditions and the following disclaimer in
24	* the documentation and/or other materials provided with the
25	* distribution.
26	*
27	* - Neither name of author nor the names of its contributors
28	* may be used to endorse or promote products derived from this
29	* software without specific prior written permission.
30	*
31	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
34	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
35	* REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
36	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
37	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
39	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
40	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
41	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
42	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43	*/
44
45	namespace LupeCode\phpTraderNative\TALib\Core;
46
47	use LupeCode\phpTraderNative\TALib\Classes\MoneyFlow;
48	use LupeCode\phpTraderNative\TALib\Enum\Compatibility;
49	use LupeCode\phpTraderNative\TALib\Enum\ReturnCode;
50	use LupeCode\phpTraderNative\TALib\Enum\UnstablePeriodFunctionID;
51
52	class MomentumIndicators extends Core
53	{
54	/**
55	* @param int $startIdx
56	* @param int $endIdx
57	* @param float[] $inHigh
58	* @param float[] $inLow
59	* @param float[] $inClose
60	* @param int $optInTimePeriod
61	* @param int $outBegIdx
62	* @param int $outNBElement
63	* @param float[] $outReal
64	*
65	* @return int
66	*/
67	public static function adx(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
68	{
69	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
70	return $RetCode;
71	}
72	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
73	$optInTimePeriod = 14;
74	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
75	return ReturnCode::BadParam;
76	}
77	$lookbackTotal = (2 * $optInTimePeriod) + (static::$unstablePeriod[UnstablePeriodFunctionID::ADX]) - 1;
78	if ($startIdx < $lookbackTotal) {
79	$startIdx = $lookbackTotal;
80	}
81	if ($startIdx > $endIdx) {
82	$outBegIdx = 0;
83	$outNBElement = 0;
84
85	return ReturnCode::Success;
86	}
87	$outBegIdx = $today = $startIdx;
88	$prevMinusDM = 0.0;
89	$prevPlusDM = 0.0;
90	$prevTR = 0.0;
91	$today = $startIdx - $lookbackTotal;
92	$prevHigh = $inHigh[$today];
93	$prevLow = $inLow[$today];
94	$prevClose = $inClose[$today];
95	$i = $optInTimePeriod - 1;
96	while ($i-- > 0) {
97	$today++;
98	$tempReal = $inHigh[$today];
99	$diffP = $tempReal - $prevHigh;
100	$prevHigh = $tempReal;
101	$tempReal = $inLow[$today];
102	$diffM = $prevLow - $tempReal;
103	$prevLow = $tempReal;
104	if (($diffM > 0) && ($diffP < $diffM)) {
105	$prevMinusDM += $diffM;
106	} elseif (($diffP > 0) && ($diffP > $diffM)) {
107	$prevPlusDM += $diffP;
108	}
109	{
110	$tempReal = $prevHigh - $prevLow;
111	$tempReal2 = abs($prevHigh - $prevClose);
112	if ($tempReal2 > $tempReal) {
113	$tempReal = $tempReal2;
114	}
115	$tempReal2 = abs($prevLow - $prevClose);
116	if ($tempReal2 > $tempReal) {
117	$tempReal = $tempReal2;
118	}
119	};
120	$prevTR += $tempReal;
121	$prevClose = $inClose[$today];
122	}
123	$sumDX = 0.0;
124	$i = $optInTimePeriod;
125	while ($i-- > 0) {
126	$today++;
127	$tempReal = $inHigh[$today];
128	$diffP = $tempReal - $prevHigh;
129	$prevHigh = $tempReal;
130	$tempReal = $inLow[$today];
131	$diffM = $prevLow - $tempReal;
132	$prevLow = $tempReal;
133	$prevMinusDM -= $prevMinusDM / $optInTimePeriod;
134	$prevPlusDM -= $prevPlusDM / $optInTimePeriod;
135	if (($diffM > 0) && ($diffP < $diffM)) {
136	$prevMinusDM += $diffM;
137	} elseif (($diffP > 0) && ($diffP > $diffM)) {
138	$prevPlusDM += $diffP;
139	}
140	{
141	$tempReal = $prevHigh - $prevLow;
142	$tempReal2 = abs($prevHigh - $prevClose);
143	if ($tempReal2 > $tempReal) {
144	$tempReal = $tempReal2;
145	}
146	$tempReal2 = abs($prevLow - $prevClose);
147	if ($tempReal2 > $tempReal) {
148	$tempReal = $tempReal2;
149	}
150	};
151	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
152	$prevClose = $inClose[$today];
153	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
154	$minusDI = (100.0 * ($prevMinusDM / $prevTR));
155	$plusDI = (100.0 * ($prevPlusDM / $prevTR));
156	$tempReal = $minusDI + $plusDI;
157	if (!(((-0.00000001) < $tempReal) && ($tempReal < 0.00000001))) {
158	$sumDX += (100.0 * (abs($minusDI - $plusDI) / $tempReal));
159	}
160	}
161	}
162	$prevADX = ($sumDX / $optInTimePeriod);
163	$i = (static::$unstablePeriod[UnstablePeriodFunctionID::ADX]);
164	while ($i-- > 0) {
165	$today++;
166	$tempReal = $inHigh[$today];
167	$diffP = $tempReal - $prevHigh;
168	$prevHigh = $tempReal;
169	$tempReal = $inLow[$today];
170	$diffM = $prevLow - $tempReal;
171	$prevLow = $tempReal;
172	$prevMinusDM -= $prevMinusDM / $optInTimePeriod;
173	$prevPlusDM -= $prevPlusDM / $optInTimePeriod;
174	if (($diffM > 0) && ($diffP < $diffM)) {
175	$prevMinusDM += $diffM;
176	} elseif (($diffP > 0) && ($diffP > $diffM)) {
177	$prevPlusDM += $diffP;
178	}
179	{
180	$tempReal = $prevHigh - $prevLow;
181	$tempReal2 = abs($prevHigh - $prevClose);
182	if ($tempReal2 > $tempReal) {
183	$tempReal = $tempReal2;
184	}
185	$tempReal2 = abs($prevLow - $prevClose);
186	if ($tempReal2 > $tempReal) {
187	$tempReal = $tempReal2;
188	}
189	};
190	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
191	$prevClose = $inClose[$today];
192	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
193	$minusDI = (100.0 * ($prevMinusDM / $prevTR));
194	$plusDI = (100.0 * ($prevPlusDM / $prevTR));
195	$tempReal = $minusDI + $plusDI;
196	if (!(((-0.00000001) < $tempReal) && ($tempReal < 0.00000001))) {
197	$tempReal = (100.0 * (abs($minusDI - $plusDI) / $tempReal));
198	$prevADX = ((($prevADX * ($optInTimePeriod - 1)) + $tempReal) / $optInTimePeriod);
199	}
200	}
201	}
202	$outReal[0] = $prevADX;
203	$outIdx = 1;
204	while ($today < $endIdx) {
205	$today++;
206	$tempReal = $inHigh[$today];
207	$diffP = $tempReal - $prevHigh;
208	$prevHigh = $tempReal;
209	$tempReal = $inLow[$today];
210	$diffM = $prevLow - $tempReal;
211	$prevLow = $tempReal;
212	$prevMinusDM -= $prevMinusDM / $optInTimePeriod;
213	$prevPlusDM -= $prevPlusDM / $optInTimePeriod;
214	if (($diffM > 0) && ($diffP < $diffM)) {
215	$prevMinusDM += $diffM;
216	} elseif (($diffP > 0) && ($diffP > $diffM)) {
217	$prevPlusDM += $diffP;
218	}
219	{
220	$tempReal = $prevHigh - $prevLow;
221	$tempReal2 = abs($prevHigh - $prevClose);
222	if ($tempReal2 > $tempReal) {
223	$tempReal = $tempReal2;
224	}
225	$tempReal2 = abs($prevLow - $prevClose);
226	if ($tempReal2 > $tempReal) {
227	$tempReal = $tempReal2;
228	}
229	};
230	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
231	$prevClose = $inClose[$today];
232	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
233	$minusDI = (100.0 * ($prevMinusDM / $prevTR));
234	$plusDI = (100.0 * ($prevPlusDM / $prevTR));
235	$tempReal = $minusDI + $plusDI;
236	if (!(((-0.00000001) < $tempReal) && ($tempReal < 0.00000001))) {
237	$tempReal = (100.0 * (abs($minusDI - $plusDI) / $tempReal));
238	$prevADX = ((($prevADX * ($optInTimePeriod - 1)) + $tempReal) / $optInTimePeriod);
239	}
240	}
241	$outReal[$outIdx++] = $prevADX;
242	}
243	$outNBElement = $outIdx;
244
245	return ReturnCode::Success;
246	}
247
248	/**
249	* @param int $startIdx
250	* @param int $endIdx
251	* @param float[] $inHigh
252	* @param float[] $inLow
253	* @param float[] $inClose
254	* @param int $optInTimePeriod
255	* @param int $outBegIdx
256	* @param int $outNBElement
257	* @param float[] $outReal
258	*
259	* @return int
260	*/
261	public static function adxr(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
262	{
263	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
264	return $RetCode;
265	}
266	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
267	$optInTimePeriod = 14;
268	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
269	return ReturnCode::BadParam;
270	}
271	$adxrLookback = Lookback::adxrLookback($optInTimePeriod);
272	if ($startIdx < $adxrLookback) {
273	$startIdx = $adxrLookback;
274	}
275	if ($startIdx > $endIdx) {
276	$outBegIdx = 0;
277	$outNBElement = 0;
278
279	return ReturnCode::Success;
280	}
281	$adx = static::double($endIdx - $startIdx + $optInTimePeriod);
282	$ReturnCode = self::adx($startIdx - ($optInTimePeriod - 1), $endIdx, $inHigh, $inLow, $inClose, $optInTimePeriod, $outBegIdx, $outNBElement, $adx);
283	if ($ReturnCode != ReturnCode::Success) {
284	return $ReturnCode;
285	}
286	$i = $optInTimePeriod - 1;
287	$j = 0;
288	$outIdx = 0;
289	$nbElement = $endIdx - $startIdx + 2;
290	while (--$nbElement != 0) {
291	$outReal[$outIdx++] = (($adx[$i++] + $adx[$j++]) / 2.0);
292	}
293	$outBegIdx = $startIdx;
294	$outNBElement = $outIdx;
295
296	return ReturnCode::Success;
297	}
298
299	/**
300	* @param int $startIdx
301	* @param int $endIdx
302	* @param float[] $inReal
303	* @param int $optInFastPeriod
304	* @param int $optInSlowPeriod
305	* @param int $optInMAType
306	* @param int $outBegIdx
307	* @param int $outNBElement
308	* @param float[] $outReal
309	*
310	* @return int
311	*/
312	public static function apo(int $startIdx, int $endIdx, array $inReal, int $optInFastPeriod, int $optInSlowPeriod, int $optInMAType, int &$outBegIdx, int &$outNBElement, array &$outReal): int
313	{
314	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
315	return $RetCode;
316	}
317	if ((int)$optInFastPeriod == (PHP_INT_MIN)) {
318	$optInFastPeriod = 12;
319	} elseif (((int)$optInFastPeriod < 2) \|\| ((int)$optInFastPeriod > 100000)) {
320	return ReturnCode::BadParam;
321	}
322	if ((int)$optInSlowPeriod == (PHP_INT_MIN)) {
323	$optInSlowPeriod = 26;
324	} elseif (((int)$optInSlowPeriod < 2) \|\| ((int)$optInSlowPeriod > 100000)) {
325	return ReturnCode::BadParam;
326	}
327	$tempBuffer = static::double($endIdx - $startIdx + 1);
328	$ReturnCode = static::TA_INT_PO($startIdx, $endIdx, $inReal, $optInFastPeriod, $optInSlowPeriod, $optInMAType, $outBegIdx, $outNBElement, $outReal, $tempBuffer, false);
329
330	return $ReturnCode;
331	}
332
333	/**
334	* @param int $startIdx
335	* @param int $endIdx
336	* @param float[] $inHigh
337	* @param float[] $inLow
338	* @param int $optInTimePeriod
339	* @param int $outBegIdx
340	* @param int $outNBElement
341	* @param float[] $outAroonDown
342	* @param float[] $outAroonUp
343	*
344	* @return int
345	*/
346	public static function aroon(int $startIdx, int $endIdx, array $inHigh, array $inLow, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outAroonDown, array &$outAroonUp): int
347	{
348	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
349	return $RetCode;
350	}
351	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
352	$optInTimePeriod = 14;
353	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
354	return ReturnCode::BadParam;
355	}
356	if ($startIdx < $optInTimePeriod) {
357	$startIdx = $optInTimePeriod;
358	}
359	if ($startIdx > $endIdx) {
360	$outBegIdx = 0;
361	$outNBElement = 0;
362
363	return ReturnCode::Success;
364	}
365	$outIdx = 0;
366	$today = $startIdx;
367	$trailingIdx = $startIdx - $optInTimePeriod;
368	$lowestIdx = -1;
369	$highestIdx = -1;
370	$lowest = 0.0;
371	$highest = 0.0;
372	$factor = (double)100.0 / (double)$optInTimePeriod;
373	while ($today <= $endIdx) {
374	$tmp = $inLow[$today];
375	if ($lowestIdx < $trailingIdx) {
376	$lowestIdx = $trailingIdx;
377	$lowest = $inLow[$lowestIdx];
378	$i = $lowestIdx;
379	while (++$i <= $today) {
380	$tmp = $inLow[$i];
381	if ($tmp <= $lowest) {
382	$lowestIdx = $i;
383	$lowest = $tmp;
384	}
385	}
386	} elseif ($tmp <= $lowest) {
387	$lowestIdx = $today;
388	$lowest = $tmp;
389	}
390	$tmp = $inHigh[$today];
391	if ($highestIdx < $trailingIdx) {
392	$highestIdx = $trailingIdx;
393	$highest = $inHigh[$highestIdx];
394	$i = $highestIdx;
395	while (++$i <= $today) {
396	$tmp = $inHigh[$i];
397	if ($tmp >= $highest) {
398	$highestIdx = $i;
399	$highest = $tmp;
400	}
401	}
402	} elseif ($tmp >= $highest) {
403	$highestIdx = $today;
404	$highest = $tmp;
405	}
406	$outAroonUp[$outIdx] = $factor * ($optInTimePeriod - ($today - $highestIdx));
407	$outAroonDown[$outIdx] = $factor * ($optInTimePeriod - ($today - $lowestIdx));
408	$outIdx++;
409	$trailingIdx++;
410	$today++;
411	}
412	$outBegIdx = $startIdx;
413	$outNBElement = $outIdx;
414
415	return ReturnCode::Success;
416	}
417
418	/**
419	* @param int $startIdx
420	* @param int $endIdx
421	* @param float[] $inHigh
422	* @param float[] $inLow
423	* @param int $optInTimePeriod
424	* @param int $outBegIdx
425	* @param int $outNBElement
426	* @param float[] $outReal
427	*
428	* @return int
429	*/
430	public static function aroonOsc(int $startIdx, int $endIdx, array $inHigh, array $inLow, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
431	{
432	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
433	return $RetCode;
434	}
435	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
436	$optInTimePeriod = 14;
437	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
438	return ReturnCode::BadParam;
439	}
440	if ($startIdx < $optInTimePeriod) {
441	$startIdx = $optInTimePeriod;
442	}
443	if ($startIdx > $endIdx) {
444	$outBegIdx = 0;
445	$outNBElement = 0;
446
447	return ReturnCode::Success;
448	}
449	$outIdx = 0;
450	$today = $startIdx;
451	$trailingIdx = $startIdx - $optInTimePeriod;
452	$lowestIdx = -1;
453	$highestIdx = -1;
454	$lowest = 0.0;
455	$highest = 0.0;
456	$factor = (double)100.0 / (double)$optInTimePeriod;
457	while ($today <= $endIdx) {
458	$tmp = $inLow[$today];
459	if ($lowestIdx < $trailingIdx) {
460	$lowestIdx = $trailingIdx;
461	$lowest = $inLow[$lowestIdx];
462	$i = $lowestIdx;
463	while (++$i <= $today) {
464	$tmp = $inLow[$i];
465	if ($tmp <= $lowest) {
466	$lowestIdx = $i;
467	$lowest = $tmp;
468	}
469	}
470	} elseif ($tmp <= $lowest) {
471	$lowestIdx = $today;
472	$lowest = $tmp;
473	}
474	$tmp = $inHigh[$today];
475	if ($highestIdx < $trailingIdx) {
476	$highestIdx = $trailingIdx;
477	$highest = $inHigh[$highestIdx];
478	$i = $highestIdx;
479	while (++$i <= $today) {
480	$tmp = $inHigh[$i];
481	if ($tmp >= $highest) {
482	$highestIdx = $i;
483	$highest = $tmp;
484	}
485	}
486	} elseif ($tmp >= $highest) {
487	$highestIdx = $today;
488	$highest = $tmp;
489	}
490	$aroon = $factor * ($highestIdx - $lowestIdx);
491	$outReal[$outIdx] = $aroon;
492	$outIdx++;
493	$trailingIdx++;
494	$today++;
495	}
496	$outBegIdx = $startIdx;
497	$outNBElement = $outIdx;
498
499	return ReturnCode::Success;
500	}
501
502	/**
503	* @param int $startIdx
504	* @param int $endIdx
505	* @param float[] $inOpen
506	* @param float[] $inHigh
507	* @param float[] $inLow
508	* @param float[] $inClose
509	* @param int $outBegIdx
510	* @param int $outNBElement
511	* @param float[] $outReal
512	*
513	* @return int
514	*/
515	public static function bop(int $startIdx, int $endIdx, array $inOpen, array $inHigh, array $inLow, array $inClose, int &$outBegIdx, int &$outNBElement, array &$outReal): int
516	{
517	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
518	return $RetCode;
519	}
520	$outIdx = 0;
521	for ($i = $startIdx; $i <= $endIdx; $i++) {
522	$tempReal = $inHigh[$i] - $inLow[$i];
523	if (($tempReal < 0.00000001)) {
524	$outReal[$outIdx++] = 0.0;
525	} else {
526	$outReal[$outIdx++] = ($inClose[$i] - $inOpen[$i]) / $tempReal;
527	}
528	}
529	$outNBElement = $outIdx;
530	$outBegIdx = $startIdx;
531
532	return ReturnCode::Success;
533	}
534
535	/**
536	* @param int $startIdx
537	* @param int $endIdx
538	* @param float[] $inHigh
539	* @param float[] $inLow
540	* @param float[] $inClose
541	* @param int $optInTimePeriod
542	* @param int $outBegIdx
543	* @param int $outNBElement
544	* @param float[] $outReal
545	*
546	* @return int
547	*/
548	public static function cci(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
549	{
550	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
551	return $RetCode;
552	}
553	$circBuffer_Idx = 0;
554	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
555	$optInTimePeriod = 14;
556	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
557	return ReturnCode::BadParam;
558	}
559	$lookbackTotal = ($optInTimePeriod - 1);
560	if ($startIdx < $lookbackTotal) {
561	$startIdx = $lookbackTotal;
562	}
563	if ($startIdx > $endIdx) {
564	$outBegIdx = 0;
565	$outNBElement = 0;
566
567	return ReturnCode::Success;
568	}
569	{
570	if ($optInTimePeriod <= 0) {
571	return ReturnCode::AllocError;
572	}
573	$circBuffer = static::double($optInTimePeriod);
574	$maxIdx_circBuffer = ($optInTimePeriod - 1);
575	};
576	$i = $startIdx - $lookbackTotal;
577	if ($optInTimePeriod > 1) {
578	while ($i < $startIdx) {
579	$circBuffer[$circBuffer_Idx] = ($inHigh[$i] + $inLow[$i] + $inClose[$i]) / 3;
580	$i++;
581	{
582	$circBuffer_Idx++;
583	if ($circBuffer_Idx > $maxIdx_circBuffer) {
584	$circBuffer_Idx = 0;
585	}
586	};
587	}
588	}
589	$outIdx = 0;
590	do {
591	$lastValue = ($inHigh[$i] + $inLow[$i] + $inClose[$i]) / 3;
592	$circBuffer[$circBuffer_Idx] = $lastValue;
593	$theAverage = 0;
594	for ($j = 0; $j < $optInTimePeriod; $j++) {
595	$theAverage += $circBuffer[$j];
596	}
597	$theAverage /= $optInTimePeriod;
598	$tempReal2 = 0;
599	for ($j = 0; $j < $optInTimePeriod; $j++) {
600	$tempReal2 += abs($circBuffer[$j] - $theAverage);
601	}
602	$tempReal = $lastValue - $theAverage;
603	if (($tempReal != 0.0) && ($tempReal2 != 0.0)) {
604	$outReal[$outIdx++] = $tempReal / (0.015 * ($tempReal2 / $optInTimePeriod));
605	} else {
606	$outReal[$outIdx++] = 0.0;
607	}
608	{
609	$circBuffer_Idx++;
610	if ($circBuffer_Idx > $maxIdx_circBuffer) {
611	$circBuffer_Idx = 0;
612	}
613	};
614	$i++;
615	} while ($i <= $endIdx);
616	$outNBElement = $outIdx;
617	$outBegIdx = $startIdx;
618
619	return ReturnCode::Success;
620	}
621
622	/**
623	* @param int $startIdx
624	* @param int $endIdx
625	* @param array $inReal
626	* @param int $optInTimePeriod
627	* @param int $outBegIdx
628	* @param int $outNBElement
629	* @param array $outReal
630	*
631	* @return int
632	*/
633	public static function cmo(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
634	{
635	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
636	return $RetCode;
637	}
638	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
639	$optInTimePeriod = 14;
640	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
641	return ReturnCode::BadParam;
642	}
643	$outBegIdx = 0;
644	$outNBElement = 0;
645	$lookbackTotal = Lookback::cmoLookback($optInTimePeriod);
646	if ($startIdx < $lookbackTotal) {
647	$startIdx = $lookbackTotal;
648	}
649	if ($startIdx > $endIdx) {
650	return ReturnCode::Success;
651	}
652	$outIdx = 0;
653	if ($optInTimePeriod == 1) {
654	$outBegIdx = $startIdx;
655	$i = ($endIdx - $startIdx) + 1;
656	$outNBElement = $i;
657	$outReal = \array_slice($inReal, 0, $i);
658
659	return ReturnCode::Success;
660	}
661	$today = $startIdx - $lookbackTotal;
662	$prevValue = $inReal[$today];
663	$unstablePeriod = (static::$unstablePeriod[UnstablePeriodFunctionID::CMO]);
664	if (($unstablePeriod == 0) &&
665	((static::$compatibility) == Compatibility::Metastock)) {
666	$savePrevValue = $prevValue;
667	$prevGain = 0.0;
668	$prevLoss = 0.0;
669	for ($i = $optInTimePeriod; $i > 0; $i--) {
670	$tempValue1 = $inReal[$today++];
671	$tempValue2 = $tempValue1 - $prevValue;
672	$prevValue = $tempValue1;
673	if ($tempValue2 < 0) {
674	$prevLoss -= $tempValue2;
675	} else {
676	$prevGain += $tempValue2;
677	}
678	}
679	$tempValue1 = $prevLoss / $optInTimePeriod;
680	$tempValue2 = $prevGain / $optInTimePeriod;
681	$tempValue3 = $tempValue2 - $tempValue1;
682	$tempValue4 = $tempValue1 + $tempValue2;
683	if (!(((-0.00000001) < $tempValue4) && ($tempValue4 < 0.00000001))) {
684	$outReal[$outIdx++] = 100 * ($tempValue3 / $tempValue4);
685	} else {
686	$outReal[$outIdx++] = 0.0;
687	}
688	if ($today > $endIdx) {
689	$outBegIdx = $startIdx;
690	$outNBElement = $outIdx;
691
692	return ReturnCode::Success;
693	}
694	$today -= $optInTimePeriod;
695	$prevValue = $savePrevValue;
696	}
697	$prevGain = 0.0;
698	$prevLoss = 0.0;
699	$today++;
700	for ($i = $optInTimePeriod; $i > 0; $i--) {
701	$tempValue1 = $inReal[$today++];
702	$tempValue2 = $tempValue1 - $prevValue;
703	$prevValue = $tempValue1;
704	if ($tempValue2 < 0) {
705	$prevLoss -= $tempValue2;
706	} else {
707	$prevGain += $tempValue2;
708	}
709	}
710	$prevLoss /= $optInTimePeriod;
711	$prevGain /= $optInTimePeriod;
712	if ($today > $startIdx) {
713	$tempValue1 = $prevGain + $prevLoss;
714	if (!(((-0.00000001) < $tempValue1) && ($tempValue1 < 0.00000001))) {
715	$outReal[$outIdx++] = 100.0 * (($prevGain - $prevLoss) / $tempValue1);
716	} else {
717	$outReal[$outIdx++] = 0.0;
718	}
719	} else {
720	while ($today < $startIdx) {
721	$tempValue1 = $inReal[$today];
722	$tempValue2 = $tempValue1 - $prevValue;
723	$prevValue = $tempValue1;
724	$prevLoss *= ($optInTimePeriod - 1);
725	$prevGain *= ($optInTimePeriod - 1);
726	if ($tempValue2 < 0) {
727	$prevLoss -= $tempValue2;
728	} else {
729	$prevGain += $tempValue2;
730	}
731	$prevLoss /= $optInTimePeriod;
732	$prevGain /= $optInTimePeriod;
733	$today++;
734	}
735	}
736	while ($today <= $endIdx) {
737	$tempValue1 = $inReal[$today++];
738	$tempValue2 = $tempValue1 - $prevValue;
739	$prevValue = $tempValue1;
740	$prevLoss *= ($optInTimePeriod - 1);
741	$prevGain *= ($optInTimePeriod - 1);
742	if ($tempValue2 < 0) {
743	$prevLoss -= $tempValue2;
744	} else {
745	$prevGain += $tempValue2;
746	}
747	$prevLoss /= $optInTimePeriod;
748	$prevGain /= $optInTimePeriod;
749	$tempValue1 = $prevGain + $prevLoss;
750	if (!(((-0.00000001) < $tempValue1) && ($tempValue1 < 0.00000001))) {
751	$outReal[$outIdx++] = 100.0 * (($prevGain - $prevLoss) / $tempValue1);
752	} else {
753	$outReal[$outIdx++] = 0.0;
754	}
755	}
756	$outBegIdx = $startIdx;
757	$outNBElement = $outIdx;
758
759	return ReturnCode::Success;
760	}
761
762	/**
763	* @param int $startIdx
764	* @param int $endIdx
765	* @param array $inHigh
766	* @param array $inLow
767	* @param array $inClose
768	* @param int $optInTimePeriod
769	* @param int $outBegIdx
770	* @param int $outNBElement
771	* @param array $outReal
772	*
773	* @return int
774	*/
775	public static function dx(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
776	{
777	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
778	return $RetCode;
779	}
780	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
781	$optInTimePeriod = 14;
782	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
783	return ReturnCode::BadParam;
784	}
785	if ($optInTimePeriod > 1) {
786	$lookbackTotal = $optInTimePeriod + (static::$unstablePeriod[UnstablePeriodFunctionID::DX]);
787	} else {
788	$lookbackTotal = 2;
789	}
790	if ($startIdx < $lookbackTotal) {
791	$startIdx = $lookbackTotal;
792	}
793	if ($startIdx > $endIdx) {
794	$outBegIdx = 0;
795	$outNBElement = 0;
796
797	return ReturnCode::Success;
798	}
799	$outIdx = 0;
800	$outBegIdx = $today = $startIdx;
801	$prevMinusDM = 0.0;
802	$prevPlusDM = 0.0;
803	$prevTR = 0.0;
804	$today = $startIdx - $lookbackTotal;
805	$prevHigh = $inHigh[$today];
806	$prevLow = $inLow[$today];
807	$prevClose = $inClose[$today];
808	$i = $optInTimePeriod - 1;
809	while ($i-- > 0) {
810	$today++;
811	$tempReal = $inHigh[$today];
812	$diffP = $tempReal - $prevHigh;
813	$prevHigh = $tempReal;
814	$tempReal = $inLow[$today];
815	$diffM = $prevLow - $tempReal;
816	$prevLow = $tempReal;
817	if (($diffM > 0) && ($diffP < $diffM)) {
818	$prevMinusDM += $diffM;
819	} elseif (($diffP > 0) && ($diffP > $diffM)) {
820	$prevPlusDM += $diffP;
821	}
822	{
823	$tempReal = $prevHigh - $prevLow;
824	$tempReal2 = abs($prevHigh - $prevClose);
825	if ($tempReal2 > $tempReal) {
826	$tempReal = $tempReal2;
827	}
828	$tempReal2 = abs($prevLow - $prevClose);
829	if ($tempReal2 > $tempReal) {
830	$tempReal = $tempReal2;
831	}
832	};
833	$prevTR += $tempReal;
834	$prevClose = $inClose[$today];
835	}
836	$i = (static::$unstablePeriod[UnstablePeriodFunctionID::DX]) + 1;
837	while ($i-- != 0) {
838	$today++;
839	$tempReal = $inHigh[$today];
840	$diffP = $tempReal - $prevHigh;
841	$prevHigh = $tempReal;
842	$tempReal = $inLow[$today];
843	$diffM = $prevLow - $tempReal;
844	$prevLow = $tempReal;
845	$prevMinusDM -= $prevMinusDM / $optInTimePeriod;
846	$prevPlusDM -= $prevPlusDM / $optInTimePeriod;
847	if (($diffM > 0) && ($diffP < $diffM)) {
848	$prevMinusDM += $diffM;
849	} elseif (($diffP > 0) && ($diffP > $diffM)) {
850	$prevPlusDM += $diffP;
851	}
852	{
853	$tempReal = $prevHigh - $prevLow;
854	$tempReal2 = abs($prevHigh - $prevClose);
855	if ($tempReal2 > $tempReal) {
856	$tempReal = $tempReal2;
857	}
858	$tempReal2 = abs($prevLow - $prevClose);
859	if ($tempReal2 > $tempReal) {
860	$tempReal = $tempReal2;
861	}
862	};
863	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
864	$prevClose = $inClose[$today];
865	}
866	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
867	$minusDI = (100.0 * ($prevMinusDM / $prevTR));
868	$plusDI = (100.0 * ($prevPlusDM / $prevTR));
869	$tempReal = $minusDI + $plusDI;
870	if (!(((-0.00000001) < $tempReal) && ($tempReal < 0.00000001))) {
871	$outReal[0] = (100.0 * (abs($minusDI - $plusDI) / $tempReal));
872	} else {
873	$outReal[0] = 0.0;
874	}
875	} else {
876	$outReal[0] = 0.0;
877	}
878	$outIdx = 1;
879	while ($today < $endIdx) {
880	$today++;
881	$tempReal = $inHigh[$today];
882	$diffP = $tempReal - $prevHigh;
883	$prevHigh = $tempReal;
884	$tempReal = $inLow[$today];
885	$diffM = $prevLow - $tempReal;
886	$prevLow = $tempReal;
887	$prevMinusDM -= $prevMinusDM / $optInTimePeriod;
888	$prevPlusDM -= $prevPlusDM / $optInTimePeriod;
889	if (($diffM > 0) && ($diffP < $diffM)) {
890	$prevMinusDM += $diffM;
891	} elseif (($diffP > 0) && ($diffP > $diffM)) {
892	$prevPlusDM += $diffP;
893	}
894	{
895	$tempReal = $prevHigh - $prevLow;
896	$tempReal2 = abs($prevHigh - $prevClose);
897	if ($tempReal2 > $tempReal) {
898	$tempReal = $tempReal2;
899	}
900	$tempReal2 = abs($prevLow - $prevClose);
901	if ($tempReal2 > $tempReal) {
902	$tempReal = $tempReal2;
903	}
904	};
905	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
906	$prevClose = $inClose[$today];
907	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
908	$minusDI = (100.0 * ($prevMinusDM / $prevTR));
909	$plusDI = (100.0 * ($prevPlusDM / $prevTR));
910	$tempReal = $minusDI + $plusDI;
911	if (!(((-0.00000001) < $tempReal) && ($tempReal < 0.00000001))) {
912	$outReal[$outIdx] = (100.0 * (abs($minusDI - $plusDI) / $tempReal));
913	} else {
914	$outReal[$outIdx] = $outReal[$outIdx - 1];
915	}
916	} else {
917	$outReal[$outIdx] = $outReal[$outIdx - 1];
918	}
919	$outIdx++;
920	}
921	$outNBElement = $outIdx;
922
923	return ReturnCode::Success;
924	}
925
926	/**
927	* @param int $startIdx
928	* @param int $endIdx
929	* @param array $inReal
930	* @param int $optInFastPeriod
931	* @param int $optInSlowPeriod
932	* @param int $optInSignalPeriod
933	* @param int $outBegIdx
934	* @param int $outNBElement
935	* @param array $outMACD
936	* @param array $outMACDSignal
937	* @param array $outMACDHist
938	*
939	* @return int
940	*/
941	public static function macd(int $startIdx, int $endIdx, array $inReal, int $optInFastPeriod, int $optInSlowPeriod, int $optInSignalPeriod, int &$outBegIdx, int &$outNBElement, array &$outMACD, array &$outMACDSignal, array &$outMACDHist): int
942	{
943	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
944	return $RetCode;
945	}
946	if ((int)$optInFastPeriod == (PHP_INT_MIN)) {
947	$optInFastPeriod = 12;
948	} elseif (((int)$optInFastPeriod < 2) \|\| ((int)$optInFastPeriod > 100000)) {
949	return ReturnCode::BadParam;
950	}
951	if ((int)$optInSlowPeriod == (PHP_INT_MIN)) {
952	$optInSlowPeriod = 26;
953	} elseif (((int)$optInSlowPeriod < 2) \|\| ((int)$optInSlowPeriod > 100000)) {
954	return ReturnCode::BadParam;
955	}
956	if ((int)$optInSignalPeriod == (PHP_INT_MIN)) {
957	$optInSignalPeriod = 9;
958	} elseif (((int)$optInSignalPeriod < 1) \|\| ((int)$optInSignalPeriod > 100000)) {
959	return ReturnCode::BadParam;
960	}
961
962	return static::TA_INT_MACD(
963	$startIdx, $endIdx, $inReal,
964	$optInFastPeriod,
965	$optInSlowPeriod,
966	$optInSignalPeriod,
967	$outBegIdx,
968	$outNBElement,
969	$outMACD,
970	$outMACDSignal,
971	$outMACDHist
972	);
973	}
974
975	/**
976	* @param int $startIdx
977	* @param int $endIdx
978	* @param array $inReal
979	* @param int $optInFastPeriod
980	* @param int $optInFastMAType
981	* @param int $optInSlowPeriod
982	* @param int $optInSlowMAType
983	* @param int $optInSignalPeriod
984	* @param int $optInSignalMAType
985	* @param int $outBegIdx
986	* @param int $outNBElement
987	* @param array $outMACD
988	* @param array $outMACDSignal
989	* @param array $outMACDHist
990	*
991	* @return int
992	*/
993	public static function macdExt(int $startIdx, int $endIdx, array $inReal, int $optInFastPeriod, int $optInFastMAType, int $optInSlowPeriod, int $optInSlowMAType, int $optInSignalPeriod, int $optInSignalMAType, int &$outBegIdx, int &$outNBElement, array &$outMACD, array &$outMACDSignal, array &$outMACDHist): int
994	{
995	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
996	return $RetCode;
997	}
998	$outBegIdx1 = 0;
999	$outNbElement1 = 0;
1000	$outBegIdx2 = 0;
1001	$outNbElement2 = 0;
1002	if ((int)$optInFastPeriod == (PHP_INT_MIN)) {
1003	$optInFastPeriod = 12;
1004	} elseif (((int)$optInFastPeriod < 2) \|\| ((int)$optInFastPeriod > 100000)) {
1005	return ReturnCode::BadParam;
1006	}
1007	if ((int)$optInSlowPeriod == (PHP_INT_MIN)) {
1008	$optInSlowPeriod = 26;
1009	} elseif (((int)$optInSlowPeriod < 2) \|\| ((int)$optInSlowPeriod > 100000)) {
1010	return ReturnCode::BadParam;
1011	}
1012	if ((int)$optInSignalPeriod == (PHP_INT_MIN)) {
1013	$optInSignalPeriod = 9;
1014	} elseif (((int)$optInSignalPeriod < 1) \|\| ((int)$optInSignalPeriod > 100000)) {
1015	return ReturnCode::BadParam;
1016	}
1017	if ($optInSlowPeriod < $optInFastPeriod) {
1018	$tempInteger = $optInSlowPeriod;
1019	$optInSlowPeriod = $optInFastPeriod;
1020	$optInFastPeriod = $tempInteger;
1021	$tempMAType = $optInSlowMAType;
1022	$optInSlowMAType = $optInFastMAType;
1023	$optInFastMAType = $tempMAType;
1024	}
1025	$lookbackLargest = Lookback::movingAverageLookback($optInFastPeriod, $optInFastMAType);
1026	$tempInteger = Lookback::movingAverageLookback($optInSlowPeriod, $optInSlowMAType);
1027	if ($tempInteger > $lookbackLargest) {
1028	$lookbackLargest = $tempInteger;
1029	}
1030	$lookbackSignal = Lookback::movingAverageLookback($optInSignalPeriod, $optInSignalMAType);
1031	$lookbackTotal = $lookbackSignal + $lookbackLargest;
1032	if ($startIdx < $lookbackTotal) {
1033	$startIdx = $lookbackTotal;
1034	}
1035	if ($startIdx > $endIdx) {
1036	$outBegIdx = 0;
1037	$outNBElement = 0;
1038
1039	return ReturnCode::Success;
1040	}
1041	$tempInteger = ($endIdx - $startIdx) + 1 + $lookbackSignal;
1042	$fastMABuffer = static::double($tempInteger);
1043	$slowMABuffer = static::double($tempInteger);
1044	$tempInteger = $startIdx - $lookbackSignal;
1045	$ReturnCode = OverlapStudies::movingAverage(
1046	$tempInteger, $endIdx,
1047	$inReal, $optInSlowPeriod, $optInSlowMAType,
1048	$outBegIdx1, $outNbElement1,
1049	$slowMABuffer
1050	);
1051	if ($ReturnCode != ReturnCode::Success) {
1052	$outBegIdx = 0;
1053	$outNBElement = 0;
1054
1055	return $ReturnCode;
1056	}
1057	$ReturnCode = OverlapStudies::movingAverage(
1058	$tempInteger, $endIdx,
1059	$inReal, $optInFastPeriod, $optInFastMAType,
1060	$outBegIdx2, $outNbElement2,
1061	$fastMABuffer
1062	);
1063	if ($ReturnCode != ReturnCode::Success) {
1064	$outBegIdx = 0;
1065	$outNBElement = 0;
1066
1067	return $ReturnCode;
1068	}
1069	if (($outBegIdx1 != $tempInteger) \|\|
1070	($outBegIdx2 != $tempInteger) \|\|
1071	($outNbElement1 != $outNbElement2) \|\|
1072	($outNbElement1 != ($endIdx - $startIdx) + 1 + $lookbackSignal)) {
1073	$outBegIdx = 0;
1074	$outNBElement = 0;
1075
1076	return (ReturnCode::InternalError);
1077	}
1078	for ($i = 0; $i < $outNbElement1; $i++) {
1079	$fastMABuffer[$i] = $fastMABuffer[$i] - $slowMABuffer[$i];
1080	}
1081	//System::arraycopy($fastMABuffer, $lookbackSignal, $outMACD, 0, ($endIdx - $startIdx) + 1);
1082	$outMACD = \array_slice($fastMABuffer, $lookbackSignal, ($endIdx - $startIdx) + 1);
1083	$ReturnCode = OverlapStudies::movingAverage(
1084	0, $outNbElement1 - 1,
1085	$fastMABuffer, $optInSignalPeriod, $optInSignalMAType,
1086	$outBegIdx2, $outNbElement2, $outMACDSignal
1087	);
1088	if ($ReturnCode != ReturnCode::Success) {
1089	$outBegIdx = 0;
1090	$outNBElement = 0;
1091
1092	return $ReturnCode;
1093	}
1094	for ($i = 0; $i < $outNbElement2; $i++) {
1095	$outMACDHist[$i] = $outMACD[$i] - $outMACDSignal[$i];
1096	}
1097	$outBegIdx = $startIdx;
1098	$outNBElement = $outNbElement2;
1099
1100	return ReturnCode::Success;
1101	}
1102
1103	/**
1104	* @param int $startIdx
1105	* @param int $endIdx
1106	* @param array $inReal
1107	* @param int $optInSignalPeriod
1108	* @param int $outBegIdx
1109	* @param int $outNBElement
1110	* @param array $outMACD
1111	* @param array $outMACDSignal
1112	* @param array $outMACDHist
1113	*
1114	* @return int
1115	*/
1116	public static function macdFix(int $startIdx, int $endIdx, array $inReal, int $optInSignalPeriod, int &$outBegIdx, int &$outNBElement, array &$outMACD, array &$outMACDSignal, array &$outMACDHist): int
1117	{
1118	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1119	return $RetCode;
1120	}
1121	if ((int)$optInSignalPeriod == (PHP_INT_MIN)) {
1122	$optInSignalPeriod = 9;
1123	} elseif (((int)$optInSignalPeriod < 1) \|\| ((int)$optInSignalPeriod > 100000)) {
1124	return ReturnCode::BadParam;
1125	}
1126
1127	return static::TA_INT_MACD(
1128	$startIdx, $endIdx, $inReal,
1129	0,
1130	0,
1131	$optInSignalPeriod,
1132	$outBegIdx,
1133	$outNBElement,
1134	$outMACD,
1135	$outMACDSignal,
1136	$outMACDHist
1137	);
1138	}
1139
1140	/**
1141	* @param int $startIdx
1142	* @param int $endIdx
1143	* @param array $inHigh
1144	* @param array $inLow
1145	* @param array $inClose
1146	* @param array $inVolume
1147	* @param int $optInTimePeriod
1148	* @param int $outBegIdx
1149	* @param int $outNBElement
1150	* @param array $outReal
1151	*
1152	* @return int
1153	*/
1154	public static function mfi(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, array &$inVolume, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
1155	{
1156	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1157	return $RetCode;
1158	}
1159	$money_flow_Idx = 0;
1160	$maxIdx_money_flow = (50 - 1);
1161	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
1162	$optInTimePeriod = 14;
1163	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
1164	return ReturnCode::BadParam;
1165	}
1166	{
1167	if ($optInTimePeriod <= 0) {
1168	return ReturnCode::AllocError;
1169	}
1170	$money_flow = \array_pad([], $optInTimePeriod, new MoneyFlow());
1171	for ($_money_flow_index = 0; $_money_flow_index < $optInTimePeriod; $_money_flow_index++) {
1172	$money_flow[$_money_flow_index] = new MoneyFlow();
1173	}
1174	$maxIdx_money_flow = ($optInTimePeriod - 1);
1175	};
1176	$outBegIdx = 0;
1177	$outNBElement = 0;
1178	$lookbackTotal = $optInTimePeriod + (static::$unstablePeriod[UnstablePeriodFunctionID::MFI]);
1179	if ($startIdx < $lookbackTotal) {
1180	$startIdx = $lookbackTotal;
1181	}
1182	if ($startIdx > $endIdx) {
1183	return ReturnCode::Success;
1184	}
1185	$outIdx = 0;
1186	$today = $startIdx - $lookbackTotal;
1187	$prevValue = ($inHigh[$today] + $inLow[$today] + $inClose[$today]) / 3.0;
1188	$posSumMF = 0.0;
1189	$negSumMF = 0.0;
1190	$today++;
1191	for ($i = $optInTimePeriod; $i > 0; $i--) {
1192	$tempValue1 = ($inHigh[$today] + $inLow[$today] + $inClose[$today]) / 3.0;
1193	$tempValue2 = $tempValue1 - $prevValue;
1194	$prevValue = $tempValue1;
1195	$tempValue1 *= $inVolume[$today++];
1196	if ($tempValue2 < 0) {
1197	($money_flow[$money_flow_Idx])->negative = $tempValue1;
1198	$negSumMF += $tempValue1;
1199	($money_flow[$money_flow_Idx])->positive = 0.0;
1200	} elseif ($tempValue2 > 0) {
1201	($money_flow[$money_flow_Idx])->positive = $tempValue1;
1202	$posSumMF += $tempValue1;
1203	($money_flow[$money_flow_Idx])->negative = 0.0;
1204	} else {
1205	($money_flow[$money_flow_Idx])->positive = 0.0;
1206	($money_flow[$money_flow_Idx])->negative = 0.0;
1207	}
1208	{
1209	$money_flow_Idx++;
1210	if ($money_flow_Idx > $maxIdx_money_flow) {
1211	$money_flow_Idx = 0;
1212	}
1213	};
1214	}
1215	if ($today > $startIdx) {
1216	$tempValue1 = $posSumMF + $negSumMF;
1217	if ($tempValue1 < 1.0) {
1218	$outReal[$outIdx++] = 0.0;
1219	} else {
1220	$outReal[$outIdx++] = 100.0 * ($posSumMF / $tempValue1);
1221	}
1222	} else {
1223	while ($today < $startIdx) {
1224	$posSumMF -= ($money_flow[$money_flow_Idx])->positive;
1225	$negSumMF -= ($money_flow[$money_flow_Idx])->negative;
1226	$tempValue1 = ($inHigh[$today] + $inLow[$today] + $inClose[$today]) / 3.0;
1227	$tempValue2 = $tempValue1 - $prevValue;
1228	$prevValue = $tempValue1;
1229	$tempValue1 *= $inVolume[$today++];
1230	if ($tempValue2 < 0) {
1231	($money_flow[$money_flow_Idx])->negative = $tempValue1;
1232	$negSumMF += $tempValue1;
1233	($money_flow[$money_flow_Idx])->positive = 0.0;
1234	} elseif ($tempValue2 > 0) {
1235	($money_flow[$money_flow_Idx])->positive = $tempValue1;
1236	$posSumMF += $tempValue1;
1237	($money_flow[$money_flow_Idx])->negative = 0.0;
1238	} else {
1239	($money_flow[$money_flow_Idx])->positive = 0.0;
1240	($money_flow[$money_flow_Idx])->negative = 0.0;
1241	}
1242	{
1243	$money_flow_Idx++;
1244	if ($money_flow_Idx > $maxIdx_money_flow) {
1245	$money_flow_Idx = 0;
1246	}
1247	};
1248	}
1249	}
1250	while ($today <= $endIdx) {
1251	$posSumMF -= ($money_flow[$money_flow_Idx])->positive;
1252	$negSumMF -= ($money_flow[$money_flow_Idx])->negative;
1253	$tempValue1 = ($inHigh[$today] + $inLow[$today] + $inClose[$today]) / 3.0;
1254	$tempValue2 = $tempValue1 - $prevValue;
1255	$prevValue = $tempValue1;
1256	$tempValue1 *= $inVolume[$today++];
1257	if ($tempValue2 < 0) {
1258	($money_flow[$money_flow_Idx])->negative = $tempValue1;
1259	$negSumMF += $tempValue1;
1260	($money_flow[$money_flow_Idx])->positive = 0.0;
1261	} elseif ($tempValue2 > 0) {
1262	($money_flow[$money_flow_Idx])->positive = $tempValue1;
1263	$posSumMF += $tempValue1;
1264	($money_flow[$money_flow_Idx])->negative = 0.0;
1265	} else {
1266	($money_flow[$money_flow_Idx])->positive = 0.0;
1267	($money_flow[$money_flow_Idx])->negative = 0.0;
1268	}
1269	$tempValue1 = $posSumMF + $negSumMF;
1270	if ($tempValue1 < 1.0) {
1271	$outReal[$outIdx++] = 0.0;
1272	} else {
1273	$outReal[$outIdx++] = 100.0 * ($posSumMF / $tempValue1);
1274	}
1275	{
1276	$money_flow_Idx++;
1277	if ($money_flow_Idx > $maxIdx_money_flow) {
1278	$money_flow_Idx = 0;
1279	}
1280	};
1281	}
1282	$outBegIdx = $startIdx;
1283	$outNBElement = $outIdx;
1284
1285	return ReturnCode::Success;
1286	}
1287
1288	/**
1289	* @param int $startIdx
1290	* @param int $endIdx
1291	* @param array $inHigh
1292	* @param array $inLow
1293	* @param array $inClose
1294	* @param int $optInTimePeriod
1295	* @param int $outBegIdx
1296	* @param int $outNBElement
1297	* @param array $outReal
1298	*
1299	* @return int
1300	*/
1301	public static function minusDI(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
1302	{
1303	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1304	return $RetCode;
1305	}
1306	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
1307	$optInTimePeriod = 14;
1308	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
1309	return ReturnCode::BadParam;
1310	}
1311	if ($optInTimePeriod > 1) {
1312	$lookbackTotal = $optInTimePeriod + (static::$unstablePeriod[UnstablePeriodFunctionID::MinusDI]);
1313	} else {
1314	$lookbackTotal = 1;
1315	}
1316	if ($startIdx < $lookbackTotal) {
1317	$startIdx = $lookbackTotal;
1318	}
1319	if ($startIdx > $endIdx) {
1320	$outBegIdx = 0;
1321	$outNBElement = 0;
1322
1323	return ReturnCode::Success;
1324	}
1325	$outIdx = 0;
1326	if ($optInTimePeriod <= 1) {
1327	$outBegIdx = $startIdx;
1328	$today = $startIdx - 1;
1329	$prevHigh = $inHigh[$today];
1330	$prevLow = $inLow[$today];
1331	$prevClose = $inClose[$today];
1332	while ($today < $endIdx) {
1333	$today++;
1334	$tempReal = $inHigh[$today];
1335	$diffP = $tempReal - $prevHigh;
1336	$prevHigh = $tempReal;
1337	$tempReal = $inLow[$today];
1338	$diffM = $prevLow - $tempReal;
1339	$prevLow = $tempReal;
1340	if (($diffM > 0) && ($diffP < $diffM)) {
1341	{
1342	$tempReal = $prevHigh - $prevLow;
1343	$tempReal2 = abs($prevHigh - $prevClose);
1344	if ($tempReal2 > $tempReal) {
1345	$tempReal = $tempReal2;
1346	}
1347	$tempReal2 = abs($prevLow - $prevClose);
1348	if ($tempReal2 > $tempReal) {
1349	$tempReal = $tempReal2;
1350	}
1351	};
1352	if ((((-0.00000001) < $tempReal) && ($tempReal < 0.00000001))) {
1353	$outReal[$outIdx++] = (double)0.0;
1354	} else {
1355	$outReal[$outIdx++] = $diffM / $tempReal;
1356	}
1357	} else {
1358	$outReal[$outIdx++] = (double)0.0;
1359	}
1360	$prevClose = $inClose[$today];
1361	}
1362	$outNBElement = $outIdx;
1363
1364	return ReturnCode::Success;
1365	}
1366	$outBegIdx = $today = $startIdx;
1367	$prevMinusDM = 0.0;
1368	$prevTR = 0.0;
1369	$today = $startIdx - $lookbackTotal;
1370	$prevHigh = $inHigh[$today];
1371	$prevLow = $inLow[$today];
1372	$prevClose = $inClose[$today];
1373	$i = $optInTimePeriod - 1;
1374	while ($i-- > 0) {
1375	$today++;
1376	$tempReal = $inHigh[$today];
1377	$diffP = $tempReal - $prevHigh;
1378	$prevHigh = $tempReal;
1379	$tempReal = $inLow[$today];
1380	$diffM = $prevLow - $tempReal;
1381	$prevLow = $tempReal;
1382	if (($diffM > 0) && ($diffP < $diffM)) {
1383	$prevMinusDM += $diffM;
1384	}
1385	{
1386	$tempReal = $prevHigh - $prevLow;
1387	$tempReal2 = abs($prevHigh - $prevClose);
1388	if ($tempReal2 > $tempReal) {
1389	$tempReal = $tempReal2;
1390	}
1391	$tempReal2 = abs($prevLow - $prevClose);
1392	if ($tempReal2 > $tempReal) {
1393	$tempReal = $tempReal2;
1394	}
1395	};
1396	$prevTR += $tempReal;
1397	$prevClose = $inClose[$today];
1398	}
1399	$i = (static::$unstablePeriod[UnstablePeriodFunctionID::MinusDI]) + 1;
1400	while ($i-- != 0) {
1401	$today++;
1402	$tempReal = $inHigh[$today];
1403	$diffP = $tempReal - $prevHigh;
1404	$prevHigh = $tempReal;
1405	$tempReal = $inLow[$today];
1406	$diffM = $prevLow - $tempReal;
1407	$prevLow = $tempReal;
1408	if (($diffM > 0) && ($diffP < $diffM)) {
1409	$prevMinusDM = $prevMinusDM - ($prevMinusDM / $optInTimePeriod) + $diffM;
1410	} else {
1411	$prevMinusDM = $prevMinusDM - ($prevMinusDM / $optInTimePeriod);
1412	}
1413	{
1414	$tempReal = $prevHigh - $prevLow;
1415	$tempReal2 = abs($prevHigh - $prevClose);
1416	if ($tempReal2 > $tempReal) {
1417	$tempReal = $tempReal2;
1418	}
1419	$tempReal2 = abs($prevLow - $prevClose);
1420	if ($tempReal2 > $tempReal) {
1421	$tempReal = $tempReal2;
1422	}
1423	};
1424	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
1425	$prevClose = $inClose[$today];
1426	}
1427	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
1428	$outReal[0] = (100.0 * ($prevMinusDM / $prevTR));
1429	} else {
1430	$outReal[0] = 0.0;
1431	}
1432	$outIdx = 1;
1433	while ($today < $endIdx) {
1434	$today++;
1435	$tempReal = $inHigh[$today];
1436	$diffP = $tempReal - $prevHigh;
1437	$prevHigh = $tempReal;
1438	$tempReal = $inLow[$today];
1439	$diffM = $prevLow - $tempReal;
1440	$prevLow = $tempReal;
1441	if (($diffM > 0) && ($diffP < $diffM)) {
1442	$prevMinusDM = $prevMinusDM - ($prevMinusDM / $optInTimePeriod) + $diffM;
1443	} else {
1444	$prevMinusDM = $prevMinusDM - ($prevMinusDM / $optInTimePeriod);
1445	}
1446	{
1447	$tempReal = $prevHigh - $prevLow;
1448	$tempReal2 = abs($prevHigh - $prevClose);
1449	if ($tempReal2 > $tempReal) {
1450	$tempReal = $tempReal2;
1451	}
1452	$tempReal2 = abs($prevLow - $prevClose);
1453	if ($tempReal2 > $tempReal) {
1454	$tempReal = $tempReal2;
1455	}
1456	};
1457	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
1458	$prevClose = $inClose[$today];
1459	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
1460	$outReal[$outIdx++] = (100.0 * ($prevMinusDM / $prevTR));
1461	} else {
1462	$outReal[$outIdx++] = 0.0;
1463	}
1464	}
1465	$outNBElement = $outIdx;
1466
1467	return ReturnCode::Success;
1468	}
1469
1470	/**
1471	* @param int $startIdx
1472	* @param int $endIdx
1473	* @param array $inHigh
1474	* @param array $inLow
1475	* @param int $optInTimePeriod
1476	* @param int $outBegIdx
1477	* @param int $outNBElement
1478	* @param array $outReal
1479	*
1480	* @return int
1481	*/
1482	public static function minusDM(int $startIdx, int $endIdx, array $inHigh, array $inLow, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
1483	{
1484	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1485	return $RetCode;
1486	}
1487	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
1488	$optInTimePeriod = 14;
1489	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
1490	return ReturnCode::BadParam;
1491	}
1492	if ($optInTimePeriod > 1) {
1493	$lookbackTotal = $optInTimePeriod + (static::$unstablePeriod[UnstablePeriodFunctionID::MinusDM]) - 1;
1494	} else {
1495	$lookbackTotal = 1;
1496	}
1497	if ($startIdx < $lookbackTotal) {
1498	$startIdx = $lookbackTotal;
1499	}
1500	if ($startIdx > $endIdx) {
1501	$outBegIdx = 0;
1502	$outNBElement = 0;
1503
1504	return ReturnCode::Success;
1505	}
1506	$outIdx = 0;
1507	if ($optInTimePeriod <= 1) {
1508	$outBegIdx = $startIdx;
1509	$today = $startIdx - 1;
1510	$prevHigh = $inHigh[$today];
1511	$prevLow = $inLow[$today];
1512	while ($today < $endIdx) {
1513	$today++;
1514	$tempReal = $inHigh[$today];
1515	$diffP = $tempReal - $prevHigh;
1516	$prevHigh = $tempReal;
1517	$tempReal = $inLow[$today];
1518	$diffM = $prevLow - $tempReal;
1519	$prevLow = $tempReal;
1520	if (($diffM > 0) && ($diffP < $diffM)) {
1521	$outReal[$outIdx++] = $diffM;
1522	} else {
1523	$outReal[$outIdx++] = 0;
1524	}
1525	}
1526	$outNBElement = $outIdx;
1527
1528	return ReturnCode::Success;
1529	}
1530	$outBegIdx = $startIdx;
1531	$prevMinusDM = 0.0;
1532	$today = $startIdx - $lookbackTotal;
1533	$prevHigh = $inHigh[$today];
1534	$prevLow = $inLow[$today];
1535	$i = $optInTimePeriod - 1;
1536	while ($i-- > 0) {
1537	$today++;
1538	$tempReal = $inHigh[$today];
1539	$diffP = $tempReal - $prevHigh;
1540	$prevHigh = $tempReal;
1541	$tempReal = $inLow[$today];
1542	$diffM = $prevLow - $tempReal;
1543	$prevLow = $tempReal;
1544	if (($diffM > 0) && ($diffP < $diffM)) {
1545	$prevMinusDM += $diffM;
1546	}
1547	}
1548	$i = (static::$unstablePeriod[UnstablePeriodFunctionID::MinusDM]);
1549	while ($i-- != 0) {
1550	$today++;
1551	$tempReal = $inHigh[$today];
1552	$diffP = $tempReal - $prevHigh;
1553	$prevHigh = $tempReal;
1554	$tempReal = $inLow[$today];
1555	$diffM = $prevLow - $tempReal;
1556	$prevLow = $tempReal;
1557	if (($diffM > 0) && ($diffP < $diffM)) {
1558	$prevMinusDM = $prevMinusDM - ($prevMinusDM / $optInTimePeriod) + $diffM;
1559	} else {
1560	$prevMinusDM = $prevMinusDM - ($prevMinusDM / $optInTimePeriod);
1561	}
1562	}
1563	$outReal[0] = $prevMinusDM;
1564	$outIdx = 1;
1565	while ($today < $endIdx) {
1566	$today++;
1567	$tempReal = $inHigh[$today];
1568	$diffP = $tempReal - $prevHigh;
1569	$prevHigh = $tempReal;
1570	$tempReal = $inLow[$today];
1571	$diffM = $prevLow - $tempReal;
1572	$prevLow = $tempReal;
1573	if (($diffM > 0) && ($diffP < $diffM)) {
1574	$prevMinusDM = $prevMinusDM - ($prevMinusDM / $optInTimePeriod) + $diffM;
1575	} else {
1576	$prevMinusDM = $prevMinusDM - ($prevMinusDM / $optInTimePeriod);
1577	}
1578	$outReal[$outIdx++] = $prevMinusDM;
1579	}
1580	$outNBElement = $outIdx;
1581
1582	return ReturnCode::Success;
1583	}
1584
1585	/**
1586	* @param int $startIdx
1587	* @param int $endIdx
1588	* @param array $inReal
1589	* @param int $optInTimePeriod
1590	* @param int $outBegIdx
1591	* @param int $outNBElement
1592	* @param array $outReal
1593	*
1594	* @return int
1595	*/
1596	public static function mom(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
1597	{
1598	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1599	return $RetCode;
1600	}
1601	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
1602	$optInTimePeriod = 10;
1603	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
1604	return ReturnCode::BadParam;
1605	}
1606	if ($startIdx < $optInTimePeriod) {
1607	$startIdx = $optInTimePeriod;
1608	}
1609	if ($startIdx > $endIdx) {
1610	$outBegIdx = 0;
1611	$outNBElement = 0;
1612
1613	return ReturnCode::Success;
1614	}
1615	$outIdx = 0;
1616	$inIdx = $startIdx;
1617	$trailingIdx = $startIdx - $optInTimePeriod;
1618	while ($inIdx <= $endIdx) {
1619	$outReal[$outIdx++] = $inReal[$inIdx++] - $inReal[$trailingIdx++];
1620	}
1621	$outNBElement = $outIdx;
1622	$outBegIdx = $startIdx;
1623
1624	return ReturnCode::Success;
1625	}
1626
1627	/**
1628	* @param int $startIdx
1629	* @param int $endIdx
1630	* @param array $inHigh
1631	* @param array $inLow
1632	* @param array $inClose
1633	* @param int $optInTimePeriod
1634	* @param int $outBegIdx
1635	* @param int $outNBElement
1636	* @param array $outReal
1637	*
1638	* @return int
1639	*/
1640	public static function plusDI(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
1641	{
1642	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1643	return $RetCode;
1644	}
1645	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
1646	$optInTimePeriod = 14;
1647	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
1648	return ReturnCode::BadParam;
1649	}
1650	if ($optInTimePeriod > 1) {
1651	$lookbackTotal = $optInTimePeriod + (static::$unstablePeriod[UnstablePeriodFunctionID::PlusDI]);
1652	} else {
1653	$lookbackTotal = 1;
1654	}
1655	if ($startIdx < $lookbackTotal) {
1656	$startIdx = $lookbackTotal;
1657	}
1658	if ($startIdx > $endIdx) {
1659	$outBegIdx = 0;
1660	$outNBElement = 0;
1661
1662	return ReturnCode::Success;
1663	}
1664	$outIdx = 0;
1665	if ($optInTimePeriod <= 1) {
1666	$outBegIdx = $startIdx;
1667	$today = $startIdx - 1;
1668	$prevHigh = $inHigh[$today];
1669	$prevLow = $inLow[$today];
1670	$prevClose = $inClose[$today];
1671	while ($today < $endIdx) {
1672	$today++;
1673	$tempReal = $inHigh[$today];
1674	$diffP = $tempReal - $prevHigh;
1675	$prevHigh = $tempReal;
1676	$tempReal = $inLow[$today];
1677	$diffM = $prevLow - $tempReal;
1678	$prevLow = $tempReal;
1679	if (($diffP > 0) && ($diffP > $diffM)) {
1680	{
1681	$tempReal = $prevHigh - $prevLow;
1682	$tempReal2 = abs($prevHigh - $prevClose);
1683	if ($tempReal2 > $tempReal) {
1684	$tempReal = $tempReal2;
1685	}
1686	$tempReal2 = abs($prevLow - $prevClose);
1687	if ($tempReal2 > $tempReal) {
1688	$tempReal = $tempReal2;
1689	}
1690	};
1691	if ((((-0.00000001) < $tempReal) && ($tempReal < 0.00000001))) {
1692	$outReal[$outIdx++] = (double)0.0;
1693	} else {
1694	$outReal[$outIdx++] = $diffP / $tempReal;
1695	}
1696	} else {
1697	$outReal[$outIdx++] = (double)0.0;
1698	}
1699	$prevClose = $inClose[$today];
1700	}
1701	$outNBElement = $outIdx;
1702
1703	return ReturnCode::Success;
1704	}
1705	$outBegIdx = $today = $startIdx;
1706	$prevPlusDM = 0.0;
1707	$prevTR = 0.0;
1708	$today = $startIdx - $lookbackTotal;
1709	$prevHigh = $inHigh[$today];
1710	$prevLow = $inLow[$today];
1711	$prevClose = $inClose[$today];
1712	$i = $optInTimePeriod - 1;
1713	while ($i-- > 0) {
1714	$today++;
1715	$tempReal = $inHigh[$today];
1716	$diffP = $tempReal - $prevHigh;
1717	$prevHigh = $tempReal;
1718	$tempReal = $inLow[$today];
1719	$diffM = $prevLow - $tempReal;
1720	$prevLow = $tempReal;
1721	if (($diffP > 0) && ($diffP > $diffM)) {
1722	$prevPlusDM += $diffP;
1723	}
1724	{
1725	$tempReal = $prevHigh - $prevLow;
1726	$tempReal2 = abs($prevHigh - $prevClose);
1727	if ($tempReal2 > $tempReal) {
1728	$tempReal = $tempReal2;
1729	}
1730	$tempReal2 = abs($prevLow - $prevClose);
1731	if ($tempReal2 > $tempReal) {
1732	$tempReal = $tempReal2;
1733	}
1734	};
1735	$prevTR += $tempReal;
1736	$prevClose = $inClose[$today];
1737	}
1738	$i = (static::$unstablePeriod[UnstablePeriodFunctionID::PlusDI]) + 1;
1739	while ($i-- != 0) {
1740	$today++;
1741	$tempReal = $inHigh[$today];
1742	$diffP = $tempReal - $prevHigh;
1743	$prevHigh = $tempReal;
1744	$tempReal = $inLow[$today];
1745	$diffM = $prevLow - $tempReal;
1746	$prevLow = $tempReal;
1747	if (($diffP > 0) && ($diffP > $diffM)) {
1748	$prevPlusDM = $prevPlusDM - ($prevPlusDM / $optInTimePeriod) + $diffP;
1749	} else {
1750	$prevPlusDM = $prevPlusDM - ($prevPlusDM / $optInTimePeriod);
1751	}
1752	{
1753	$tempReal = $prevHigh - $prevLow;
1754	$tempReal2 = abs($prevHigh - $prevClose);
1755	if ($tempReal2 > $tempReal) {
1756	$tempReal = $tempReal2;
1757	}
1758	$tempReal2 = abs($prevLow - $prevClose);
1759	if ($tempReal2 > $tempReal) {
1760	$tempReal = $tempReal2;
1761	}
1762	};
1763	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
1764	$prevClose = $inClose[$today];
1765	}
1766	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
1767	$outReal[0] = (100.0 * ($prevPlusDM / $prevTR));
1768	} else {
1769	$outReal[0] = 0.0;
1770	}
1771	$outIdx = 1;
1772	while ($today < $endIdx) {
1773	$today++;
1774	$tempReal = $inHigh[$today];
1775	$diffP = $tempReal - $prevHigh;
1776	$prevHigh = $tempReal;
1777	$tempReal = $inLow[$today];
1778	$diffM = $prevLow - $tempReal;
1779	$prevLow = $tempReal;
1780	if (($diffP > 0) && ($diffP > $diffM)) {
1781	$prevPlusDM = $prevPlusDM - ($prevPlusDM / $optInTimePeriod) + $diffP;
1782	} else {
1783	$prevPlusDM = $prevPlusDM - ($prevPlusDM / $optInTimePeriod);
1784	}
1785	{
1786	$tempReal = $prevHigh - $prevLow;
1787	$tempReal2 = abs($prevHigh - $prevClose);
1788	if ($tempReal2 > $tempReal) {
1789	$tempReal = $tempReal2;
1790	}
1791	$tempReal2 = abs($prevLow - $prevClose);
1792	if ($tempReal2 > $tempReal) {
1793	$tempReal = $tempReal2;
1794	}
1795	};
1796	$prevTR = $prevTR - ($prevTR / $optInTimePeriod) + $tempReal;
1797	$prevClose = $inClose[$today];
1798	if (!(((-0.00000001) < $prevTR) && ($prevTR < 0.00000001))) {
1799	$outReal[$outIdx++] = (100.0 * ($prevPlusDM / $prevTR));
1800	} else {
1801	$outReal[$outIdx++] = 0.0;
1802	}
1803	}
1804	$outNBElement = $outIdx;
1805
1806	return ReturnCode::Success;
1807	}
1808
1809	/**
1810	* @param int $startIdx
1811	* @param int $endIdx
1812	* @param array $inHigh
1813	* @param array $inLow
1814	* @param int $optInTimePeriod
1815	* @param int $outBegIdx
1816	* @param int $outNBElement
1817	* @param array $outReal
1818	*
1819	* @return int
1820	*/
1821	public static function plusDM(int $startIdx, int $endIdx, array $inHigh, array $inLow, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
1822	{
1823	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1824	return $RetCode;
1825	}
1826	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
1827	$optInTimePeriod = 14;
1828	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
1829	return ReturnCode::BadParam;
1830	}
1831	if ($optInTimePeriod > 1) {
1832	$lookbackTotal = $optInTimePeriod + (static::$unstablePeriod[UnstablePeriodFunctionID::PlusDM]) - 1;
1833	} else {
1834	$lookbackTotal = 1;
1835	}
1836	if ($startIdx < $lookbackTotal) {
1837	$startIdx = $lookbackTotal;
1838	}
1839	if ($startIdx > $endIdx) {
1840	$outBegIdx = 0;
1841	$outNBElement = 0;
1842
1843	return ReturnCode::Success;
1844	}
1845	$outIdx = 0;
1846	if ($optInTimePeriod <= 1) {
1847	$outBegIdx = $startIdx;
1848	$today = $startIdx - 1;
1849	$prevHigh = $inHigh[$today];
1850	$prevLow = $inLow[$today];
1851	while ($today < $endIdx) {
1852	$today++;
1853	$tempReal = $inHigh[$today];
1854	$diffP = $tempReal - $prevHigh;
1855	$prevHigh = $tempReal;
1856	$tempReal = $inLow[$today];
1857	$diffM = $prevLow - $tempReal;
1858	$prevLow = $tempReal;
1859	if (($diffP > 0) && ($diffP > $diffM)) {
1860	$outReal[$outIdx++] = $diffP;
1861	} else {
1862	$outReal[$outIdx++] = 0;
1863	}
1864	}
1865	$outNBElement = $outIdx;
1866
1867	return ReturnCode::Success;
1868	}
1869	$outBegIdx = $startIdx;
1870	$prevPlusDM = 0.0;
1871	$today = $startIdx - $lookbackTotal;
1872	$prevHigh = $inHigh[$today];
1873	$prevLow = $inLow[$today];
1874	$i = $optInTimePeriod - 1;
1875	while ($i-- > 0) {
1876	$today++;
1877	$tempReal = $inHigh[$today];
1878	$diffP = $tempReal - $prevHigh;
1879	$prevHigh = $tempReal;
1880	$tempReal = $inLow[$today];
1881	$diffM = $prevLow - $tempReal;
1882	$prevLow = $tempReal;
1883	if (($diffP > 0) && ($diffP > $diffM)) {
1884	$prevPlusDM += $diffP;
1885	}
1886	}
1887	$i = (static::$unstablePeriod[UnstablePeriodFunctionID::PlusDM]);
1888	while ($i-- != 0) {
1889	$today++;
1890	$tempReal = $inHigh[$today];
1891	$diffP = $tempReal - $prevHigh;
1892	$prevHigh = $tempReal;
1893	$tempReal = $inLow[$today];
1894	$diffM = $prevLow - $tempReal;
1895	$prevLow = $tempReal;
1896	if (($diffP > 0) && ($diffP > $diffM)) {
1897	$prevPlusDM = $prevPlusDM - ($prevPlusDM / $optInTimePeriod) + $diffP;
1898	} else {
1899	$prevPlusDM = $prevPlusDM - ($prevPlusDM / $optInTimePeriod);
1900	}
1901	}
1902	$outReal[0] = $prevPlusDM;
1903	$outIdx = 1;
1904	while ($today < $endIdx) {
1905	$today++;
1906	$tempReal = $inHigh[$today];
1907	$diffP = $tempReal - $prevHigh;
1908	$prevHigh = $tempReal;
1909	$tempReal = $inLow[$today];
1910	$diffM = $prevLow - $tempReal;
1911	$prevLow = $tempReal;
1912	if (($diffP > 0) && ($diffP > $diffM)) {
1913	$prevPlusDM = $prevPlusDM - ($prevPlusDM / $optInTimePeriod) + $diffP;
1914	} else {
1915	$prevPlusDM = $prevPlusDM - ($prevPlusDM / $optInTimePeriod);
1916	}
1917	$outReal[$outIdx++] = $prevPlusDM;
1918	}
1919	$outNBElement = $outIdx;
1920
1921	return ReturnCode::Success;
1922	}
1923
1924	/**
1925	* @param int $startIdx
1926	* @param int $endIdx
1927	* @param array $inReal
1928	* @param int $optInFastPeriod
1929	* @param int $optInSlowPeriod
1930	* @param int $optInMAType
1931	* @param int $outBegIdx
1932	* @param int $outNBElement
1933	* @param array $outReal
1934	*
1935	* @return int
1936	*/
1937	public static function ppo(int $startIdx, int $endIdx, array $inReal, int $optInFastPeriod, int $optInSlowPeriod, int $optInMAType, int &$outBegIdx, int &$outNBElement, array &$outReal): int
1938	{
1939	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1940	return $RetCode;
1941	}
1942	if ((int)$optInFastPeriod == (PHP_INT_MIN)) {
1943	$optInFastPeriod = 12;
1944	} elseif (((int)$optInFastPeriod < 2) \|\| ((int)$optInFastPeriod > 100000)) {
1945	return ReturnCode::BadParam;
1946	}
1947	if ((int)$optInSlowPeriod == (PHP_INT_MIN)) {
1948	$optInSlowPeriod = 26;
1949	} elseif (((int)$optInSlowPeriod < 2) \|\| ((int)$optInSlowPeriod > 100000)) {
1950	return ReturnCode::BadParam;
1951	}
1952	$tempBuffer = static::double($endIdx - $startIdx + 1);
1953	$one = 1;
1954	$ReturnCode = static::TA_INT_PO(
1955	$startIdx, $endIdx, $inReal,
1956	$optInFastPeriod,
1957	$optInSlowPeriod,
1958	$optInMAType,
1959	$outBegIdx,
1960	$outNBElement,
1961	$outReal,
1962	$tempBuffer,
1963	$one
1964	);
1965
1966	return $ReturnCode;
1967	}
1968
1969	/**
1970	* @param int $startIdx
1971	* @param int $endIdx
1972	* @param array $inReal
1973	* @param int $optInTimePeriod
1974	* @param int $outBegIdx
1975	* @param int $outNBElement
1976	* @param array $outReal
1977	*
1978	* @return int
1979	*/
1980	public static function roc(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
1981	{
1982	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
1983	return $RetCode;
1984	}
1985	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
1986	$optInTimePeriod = 10;
1987	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
1988	return ReturnCode::BadParam;
1989	}
1990	if ($startIdx < $optInTimePeriod) {
1991	$startIdx = $optInTimePeriod;
1992	}
1993	if ($startIdx > $endIdx) {
1994	$outBegIdx = 0;
1995	$outNBElement = 0;
1996
1997	return ReturnCode::Success;
1998	}
1999	$outIdx = 0;
2000	$inIdx = $startIdx;
2001	$trailingIdx = $startIdx - $optInTimePeriod;
2002	while ($inIdx <= $endIdx) {
2003	$tempReal = $inReal[$trailingIdx++];
2004	if ($tempReal != 0.0) {
2005	$outReal[$outIdx++] = (($inReal[$inIdx] / $tempReal) - 1.0) * 100.0;
2006	} else {
2007	$outReal[$outIdx++] = 0.0;
2008	}
2009	$inIdx++;
2010	}
2011	$outNBElement = $outIdx;
2012	$outBegIdx = $startIdx;
2013
2014	return ReturnCode::Success;
2015	}
2016
2017	/**
2018	* @param int $startIdx
2019	* @param int $endIdx
2020	* @param array $inReal
2021	* @param int $optInTimePeriod
2022	* @param int $outBegIdx
2023	* @param int $outNBElement
2024	* @param array $outReal
2025	*
2026	* @return int
2027	*/
2028	public static function rocP(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
2029	{
2030	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2031	return $RetCode;
2032	}
2033	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
2034	$optInTimePeriod = 10;
2035	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
2036	return ReturnCode::BadParam;
2037	}
2038	if ($startIdx < $optInTimePeriod) {
2039	$startIdx = $optInTimePeriod;
2040	}
2041	if ($startIdx > $endIdx) {
2042	$outBegIdx = 0;
2043	$outNBElement = 0;
2044
2045	return ReturnCode::Success;
2046	}
2047	$outIdx = 0;
2048	$inIdx = $startIdx;
2049	$trailingIdx = $startIdx - $optInTimePeriod;
2050	while ($inIdx <= $endIdx) {
2051	$tempReal = $inReal[$trailingIdx++];
2052	if ($tempReal != 0.0) {
2053	$outReal[$outIdx++] = ($inReal[$inIdx] - $tempReal) / $tempReal;
2054	} else {
2055	$outReal[$outIdx++] = 0.0;
2056	}
2057	$inIdx++;
2058	}
2059	$outNBElement = $outIdx;
2060	$outBegIdx = $startIdx;
2061
2062	return ReturnCode::Success;
2063	}
2064
2065	/**
2066	* @param int $startIdx
2067	* @param int $endIdx
2068	* @param array $inReal
2069	* @param int $optInTimePeriod
2070	* @param int $outBegIdx
2071	* @param int $outNBElement
2072	* @param array $outReal
2073	*
2074	* @return int
2075	*/
2076	public static function rocR(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
2077	{
2078	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2079	return $RetCode;
2080	}
2081	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
2082	$optInTimePeriod = 10;
2083	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
2084	return ReturnCode::BadParam;
2085	}
2086	if ($startIdx < $optInTimePeriod) {
2087	$startIdx = $optInTimePeriod;
2088	}
2089	if ($startIdx > $endIdx) {
2090	$outBegIdx = 0;
2091	$outNBElement = 0;
2092
2093	return ReturnCode::Success;
2094	}
2095	$outIdx = 0;
2096	$inIdx = $startIdx;
2097	$trailingIdx = $startIdx - $optInTimePeriod;
2098	while ($inIdx <= $endIdx) {
2099	$tempReal = $inReal[$trailingIdx++];
2100	if ($tempReal != 0.0) {
2101	$outReal[$outIdx++] = ($inReal[$inIdx] / $tempReal);
2102	} else {
2103	$outReal[$outIdx++] = 0.0;
2104	}
2105	$inIdx++;
2106	}
2107	$outNBElement = $outIdx;
2108	$outBegIdx = $startIdx;
2109
2110	return ReturnCode::Success;
2111	}
2112
2113	/**
2114	* @param int $startIdx
2115	* @param int $endIdx
2116	* @param array $inReal
2117	* @param int $optInTimePeriod
2118	* @param int $outBegIdx
2119	* @param int $outNBElement
2120	* @param array $outReal
2121	*
2122	* @return int
2123	*/
2124	public static function rocR100(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
2125	{
2126	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2127	return $RetCode;
2128	}
2129	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
2130	$optInTimePeriod = 10;
2131	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
2132	return ReturnCode::BadParam;
2133	}
2134	if ($startIdx < $optInTimePeriod) {
2135	$startIdx = $optInTimePeriod;
2136	}
2137	if ($startIdx > $endIdx) {
2138	$outBegIdx = 0;
2139	$outNBElement = 0;
2140
2141	return ReturnCode::Success;
2142	}
2143	$outIdx = 0;
2144	$inIdx = $startIdx;
2145	$trailingIdx = $startIdx - $optInTimePeriod;
2146	while ($inIdx <= $endIdx) {
2147	$tempReal = $inReal[$trailingIdx++];
2148	if ($tempReal != 0.0) {
2149	$outReal[$outIdx++] = ($inReal[$inIdx] / $tempReal) * 100.0;
2150	} else {
2151	$outReal[$outIdx++] = 0.0;
2152	}
2153	$inIdx++;
2154	}
2155	$outNBElement = $outIdx;
2156	$outBegIdx = $startIdx;
2157
2158	return ReturnCode::Success;
2159	}
2160
2161	/**
2162	* @param int $startIdx
2163	* @param int $endIdx
2164	* @param array $inReal
2165	* @param int $optInTimePeriod
2166	* @param int $outBegIdx
2167	* @param int $outNBElement
2168	* @param array $outReal
2169	*
2170	* @return int
2171	*/
2172	public static function rsi(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
2173	{
2174	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2175	return $RetCode;
2176	}
2177	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
2178	$optInTimePeriod = 14;
2179	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
2180	return ReturnCode::BadParam;
2181	}
2182	$outBegIdx = 0;
2183	$outNBElement = 0;
2184	$lookbackTotal = Lookback::rsiLookback($optInTimePeriod);
2185	if ($startIdx < $lookbackTotal) {
2186	$startIdx = $lookbackTotal;
2187	}
2188	if ($startIdx > $endIdx) {
2189	return ReturnCode::Success;
2190	}
2191	$outIdx = 0;
2192	if ($optInTimePeriod == 1) {
2193	$outBegIdx = $startIdx;
2194	$i = ($endIdx - $startIdx) + 1;
2195	$outNBElement = $i;
2196	//System::arraycopy($inReal, $startIdx, $outReal, 0, $i);
2197	$outReal = \array_slice($inReal, $startIdx, $i);
2198
2199	return ReturnCode::Success;
2200	}
2201	$today = $startIdx - $lookbackTotal;
2202	$prevValue = $inReal[$today];
2203	$unstablePeriod = (static::$unstablePeriod[UnstablePeriodFunctionID::RSI]);
2204	if (($unstablePeriod == 0) &&
2205	((static::$compatibility) == Compatibility::Metastock)) {
2206	$savePrevValue = $prevValue;
2207	$prevGain = 0.0;
2208	$prevLoss = 0.0;
2209	for ($i = $optInTimePeriod; $i > 0; $i--) {
2210	$tempValue1 = $inReal[$today++];
2211	$tempValue2 = $tempValue1 - $prevValue;
2212	$prevValue = $tempValue1;
2213	if ($tempValue2 < 0) {
2214	$prevLoss -= $tempValue2;
2215	} else {
2216	$prevGain += $tempValue2;
2217	}
2218	}
2219	$tempValue1 = $prevLoss / $optInTimePeriod;
2220	$tempValue2 = $prevGain / $optInTimePeriod;
2221	$tempValue1 = $tempValue2 + $tempValue1;
2222	if (!(((-0.00000001) < $tempValue1) && ($tempValue1 < 0.00000001))) {
2223	$outReal[$outIdx++] = 100 * ($tempValue2 / $tempValue1);
2224	} else {
2225	$outReal[$outIdx++] = 0.0;
2226	}
2227	if ($today > $endIdx) {
2228	$outBegIdx = $startIdx;
2229	$outNBElement = $outIdx;
2230
2231	return ReturnCode::Success;
2232	}
2233	$today -= $optInTimePeriod;
2234	$prevValue = $savePrevValue;
2235	}
2236	$prevGain = 0.0;
2237	$prevLoss = 0.0;
2238	$today++;
2239	for ($i = $optInTimePeriod; $i > 0; $i--) {
2240	$tempValue1 = $inReal[$today++];
2241	$tempValue2 = $tempValue1 - $prevValue;
2242	$prevValue = $tempValue1;
2243	if ($tempValue2 < 0) {
2244	$prevLoss -= $tempValue2;
2245	} else {
2246	$prevGain += $tempValue2;
2247	}
2248	}
2249	$prevLoss /= $optInTimePeriod;
2250	$prevGain /= $optInTimePeriod;
2251	if ($today > $startIdx) {
2252	$tempValue1 = $prevGain + $prevLoss;
2253	if (!(((-0.00000001) < $tempValue1) && ($tempValue1 < 0.00000001))) {
2254	$outReal[$outIdx++] = 100.0 * ($prevGain / $tempValue1);
2255	} else {
2256	$outReal[$outIdx++] = 0.0;
2257	}
2258	} else {
2259	while ($today < $startIdx) {
2260	$tempValue1 = $inReal[$today];
2261	$tempValue2 = $tempValue1 - $prevValue;
2262	$prevValue = $tempValue1;
2263	$prevLoss *= ($optInTimePeriod - 1);
2264	$prevGain *= ($optInTimePeriod - 1);
2265	if ($tempValue2 < 0) {
2266	$prevLoss -= $tempValue2;
2267	} else {
2268	$prevGain += $tempValue2;
2269	}
2270	$prevLoss /= $optInTimePeriod;
2271	$prevGain /= $optInTimePeriod;
2272	$today++;
2273	}
2274	}
2275	while ($today <= $endIdx) {
2276	$tempValue1 = $inReal[$today++];
2277	$tempValue2 = $tempValue1 - $prevValue;
2278	$prevValue = $tempValue1;
2279	$prevLoss *= ($optInTimePeriod - 1);
2280	$prevGain *= ($optInTimePeriod - 1);
2281	if ($tempValue2 < 0) {
2282	$prevLoss -= $tempValue2;
2283	} else {
2284	$prevGain += $tempValue2;
2285	}
2286	$prevLoss /= $optInTimePeriod;
2287	$prevGain /= $optInTimePeriod;
2288	$tempValue1 = $prevGain + $prevLoss;
2289	if (!(((-0.00000001) < $tempValue1) && ($tempValue1 < 0.00000001))) {
2290	$outReal[$outIdx++] = 100.0 * ($prevGain / $tempValue1);
2291	} else {
2292	$outReal[$outIdx++] = 0.0;
2293	}
2294	}
2295	$outBegIdx = $startIdx;
2296	$outNBElement = $outIdx;
2297
2298	return ReturnCode::Success;
2299	}
2300
2301	/**
2302	* @param int $startIdx
2303	* @param int $endIdx
2304	* @param array $inHigh
2305	* @param array $inLow
2306	* @param array $inClose
2307	* @param int $optInFastK_Period
2308	* @param int $optInSlowK_Period
2309	* @param int $optInSlowK_MAType
2310	* @param int $optInSlowD_Period
2311	* @param int $optInSlowD_MAType
2312	* @param int $outBegIdx
2313	* @param int $outNBElement
2314	* @param array $outSlowK
2315	* @param array $outSlowD
2316	*
2317	* @return int
2318	*/
2319	public static function stoch(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInFastK_Period, int $optInSlowK_Period, int $optInSlowK_MAType, int $optInSlowD_Period, int $optInSlowD_MAType, int &$outBegIdx, int &$outNBElement, array &$outSlowK, array &$outSlowD): int
2320	{
2321	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2322	return $RetCode;
2323	}
2324	if ((int)$optInFastK_Period == (PHP_INT_MIN)) {
2325	$optInFastK_Period = 5;
2326	} elseif (((int)$optInFastK_Period < 1) \|\| ((int)$optInFastK_Period > 100000)) {
2327	return ReturnCode::BadParam;
2328	}
2329	if ((int)$optInSlowK_Period == (PHP_INT_MIN)) {
2330	$optInSlowK_Period = 3;
2331	} elseif (((int)$optInSlowK_Period < 1) \|\| ((int)$optInSlowK_Period > 100000)) {
2332	return ReturnCode::BadParam;
2333	}
2334	if ((int)$optInSlowD_Period == (PHP_INT_MIN)) {
2335	$optInSlowD_Period = 3;
2336	} elseif (((int)$optInSlowD_Period < 1) \|\| ((int)$optInSlowD_Period > 100000)) {
2337	return ReturnCode::BadParam;
2338	}
2339	$lookbackK = $optInFastK_Period - 1;
2340	$lookbackKSlow = Lookback::movingAverageLookback($optInSlowK_Period, $optInSlowK_MAType);
2341	$lookbackDSlow = Lookback::movingAverageLookback($optInSlowD_Period, $optInSlowD_MAType);
2342	$lookbackTotal = $lookbackK + $lookbackDSlow + $lookbackKSlow;
2343	if ($startIdx < $lookbackTotal) {
2344	$startIdx = $lookbackTotal;
2345	}
2346	if ($startIdx > $endIdx) {
2347	$outBegIdx = 0;
2348	$outNBElement = 0;
2349
2350	return ReturnCode::Success;
2351	}
2352	$outIdx = 0;
2353	$trailingIdx = $startIdx - $lookbackTotal;
2354	$today = $trailingIdx + $lookbackK;
2355	$lowestIdx = $highestIdx = -1;
2356	$diff = $highest = $lowest = 0.0;
2357	if (($outSlowK == $inHigh) \|\|
2358	($outSlowK == $inLow) \|\|
2359	($outSlowK == $inClose)) {
2360	$tempBuffer = $outSlowK;
2361	} elseif (($outSlowD == $inHigh) \|\|
2362	($outSlowD == $inLow) \|\|
2363	($outSlowD == $inClose)) {
2364	$tempBuffer = $outSlowD;
2365	} else {
2366	$tempBuffer = static::double($endIdx - $today + 1);
2367	}
2368	while ($today <= $endIdx) {
2369	$tmp = $inLow[$today];
2370	if ($lowestIdx < $trailingIdx) {
2371	$lowestIdx = $trailingIdx;
2372	$lowest = $inLow[$lowestIdx];
2373	$i = $lowestIdx;
2374	while (++$i <= $today) {
2375	$tmp = $inLow[$i];
2376	if ($tmp < $lowest) {
2377	$lowestIdx = $i;
2378	$lowest = $tmp;
2379	}
2380	}
2381	$diff = ($highest - $lowest) / 100.0;
2382	} elseif ($tmp <= $lowest) {
2383	$lowestIdx = $today;
2384	$lowest = $tmp;
2385	$diff = ($highest - $lowest) / 100.0;
2386	}
2387	$tmp = $inHigh[$today];
2388	if ($highestIdx < $trailingIdx) {
2389	$highestIdx = $trailingIdx;
2390	$highest = $inHigh[$highestIdx];
2391	$i = $highestIdx;
2392	while (++$i <= $today) {
2393	$tmp = $inHigh[$i];
2394	if ($tmp > $highest) {
2395	$highestIdx = $i;
2396	$highest = $tmp;
2397	}
2398	}
2399	$diff = ($highest - $lowest) / 100.0;
2400	} elseif ($tmp >= $highest) {
2401	$highestIdx = $today;
2402	$highest = $tmp;
2403	$diff = ($highest - $lowest) / 100.0;
2404	}
2405	if ($diff != 0.0) {
2406	$tempBuffer[$outIdx++] = ($inClose[$today] - $lowest) / $diff;
2407	} else {
2408	$tempBuffer[$outIdx++] = 0.0;
2409	}
2410	$trailingIdx++;
2411	$today++;
2412	}
2413	$ReturnCode = OverlapStudies::movingAverage(
2414	0, $outIdx - 1,
2415	$tempBuffer, $optInSlowK_Period,
2416	$optInSlowK_MAType,
2417	$outBegIdx, $outNBElement, $tempBuffer
2418	);
2419	if (($ReturnCode != ReturnCode::Success) \|\| ((int)$outNBElement == 0)) {
2420	$outBegIdx = 0;
2421	$outNBElement = 0;
2422
2423	return $ReturnCode;
2424	}
2425	$ReturnCode = OverlapStudies::movingAverage(
2426	0, (int)$outNBElement - 1,
2427	$tempBuffer, $optInSlowD_Period,
2428	$optInSlowD_MAType,
2429	$outBegIdx, $outNBElement, $outSlowD
2430	);
2431	//System::arraycopy($tempBuffer, $lookbackDSlow, $outSlowK, 0, (int)$outNBElement);
2432	$outSlowK = \array_slice($tempBuffer, $lookbackDSlow, (int)$outNBElement);
2433	if ($ReturnCode != ReturnCode::Success) {
2434	$outBegIdx = 0;
2435	$outNBElement = 0;
2436
2437	return $ReturnCode;
2438	}
2439	$outBegIdx = $startIdx;
2440
2441	return ReturnCode::Success;
2442	}
2443
2444	/**
2445	* @param int $startIdx
2446	* @param int $endIdx
2447	* @param array $inHigh
2448	* @param array $inLow
2449	* @param array $inClose
2450	* @param int $optInFastK_Period
2451	* @param int $optInFastD_Period
2452	* @param int $optInFastD_MAType
2453	* @param int $outBegIdx
2454	* @param int $outNBElement
2455	* @param array $outFastK
2456	* @param array $outFastD
2457	*
2458	* @return int
2459	*/
2460	public static function stochF(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInFastK_Period, int $optInFastD_Period, int $optInFastD_MAType, int &$outBegIdx, int &$outNBElement, array &$outFastK, array &$outFastD): int
2461	{
2462	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2463	return $RetCode;
2464	}
2465	if ((int)$optInFastK_Period == (PHP_INT_MIN)) {
2466	$optInFastK_Period = 5;
2467	} elseif (((int)$optInFastK_Period < 1) \|\| ((int)$optInFastK_Period > 100000)) {
2468	return ReturnCode::BadParam;
2469	}
2470	if ((int)$optInFastD_Period == (PHP_INT_MIN)) {
2471	$optInFastD_Period = 3;
2472	} elseif (((int)$optInFastD_Period < 1) \|\| ((int)$optInFastD_Period > 100000)) {
2473	return ReturnCode::BadParam;
2474	}
2475	$lookbackK = $optInFastK_Period - 1;
2476	$lookbackFastD = Lookback::movingAverageLookback($optInFastD_Period, $optInFastD_MAType);
2477	$lookbackTotal = $lookbackK + $lookbackFastD;
2478	if ($startIdx < $lookbackTotal) {
2479	$startIdx = $lookbackTotal;
2480	}
2481	if ($startIdx > $endIdx) {
2482	$outBegIdx = 0;
2483	$outNBElement = 0;
2484
2485	return ReturnCode::Success;
2486	}
2487	$outIdx = 0;
2488	$trailingIdx = $startIdx - $lookbackTotal;
2489	$today = $trailingIdx + $lookbackK;
2490	$lowestIdx = $highestIdx = -1;
2491	$diff = $highest = $lowest = 0.0;
2492	if (($outFastK == $inHigh) \|\|
2493	($outFastK == $inLow) \|\|
2494	($outFastK == $inClose)) {
2495	$tempBuffer = $outFastK;
2496	} elseif (($outFastD == $inHigh) \|\|
2497	($outFastD == $inLow) \|\|
2498	($outFastD == $inClose)) {
2499	$tempBuffer = $outFastD;
2500	} else {
2501	$tempBuffer = static::double($endIdx - $today + 1);
2502	}
2503	while ($today <= $endIdx) {
2504	$tmp = $inLow[$today];
2505	if ($lowestIdx < $trailingIdx) {
2506	$lowestIdx = $trailingIdx;
2507	$lowest = $inLow[$lowestIdx];
2508	$i = $lowestIdx;
2509	while (++$i <= $today) {
2510	$tmp = $inLow[$i];
2511	if ($tmp < $lowest) {
2512	$lowestIdx = $i;
2513	$lowest = $tmp;
2514	}
2515	}
2516	$diff = ($highest - $lowest) / 100.0;
2517	} elseif ($tmp <= $lowest) {
2518	$lowestIdx = $today;
2519	$lowest = $tmp;
2520	$diff = ($highest - $lowest) / 100.0;
2521	}
2522	$tmp = $inHigh[$today];
2523	if ($highestIdx < $trailingIdx) {
2524	$highestIdx = $trailingIdx;
2525	$highest = $inHigh[$highestIdx];
2526	$i = $highestIdx;
2527	while (++$i <= $today) {
2528	$tmp = $inHigh[$i];
2529	if ($tmp > $highest) {
2530	$highestIdx = $i;
2531	$highest = $tmp;
2532	}
2533	}
2534	$diff = ($highest - $lowest) / 100.0;
2535	} elseif ($tmp >= $highest) {
2536	$highestIdx = $today;
2537	$highest = $tmp;
2538	$diff = ($highest - $lowest) / 100.0;
2539	}
2540	if ($diff != 0.0) {
2541	$tempBuffer[$outIdx++] = ($inClose[$today] - $lowest) / $diff;
2542	} else {
2543	$tempBuffer[$outIdx++] = 0.0;
2544	}
2545	$trailingIdx++;
2546	$today++;
2547	}
2548	$ReturnCode = OverlapStudies::movingAverage(
2549	0, $outIdx - 1,
2550	$tempBuffer, $optInFastD_Period,
2551	$optInFastD_MAType,
2552	$outBegIdx, $outNBElement, $outFastD
2553	);
2554	if (($ReturnCode != ReturnCode::Success) \|\| ((int)$outNBElement) == 0) {
2555	$outBegIdx = 0;
2556	$outNBElement = 0;
2557
2558	return $ReturnCode;
2559	}
2560	//System::arraycopy($tempBuffer, $lookbackFastD, $outFastK, 0, (int)$outNBElement);
2561	$outFastK = \array_slice($tempBuffer, $lookbackFastD, (int)$outNBElement);
2562	if ($ReturnCode != ReturnCode::Success) {
2563	$outBegIdx = 0;
2564	$outNBElement = 0;
2565
2566	return $ReturnCode;
2567	}
2568	$outBegIdx = $startIdx;
2569
2570	return ReturnCode::Success;
2571	}
2572
2573	/**
2574	* @param int $startIdx
2575	* @param int $endIdx
2576	* @param array $inReal
2577	* @param int $optInTimePeriod
2578	* @param int $optInFastK_Period
2579	* @param int $optInFastD_Period
2580	* @param int $optInFastD_MAType
2581	* @param int $outBegIdx
2582	* @param int $outNBElement
2583	* @param array $outFastK
2584	* @param array $outFastD
2585	*
2586	* @return int
2587	*/
2588	public static function stochRsi(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int $optInFastK_Period, int $optInFastD_Period, int $optInFastD_MAType, int &$outBegIdx, int &$outNBElement, array &$outFastK, array &$outFastD): int
2589	{
2590	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2591	return $RetCode;
2592	}
2593	$outBegIdx1 = 0;
2594	$outBegIdx2 = 0;
2595	$outNbElement1 = 0;
2596	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
2597	$optInTimePeriod = 14;
2598	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
2599	return ReturnCode::BadParam;
2600	}
2601	if ((int)$optInFastK_Period == (PHP_INT_MIN)) {
2602	$optInFastK_Period = 5;
2603	} elseif (((int)$optInFastK_Period < 1) \|\| ((int)$optInFastK_Period > 100000)) {
2604	return ReturnCode::BadParam;
2605	}
2606	if ((int)$optInFastD_Period == (PHP_INT_MIN)) {
2607	$optInFastD_Period = 3;
2608	} elseif (((int)$optInFastD_Period < 1) \|\| ((int)$optInFastD_Period > 100000)) {
2609	return ReturnCode::BadParam;
2610	}
2611	$outBegIdx = 0;
2612	$outNBElement = 0;
2613	$lookbackSTOCHF = Lookback::stochFLookback($optInFastK_Period, $optInFastD_Period, $optInFastD_MAType);
2614	$lookbackTotal = Lookback::rsiLookback($optInTimePeriod) + $lookbackSTOCHF;
2615	if ($startIdx < $lookbackTotal) {
2616	$startIdx = $lookbackTotal;
2617	}
2618	if ($startIdx > $endIdx) {
2619	$outBegIdx = 0;
2620	$outNBElement = 0;
2621
2622	return ReturnCode::Success;
2623	}
2624	$outBegIdx = $startIdx;
2625	$tempArraySize = ($endIdx - $startIdx) + 1 + $lookbackSTOCHF;
2626	$tempRSIBuffer = static::double($tempArraySize);
2627	$ReturnCode = self::rsi(
2628	$startIdx - $lookbackSTOCHF,
2629	$endIdx,
2630	$inReal,
2631	$optInTimePeriod,
2632	$outBegIdx1,
2633	$outNbElement1,
2634	$tempRSIBuffer
2635	);
2636	if ($ReturnCode != ReturnCode::Success \|\| $outNbElement1 == 0) {
2637	$outBegIdx = 0;
2638	$outNBElement = 0;
2639
2640	return $ReturnCode;
2641	}
2642	$ReturnCode = self::stochF(
2643	0,
2644	$tempArraySize - 1,
2645	$tempRSIBuffer,
2646	$tempRSIBuffer,
2647	$tempRSIBuffer,
2648	$optInFastK_Period,
2649	$optInFastD_Period,
2650	$optInFastD_MAType,
2651	$outBegIdx2,
2652	$outNBElement,
2653	$outFastK,
2654	$outFastD
2655	);
2656	if ($ReturnCode != ReturnCode::Success \|\| ((int)$outNBElement) == 0) {
2657	$outBegIdx = 0;
2658	$outNBElement = 0;
2659
2660	return $ReturnCode;
2661	}
2662
2663	return ReturnCode::Success;
2664	}
2665
2666	/**
2667	* @param int $startIdx
2668	* @param int $endIdx
2669	* @param array $inReal
2670	* @param int $optInTimePeriod
2671	* @param int $outBegIdx
2672	* @param int $outNBElement
2673	* @param array $outReal
2674	*
2675	* @return int
2676	*/
2677	public static function trix(int $startIdx, int $endIdx, array $inReal, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
2678	{
2679	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2680	return $RetCode;
2681	}
2682	$nbElement = 0;
2683	$begIdx = 0;
2684	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
2685	$optInTimePeriod = 30;
2686	} elseif (((int)$optInTimePeriod < 1) \|\| ((int)$optInTimePeriod > 100000)) {
2687	return ReturnCode::BadParam;
2688	}
2689	$emaLookback = Lookback::emaLookback($optInTimePeriod);
2690	$rocLookback = Lookback::rocRLookback(1);
2691	$totalLookback = ($emaLookback * 3) + $rocLookback;
2692	if ($startIdx < $totalLookback) {
2693	$startIdx = $totalLookback;
2694	}
2695	if ($startIdx > $endIdx) {
2696	$outNBElement = 0;
2697	$outBegIdx = 0;
2698
2699	return ReturnCode::Success;
2700	}
2701	$outBegIdx = $startIdx;
2702	$nbElementToOutput = ($endIdx - $startIdx) + 1 + $totalLookback;
2703	$tempBuffer = static::double($nbElementToOutput);
2704	$k = ((double)2.0 / ((double)($optInTimePeriod + 1)));
2705	$ReturnCode = static::TA_INT_EMA(
2706	($startIdx - $totalLookback), $endIdx, $inReal,
2707	$optInTimePeriod, $k,
2708	$begIdx, $nbElement,
2709	$tempBuffer
2710	);
2711	if (($ReturnCode != ReturnCode::Success) \|\| ($nbElement == 0)) {
2712	$outNBElement = 0;
2713	$outBegIdx = 0;
2714
2715	return $ReturnCode;
2716	}
2717	$nbElementToOutput--;
2718	$nbElementToOutput -= $emaLookback;
2719	$ReturnCode = static::TA_INT_EMA(
2720	0, $nbElementToOutput, $tempBuffer,
2721	$optInTimePeriod, $k,
2722	$begIdx, $nbElement,
2723	$tempBuffer
2724	);
2725	if (($ReturnCode != ReturnCode::Success) \|\| ($nbElement == 0)) {
2726	$outNBElement = 0;
2727	$outBegIdx = 0;
2728
2729	return $ReturnCode;
2730	}
2731	$nbElementToOutput -= $emaLookback;
2732	$ReturnCode = static::TA_INT_EMA(
2733	0, $nbElementToOutput, $tempBuffer,
2734	$optInTimePeriod, $k,
2735	$begIdx, $nbElement,
2736	$tempBuffer
2737	);
2738	if (($ReturnCode != ReturnCode::Success) \|\| ($nbElement == 0)) {
2739	$outNBElement = 0;
2740	$outBegIdx = 0;
2741
2742	return $ReturnCode;
2743	}
2744	$nbElementToOutput -= $emaLookback;
2745	$ReturnCode = self::roc(
2746	0, $nbElementToOutput,
2747	$tempBuffer,
2748	1, $begIdx, $outNBElement,
2749	$outReal
2750	);
2751	if (($ReturnCode != ReturnCode::Success) \|\| ((int)$outNBElement == 0)) {
2752	$outNBElement = 0;
2753	$outBegIdx = 0;
2754
2755	return $ReturnCode;
2756	}
2757
2758	return ReturnCode::Success;
2759	}
2760
2761	/**
2762	* @param int $startIdx
2763	* @param int $endIdx
2764	* @param array $inHigh
2765	* @param array $inLow
2766	* @param array $inClose
2767	* @param int $optInTimePeriod1
2768	* @param int $optInTimePeriod2
2769	* @param int $optInTimePeriod3
2770	* @param int $outBegIdx
2771	* @param int $outNBElement
2772	* @param array $outReal
2773	*
2774	* @return int
2775	*/
2776	public static function ultOsc(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInTimePeriod1, int $optInTimePeriod2, int $optInTimePeriod3, int &$outBegIdx, int &$outNBElement, array &$outReal): int
2777	{
2778	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
2779	return $RetCode;
2780	}
2781	$usedFlag = \array_pad([], 3, 0);
2782	$periods = \array_pad([], 3, 0);
2783	$sortedPeriods = \array_pad([], 3, 0);
2784	if ((int)$optInTimePeriod1 == (PHP_INT_MIN)) {
2785	$optInTimePeriod1 = 7;
2786	} elseif (((int)$optInTimePeriod1 < 1) \|\| ((int)$optInTimePeriod1 > 100000)) {
2787	return ReturnCode::BadParam;
2788	}
2789	if ((int)$optInTimePeriod2 == (PHP_INT_MIN)) {
2790	$optInTimePeriod2 = 14;
2791	} elseif (((int)$optInTimePeriod2 < 1) \|\| ((int)$optInTimePeriod2 > 100000)) {
2792	return ReturnCode::BadParam;
2793	}
2794	if ((int)$optInTimePeriod3 == (PHP_INT_MIN)) {
2795	$optInTimePeriod3 = 28;
2796	} elseif (((int)$optInTimePeriod3 < 1) \|\| ((int)$optInTimePeriod3 > 100000)) {
2797	return ReturnCode::BadParam;
2798	}
2799	$outBegIdx = 0;
2800	$outNBElement = 0;
2801	$periods[0] = $optInTimePeriod1;
2802	$periods[1] = $optInTimePeriod2;
2803	$periods[2] = $optInTimePeriod3;
2804	$usedFlag[0] = 0;
2805	$usedFlag[1] = 0;
2806	$usedFlag[2] = 0;
2807	for ($i = 0; $i < 3; ++$i) {
2808	$longestPeriod = 0;
2809	$longestIndex = 0;
2810	for ($j = 0; $j < 3; ++$j) {
2811	if (($usedFlag[$j] == 0) && ($periods[$j] > $longestPeriod)) {
2812	$longestPeriod = $periods[$j];
2813	$longestIndex = $j;
2814	}
2815	}
2816	$usedFlag[$longestIndex] = 1;
2817	$sortedPeriods[$i] = $longestPeriod;
2818	}
2819	$optInTimePeriod1 = $sortedPeriods[2];
2820	$optInTimePeriod2 = $sortedPeriods[1];
2821	$optInTimePeriod3 = $sortedPeriods[0];
2822	$lookbackTotal = Lookback::ultOscLookback($optInTimePeriod1, $optInTimePeriod2, $optInTimePeriod3);
2823	if ($startIdx < $lookbackTotal) {
2824	$startIdx = $lookbackTotal;
2825	}
2826	if ($startIdx > $endIdx) {
2827	return ReturnCode::Success;
2828	}
2829	{
2830	$a1Total = 0;
2831	$b1Total = 0;
2832	for ($i = $startIdx - $optInTimePeriod1 + 1; $i < $startIdx; ++$i) {
2833	{
2834	$tempLT = $inLow[$i];
2835	$tempHT = $inHigh[$i];
2836	$tempCY = $inClose[$i - 1];
2837	$trueLow = ((($tempLT) < ($tempCY)) ? ($tempLT) : ($tempCY));
2838	$closeMinusTrueLow = $inClose[$i] - $trueLow;
2839	$trueRange = $tempHT - $tempLT;
2840	$tempDouble = abs($tempCY - $tempHT);
2841	if ($tempDouble > $trueRange) {
2842	$trueRange = $tempDouble;
2843	}
2844	$tempDouble = abs($tempCY - $tempLT);
2845	if ($tempDouble > $trueRange) {
2846	$trueRange = $tempDouble;
2847	}
2848	};
2849	$a1Total += $closeMinusTrueLow;
2850	$b1Total += $trueRange;
2851	}
2852	};
2853	{
2854	$a2Total = 0;
2855	$b2Total = 0;
2856	for ($i = $startIdx - $optInTimePeriod2 + 1; $i < $startIdx; ++$i) {
2857	{
2858	$tempLT = $inLow[$i];
2859	$tempHT = $inHigh[$i];
2860	$tempCY = $inClose[$i - 1];
2861	$trueLow = ((($tempLT) < ($tempCY)) ? ($tempLT) : ($tempCY));
2862	$closeMinusTrueLow = $inClose[$i] - $trueLow;
2863	$trueRange = $tempHT - $tempLT;
2864	$tempDouble = abs($tempCY - $tempHT);
2865	if ($tempDouble > $trueRange) {
2866	$trueRange = $tempDouble;
2867	}
2868	$tempDouble = abs($tempCY - $tempLT);
2869	if ($tempDouble > $trueRange) {
2870	$trueRange = $tempDouble;
2871	}
2872	};
2873	$a2Total += $closeMinusTrueLow;
2874	$b2Total += $trueRange;
2875	}
2876	};
2877	{
2878	$a3Total = 0;
2879	$b3Total = 0;
2880	for ($i = $startIdx - $optInTimePeriod3 + 1; $i < $startIdx; ++$i) {
2881	{
2882	$tempLT = $inLow[$i];
2883	$tempHT = $inHigh[$i];
2884	$tempCY = $inClose[$i - 1];
2885	$trueLow = ((($tempLT) < ($tempCY)) ? ($tempLT) : ($tempCY));
2886	$closeMinusTrueLow = $inClose[$i] - $trueLow;
2887	$trueRange = $tempHT - $tempLT;
2888	$tempDouble = abs($tempCY - $tempHT);
2889	if ($tempDouble > $trueRange) {
2890	$trueRange = $tempDouble;
2891	}
2892	$tempDouble = abs($tempCY - $tempLT);
2893	if ($tempDouble > $trueRange) {
2894	$trueRange = $tempDouble;
2895	}
2896	};
2897	$a3Total += $closeMinusTrueLow;
2898	$b3Total += $trueRange;
2899	}
2900	};
2901	$today = $startIdx;
2902	$outIdx = 0;
2903	$trailingIdx1 = $today - $optInTimePeriod1 + 1;
2904	$trailingIdx2 = $today - $optInTimePeriod2 + 1;
2905	$trailingIdx3 = $today - $optInTimePeriod3 + 1;
2906	while ($today <= $endIdx) {
2907	{
2908	$tempLT = $inLow[$today];
2909	$tempHT = $inHigh[$today];
2910	$tempCY = $inClose[$today - 1];
2911	$trueLow = ((($tempLT) < ($tempCY)) ? ($tempLT) : ($tempCY));
2912	$closeMinusTrueLow = $inClose[$today] - $trueLow;
2913	$trueRange = $tempHT - $tempLT;
2914	$tempDouble = abs($tempCY - $tempHT);
2915	if ($tempDouble > $trueRange) {
2916	$trueRange = $tempDouble;
2917	}
2918	$tempDouble = abs($tempCY - $tempLT);
2919	if ($tempDouble > $trueRange) {
2920	$trueRange = $tempDouble;
2921	}
2922	};
2923	$a1Total += $closeMinusTrueLow;
2924	$a2Total += $closeMinusTrueLow;
2925	$a3Total += $closeMinusTrueLow;
2926	$b1Total += $trueRange;
2927	$b2Total += $trueRange;
2928	$b3Total += $trueRange;
2929	$output = 0.0;
2930	if (!(((-0.00000001) < $b1Total) && ($b1Total < 0.00000001))) {
2931	$output += 4.0 * ($a1Total / $b1Total);
2932	}
2933	if (!(((-0.00000001) < $b2Total) && ($b2Total < 0.00000001))) {
2934	$output += 2.0 * ($a2Total / $b2Total);
2935	}
2936	if (!(((-0.00000001) < $b3Total) && ($b3Total < 0.00000001))) {
2937	$output += $a3Total / $b3Total;
2938	}
2939	{
2940	$tempLT = $inLow[$trailingIdx1];
2941	$tempHT = $inHigh[$trailingIdx1];
2942	$tempCY = $inClose[$trailingIdx1 - 1];
2943	$trueLow = ((($tempLT) < ($tempCY)) ? ($tempLT) : ($tempCY));
2944	$closeMinusTrueLow = $inClose[$trailingIdx1] - $trueLow;
2945	$trueRange = $tempHT - $tempLT;
2946	$tempDouble = abs($tempCY - $tempHT);
2947	if ($tempDouble > $trueRange) {
2948	$trueRange = $tempDouble;
2949	}
2950	$tempDouble = abs($tempCY - $tempLT);
2951	if ($tempDouble > $trueRange) {
2952	$trueRange = $tempDouble;
2953	}
2954	};
2955	$a1Total -= $closeMinusTrueLow;
2956	$b1Total -= $trueRange;
2957	{
2958	$tempLT = $inLow[$trailingIdx2];
2959	$tempHT = $inHigh[$trailingIdx2];
2960	$tempCY = $inClose[$trailingIdx2 - 1];
2961	$trueLow = ((($tempLT) < ($tempCY)) ? ($tempLT) : ($tempCY));
2962	$closeMinusTrueLow = $inClose[$trailingIdx2] - $trueLow;
2963	$trueRange = $tempHT - $tempLT;
2964	$tempDouble = abs($tempCY - $tempHT);
2965	if ($tempDouble > $trueRange) {
2966	$trueRange = $tempDouble;
2967	}
2968	$tempDouble = abs($tempCY - $tempLT);
2969	if ($tempDouble > $trueRange) {
2970	$trueRange = $tempDouble;
2971	}
2972	};
2973	$a2Total -= $closeMinusTrueLow;
2974	$b2Total -= $trueRange;
2975	{
2976	$tempLT = $inLow[$trailingIdx3];
2977	$tempHT = $inHigh[$trailingIdx3];
2978	$tempCY = $inClose[$trailingIdx3 - 1];
2979	$trueLow = ((($tempLT) < ($tempCY)) ? ($tempLT) : ($tempCY));
2980	$closeMinusTrueLow = $inClose[$trailingIdx3] - $trueLow;
2981	$trueRange = $tempHT - $tempLT;
2982	$tempDouble = abs($tempCY - $tempHT);
2983	if ($tempDouble > $trueRange) {
2984	$trueRange = $tempDouble;
2985	}
2986	$tempDouble = abs($tempCY - $tempLT);
2987	if ($tempDouble > $trueRange) {
2988	$trueRange = $tempDouble;
2989	}
2990	};
2991	$a3Total -= $closeMinusTrueLow;
2992	$b3Total -= $trueRange;
2993	$outReal[$outIdx] = 100.0 * ($output / 7.0);
2994	$outIdx++;
2995	$today++;
2996	$trailingIdx1++;
2997	$trailingIdx2++;
2998	$trailingIdx3++;
2999	}
3000	$outNBElement = $outIdx;
3001	$outBegIdx = $startIdx;
3002
3003	return ReturnCode::Success;
3004	}
3005
3006	/**
3007	* @param int $startIdx
3008	* @param int $endIdx
3009	* @param array $inHigh
3010	* @param array $inLow
3011	* @param array $inClose
3012	* @param int $optInTimePeriod
3013	* @param int $outBegIdx
3014	* @param int $outNBElement
3015	* @param array $outReal
3016	*
3017	* @return int
3018	*/
3019	public static function willR(int $startIdx, int $endIdx, array $inHigh, array $inLow, array $inClose, int $optInTimePeriod, int &$outBegIdx, int &$outNBElement, array &$outReal): int
3020	{
3021	if ($RetCode = static::validateStartEndIndexes($startIdx, $endIdx)) {
3022	return $RetCode;
3023	}
3024	if ((int)$optInTimePeriod == (PHP_INT_MIN)) {
3025	$optInTimePeriod = 14;
3026	} elseif (((int)$optInTimePeriod < 2) \|\| ((int)$optInTimePeriod > 100000)) {
3027	return ReturnCode::BadParam;
3028	}
3029	$nbInitialElementNeeded = ($optInTimePeriod - 1);
3030	if ($startIdx < $nbInitialElementNeeded) {
3031	$startIdx = $nbInitialElementNeeded;
3032	}
3033	if ($startIdx > $endIdx) {
3034	$outBegIdx = 0;
3035	$outNBElement = 0;
3036
3037	return ReturnCode::Success;
3038	}
3039	$diff = 0.0;
3040	$outIdx = 0;
3041	$today = $startIdx;
3042	$trailingIdx = $startIdx - $nbInitialElementNeeded;
3043	$lowestIdx = $highestIdx = -1;
3044	$diff = $highest = $lowest = 0.0;
3045	while ($today <= $endIdx) {
3046	$tmp = $inLow[$today];
3047	if ($lowestIdx < $trailingIdx) {
3048	$lowestIdx = $trailingIdx;
3049	$lowest = $inLow[$lowestIdx];
3050	$i = $lowestIdx;
3051	while (++$i <= $today) {
3052	$tmp = $inLow[$i];
3053	if ($tmp < $lowest) {
3054	$lowestIdx = $i;
3055	$lowest = $tmp;
3056	}
3057	}
3058	$diff = ($highest - $lowest) / (-100.0);
3059	} elseif ($tmp <= $lowest) {
3060	$lowestIdx = $today;
3061	$lowest = $tmp;
3062	$diff = ($highest - $lowest) / (-100.0);
3063	}
3064	$tmp = $inHigh[$today];
3065	if ($highestIdx < $trailingIdx) {
3066	$highestIdx = $trailingIdx;
3067	$highest = $inHigh[$highestIdx];
3068	$i = $highestIdx;
3069	while (++$i <= $today) {
3070	$tmp = $inHigh[$i];
3071	if ($tmp > $highest) {
3072	$highestIdx = $i;
3073	$highest = $tmp;
3074	}
3075	}
3076	$diff = ($highest - $lowest) / (-100.0);
3077	} elseif ($tmp >= $highest) {
3078	$highestIdx = $today;
3079	$highest = $tmp;
3080	$diff = ($highest - $lowest) / (-100.0);
3081	}
3082	if ($diff != 0.0) {
3083	$outReal[$outIdx++] = ($highest - $inClose[$today]) / $diff;
3084	} else {
3085	$outReal[$outIdx++] = 0.0;
3086	}
3087	$trailingIdx++;
3088	$today++;
3089	}
3090	$outBegIdx = $startIdx;
3091	$outNBElement = $outIdx;
3092
3093	return ReturnCode::Success;
3094	}
3095	}