1 /* TA-LIB Copyright (c) 1999-2007, Mario Fortier
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or
5  * without modification, are permitted provided that the following
6  * conditions are met:
7  *
8  * - Redistributions of source code must retain the above copyright
9  *   notice, this list of conditions and the following disclaimer.
10  *
11  * - Redistributions in binary form must reproduce the above copyright
12  *   notice, this list of conditions and the following disclaimer in
13  *   the documentation and/or other materials provided with the
14  *   distribution.
15  *
16  * - Neither name of author nor the names of its contributors
17  *   may be used to endorse or promote products derived from this
18  *   software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24  * REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
30  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
31  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33 #ifndef TA_FUNC_H
34 #define TA_FUNC_H
35 
36 #ifndef TA_COMMON_H
37    #include "ta_common.h"
38 #endif
39 
40 /* This header contains the prototype of all the Technical Analysis
41  * function provided by TA-LIB.
42  */
43 
44 /* TA-LIB Developer Note: Do not modify this file, it is automaticaly
45  *                        generated by gen_code.
46  */
47 #ifdef __cplusplus
48 extern "C" {
49 #endif
50 
51 #ifndef TA_DEFS_H
52    #include "ta_defs.h"
53 #endif
54 
55 
56 /*
57  * TA_ACOS - Vector Trigonometric ACos
58  *
59  * Input  = double
60  * Output = double
61  *
62  */
63 TA_RetCode TA_ACOS( int    startIdx,
64                     int    endIdx,
65                     const double inReal[],
66                     int          *outBegIdx,
67                     int          *outNBElement,
68                     double        outReal[] );
69 
70 TA_RetCode TA_S_ACOS( int    startIdx,
71                       int    endIdx,
72                       const float  inReal[],
73                       int          *outBegIdx,
74                       int          *outNBElement,
75                       double        outReal[] );
76 
77 int TA_ACOS_Lookback( void );
78 
79 
80 /*
81  * TA_AD - Chaikin A/D Line
82  *
83  * Input  = High, Low, Close, Volume
84  * Output = double
85  *
86  */
87 TA_RetCode TA_AD( int    startIdx,
88                   int    endIdx,
89                   const double inHigh[],
90                   const double inLow[],
91                   const double inClose[],
92                   const double inVolume[],
93                   int          *outBegIdx,
94                   int          *outNBElement,
95                   double        outReal[] );
96 
97 TA_RetCode TA_S_AD( int    startIdx,
98                     int    endIdx,
99                     const float  inHigh[],
100                     const float  inLow[],
101                     const float  inClose[],
102                     const float  inVolume[],
103                     int          *outBegIdx,
104                     int          *outNBElement,
105                     double        outReal[] );
106 
107 int TA_AD_Lookback( void );
108 
109 
110 /*
111  * TA_ADD - Vector Arithmetic Add
112  *
113  * Input  = double, double
114  * Output = double
115  *
116  */
117 TA_RetCode TA_ADD( int    startIdx,
118                    int    endIdx,
119                    const double inReal0[],
120                    const double inReal1[],
121                    int          *outBegIdx,
122                    int          *outNBElement,
123                    double        outReal[] );
124 
125 TA_RetCode TA_S_ADD( int    startIdx,
126                      int    endIdx,
127                      const float  inReal0[],
128                      const float  inReal1[],
129                      int          *outBegIdx,
130                      int          *outNBElement,
131                      double        outReal[] );
132 
133 int TA_ADD_Lookback( void );
134 
135 
136 /*
137  * TA_ADOSC - Chaikin A/D Oscillator
138  *
139  * Input  = High, Low, Close, Volume
140  * Output = double
141  *
142  * Optional Parameters
143  * -------------------
144  * optInFastPeriod:(From 2 to 100000)
145  *    Number of period for the fast MA
146  *
147  * optInSlowPeriod:(From 2 to 100000)
148  *    Number of period for the slow MA
149  *
150  *
151  */
152 TA_RetCode TA_ADOSC( int    startIdx,
153                      int    endIdx,
154                      const double inHigh[],
155                      const double inLow[],
156                      const double inClose[],
157                      const double inVolume[],
158                      int           optInFastPeriod, /* From 2 to 100000 */
159                      int           optInSlowPeriod, /* From 2 to 100000 */
160                      int          *outBegIdx,
161                      int          *outNBElement,
162                      double        outReal[] );
163 
164 TA_RetCode TA_S_ADOSC( int    startIdx,
165                        int    endIdx,
166                        const float  inHigh[],
167                        const float  inLow[],
168                        const float  inClose[],
169                        const float  inVolume[],
170                        int           optInFastPeriod, /* From 2 to 100000 */
171                        int           optInSlowPeriod, /* From 2 to 100000 */
172                        int          *outBegIdx,
173                        int          *outNBElement,
174                        double        outReal[] );
175 
176 int TA_ADOSC_Lookback( int           optInFastPeriod, /* From 2 to 100000 */
177                      int           optInSlowPeriod );  /* From 2 to 100000 */
178 
179 
180 /*
181  * TA_ADX - Average Directional Movement Index
182  *
183  * Input  = High, Low, Close
184  * Output = double
185  *
186  * Optional Parameters
187  * -------------------
188  * optInTimePeriod:(From 2 to 100000)
189  *    Number of period
190  *
191  *
192  */
193 TA_RetCode TA_ADX( int    startIdx,
194                    int    endIdx,
195                    const double inHigh[],
196                    const double inLow[],
197                    const double inClose[],
198                    int           optInTimePeriod, /* From 2 to 100000 */
199                    int          *outBegIdx,
200                    int          *outNBElement,
201                    double        outReal[] );
202 
203 TA_RetCode TA_S_ADX( int    startIdx,
204                      int    endIdx,
205                      const float  inHigh[],
206                      const float  inLow[],
207                      const float  inClose[],
208                      int           optInTimePeriod, /* From 2 to 100000 */
209                      int          *outBegIdx,
210                      int          *outNBElement,
211                      double        outReal[] );
212 
213 int TA_ADX_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
214 
215 
216 /*
217  * TA_ADXR - Average Directional Movement Index Rating
218  *
219  * Input  = High, Low, Close
220  * Output = double
221  *
222  * Optional Parameters
223  * -------------------
224  * optInTimePeriod:(From 2 to 100000)
225  *    Number of period
226  *
227  *
228  */
229 TA_RetCode TA_ADXR( int    startIdx,
230                     int    endIdx,
231                     const double inHigh[],
232                     const double inLow[],
233                     const double inClose[],
234                     int           optInTimePeriod, /* From 2 to 100000 */
235                     int          *outBegIdx,
236                     int          *outNBElement,
237                     double        outReal[] );
238 
239 TA_RetCode TA_S_ADXR( int    startIdx,
240                       int    endIdx,
241                       const float  inHigh[],
242                       const float  inLow[],
243                       const float  inClose[],
244                       int           optInTimePeriod, /* From 2 to 100000 */
245                       int          *outBegIdx,
246                       int          *outNBElement,
247                       double        outReal[] );
248 
249 int TA_ADXR_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
250 
251 
252 /*
253  * TA_APO - Absolute Price Oscillator
254  *
255  * Input  = double
256  * Output = double
257  *
258  * Optional Parameters
259  * -------------------
260  * optInFastPeriod:(From 2 to 100000)
261  *    Number of period for the fast MA
262  *
263  * optInSlowPeriod:(From 2 to 100000)
264  *    Number of period for the slow MA
265  *
266  * optInMAType:
267  *    Type of Moving Average
268  *
269  *
270  */
271 TA_RetCode TA_APO( int    startIdx,
272                    int    endIdx,
273                    const double inReal[],
274                    int           optInFastPeriod, /* From 2 to 100000 */
275                    int           optInSlowPeriod, /* From 2 to 100000 */
276                    TA_MAType     optInMAType,
277                    int          *outBegIdx,
278                    int          *outNBElement,
279                    double        outReal[] );
280 
281 TA_RetCode TA_S_APO( int    startIdx,
282                      int    endIdx,
283                      const float  inReal[],
284                      int           optInFastPeriod, /* From 2 to 100000 */
285                      int           optInSlowPeriod, /* From 2 to 100000 */
286                      TA_MAType     optInMAType,
287                      int          *outBegIdx,
288                      int          *outNBElement,
289                      double        outReal[] );
290 
291 int TA_APO_Lookback( int           optInFastPeriod, /* From 2 to 100000 */
292                    int           optInSlowPeriod, /* From 2 to 100000 */
293                    TA_MAType     optInMAType );
294 
295 /*
296  * TA_AROON - Aroon
297  *
298  * Input  = High, Low
299  * Output = double, double
300  *
301  * Optional Parameters
302  * -------------------
303  * optInTimePeriod:(From 2 to 100000)
304  *    Number of period
305  *
306  *
307  */
308 TA_RetCode TA_AROON( int    startIdx,
309                      int    endIdx,
310                      const double inHigh[],
311                      const double inLow[],
312                      int           optInTimePeriod, /* From 2 to 100000 */
313                      int          *outBegIdx,
314                      int          *outNBElement,
315                      double        outAroonDown[],
316                      double        outAroonUp[] );
317 
318 TA_RetCode TA_S_AROON( int    startIdx,
319                        int    endIdx,
320                        const float  inHigh[],
321                        const float  inLow[],
322                        int           optInTimePeriod, /* From 2 to 100000 */
323                        int          *outBegIdx,
324                        int          *outNBElement,
325                        double        outAroonDown[],
326                        double        outAroonUp[] );
327 
328 int TA_AROON_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
329 
330 
331 /*
332  * TA_AROONOSC - Aroon Oscillator
333  *
334  * Input  = High, Low
335  * Output = double
336  *
337  * Optional Parameters
338  * -------------------
339  * optInTimePeriod:(From 2 to 100000)
340  *    Number of period
341  *
342  *
343  */
344 TA_RetCode TA_AROONOSC( int    startIdx,
345                         int    endIdx,
346                         const double inHigh[],
347                         const double inLow[],
348                         int           optInTimePeriod, /* From 2 to 100000 */
349                         int          *outBegIdx,
350                         int          *outNBElement,
351                         double        outReal[] );
352 
353 TA_RetCode TA_S_AROONOSC( int    startIdx,
354                           int    endIdx,
355                           const float  inHigh[],
356                           const float  inLow[],
357                           int           optInTimePeriod, /* From 2 to 100000 */
358                           int          *outBegIdx,
359                           int          *outNBElement,
360                           double        outReal[] );
361 
362 int TA_AROONOSC_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
363 
364 
365 /*
366  * TA_ASIN - Vector Trigonometric ASin
367  *
368  * Input  = double
369  * Output = double
370  *
371  */
372 TA_RetCode TA_ASIN( int    startIdx,
373                     int    endIdx,
374                     const double inReal[],
375                     int          *outBegIdx,
376                     int          *outNBElement,
377                     double        outReal[] );
378 
379 TA_RetCode TA_S_ASIN( int    startIdx,
380                       int    endIdx,
381                       const float  inReal[],
382                       int          *outBegIdx,
383                       int          *outNBElement,
384                       double        outReal[] );
385 
386 int TA_ASIN_Lookback( void );
387 
388 
389 /*
390  * TA_ATAN - Vector Trigonometric ATan
391  *
392  * Input  = double
393  * Output = double
394  *
395  */
396 TA_RetCode TA_ATAN( int    startIdx,
397                     int    endIdx,
398                     const double inReal[],
399                     int          *outBegIdx,
400                     int          *outNBElement,
401                     double        outReal[] );
402 
403 TA_RetCode TA_S_ATAN( int    startIdx,
404                       int    endIdx,
405                       const float  inReal[],
406                       int          *outBegIdx,
407                       int          *outNBElement,
408                       double        outReal[] );
409 
410 int TA_ATAN_Lookback( void );
411 
412 
413 /*
414  * TA_ATR - Average True Range
415  *
416  * Input  = High, Low, Close
417  * Output = double
418  *
419  * Optional Parameters
420  * -------------------
421  * optInTimePeriod:(From 1 to 100000)
422  *    Number of period
423  *
424  *
425  */
426 TA_RetCode TA_ATR( int    startIdx,
427                    int    endIdx,
428                    const double inHigh[],
429                    const double inLow[],
430                    const double inClose[],
431                    int           optInTimePeriod, /* From 1 to 100000 */
432                    int          *outBegIdx,
433                    int          *outNBElement,
434                    double        outReal[] );
435 
436 TA_RetCode TA_S_ATR( int    startIdx,
437                      int    endIdx,
438                      const float  inHigh[],
439                      const float  inLow[],
440                      const float  inClose[],
441                      int           optInTimePeriod, /* From 1 to 100000 */
442                      int          *outBegIdx,
443                      int          *outNBElement,
444                      double        outReal[] );
445 
446 int TA_ATR_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
447 
448 
449 /*
450  * TA_AVGPRICE - Average Price
451  *
452  * Input  = Open, High, Low, Close
453  * Output = double
454  *
455  */
456 TA_RetCode TA_AVGPRICE( int    startIdx,
457                         int    endIdx,
458                         const double inOpen[],
459                         const double inHigh[],
460                         const double inLow[],
461                         const double inClose[],
462                         int          *outBegIdx,
463                         int          *outNBElement,
464                         double        outReal[] );
465 
466 TA_RetCode TA_S_AVGPRICE( int    startIdx,
467                           int    endIdx,
468                           const float  inOpen[],
469                           const float  inHigh[],
470                           const float  inLow[],
471                           const float  inClose[],
472                           int          *outBegIdx,
473                           int          *outNBElement,
474                           double        outReal[] );
475 
476 int TA_AVGPRICE_Lookback( void );
477 
478 
479 /*
480  * TA_BBANDS - Bollinger Bands
481  *
482  * Input  = double
483  * Output = double, double, double
484  *
485  * Optional Parameters
486  * -------------------
487  * optInTimePeriod:(From 2 to 100000)
488  *    Number of period
489  *
490  * optInNbDevUp:(From TA_REAL_MIN to TA_REAL_MAX)
491  *    Deviation multiplier for upper band
492  *
493  * optInNbDevDn:(From TA_REAL_MIN to TA_REAL_MAX)
494  *    Deviation multiplier for lower band
495  *
496  * optInMAType:
497  *    Type of Moving Average
498  *
499  *
500  */
501 TA_RetCode TA_BBANDS( int    startIdx,
502                       int    endIdx,
503                       const double inReal[],
504                       int           optInTimePeriod, /* From 2 to 100000 */
505                       double        optInNbDevUp, /* From TA_REAL_MIN to TA_REAL_MAX */
506                       double        optInNbDevDn, /* From TA_REAL_MIN to TA_REAL_MAX */
507                       TA_MAType     optInMAType,
508                       int          *outBegIdx,
509                       int          *outNBElement,
510                       double        outRealUpperBand[],
511                       double        outRealMiddleBand[],
512                       double        outRealLowerBand[] );
513 
514 TA_RetCode TA_S_BBANDS( int    startIdx,
515                         int    endIdx,
516                         const float  inReal[],
517                         int           optInTimePeriod, /* From 2 to 100000 */
518                         double        optInNbDevUp, /* From TA_REAL_MIN to TA_REAL_MAX */
519                         double        optInNbDevDn, /* From TA_REAL_MIN to TA_REAL_MAX */
520                         TA_MAType     optInMAType,
521                         int          *outBegIdx,
522                         int          *outNBElement,
523                         double        outRealUpperBand[],
524                         double        outRealMiddleBand[],
525                         double        outRealLowerBand[] );
526 
527 int TA_BBANDS_Lookback( int           optInTimePeriod, /* From 2 to 100000 */
528                       double        optInNbDevUp, /* From TA_REAL_MIN to TA_REAL_MAX */
529                       double        optInNbDevDn, /* From TA_REAL_MIN to TA_REAL_MAX */
530                       TA_MAType     optInMAType );
531 
532 /*
533  * TA_BETA - Beta
534  *
535  * Input  = double, double
536  * Output = double
537  *
538  * Optional Parameters
539  * -------------------
540  * optInTimePeriod:(From 1 to 100000)
541  *    Number of period
542  *
543  *
544  */
545 TA_RetCode TA_BETA( int    startIdx,
546                     int    endIdx,
547                     const double inReal0[],
548                     const double inReal1[],
549                     int           optInTimePeriod, /* From 1 to 100000 */
550                     int          *outBegIdx,
551                     int          *outNBElement,
552                     double        outReal[] );
553 
554 TA_RetCode TA_S_BETA( int    startIdx,
555                       int    endIdx,
556                       const float  inReal0[],
557                       const float  inReal1[],
558                       int           optInTimePeriod, /* From 1 to 100000 */
559                       int          *outBegIdx,
560                       int          *outNBElement,
561                       double        outReal[] );
562 
563 int TA_BETA_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
564 
565 
566 /*
567  * TA_BOP - Balance Of Power
568  *
569  * Input  = Open, High, Low, Close
570  * Output = double
571  *
572  */
573 TA_RetCode TA_BOP( int    startIdx,
574                    int    endIdx,
575                    const double inOpen[],
576                    const double inHigh[],
577                    const double inLow[],
578                    const double inClose[],
579                    int          *outBegIdx,
580                    int          *outNBElement,
581                    double        outReal[] );
582 
583 TA_RetCode TA_S_BOP( int    startIdx,
584                      int    endIdx,
585                      const float  inOpen[],
586                      const float  inHigh[],
587                      const float  inLow[],
588                      const float  inClose[],
589                      int          *outBegIdx,
590                      int          *outNBElement,
591                      double        outReal[] );
592 
593 int TA_BOP_Lookback( void );
594 
595 
596 /*
597  * TA_CCI - Commodity Channel Index
598  *
599  * Input  = High, Low, Close
600  * Output = double
601  *
602  * Optional Parameters
603  * -------------------
604  * optInTimePeriod:(From 2 to 100000)
605  *    Number of period
606  *
607  *
608  */
609 TA_RetCode TA_CCI( int    startIdx,
610                    int    endIdx,
611                    const double inHigh[],
612                    const double inLow[],
613                    const double inClose[],
614                    int           optInTimePeriod, /* From 2 to 100000 */
615                    int          *outBegIdx,
616                    int          *outNBElement,
617                    double        outReal[] );
618 
619 TA_RetCode TA_S_CCI( int    startIdx,
620                      int    endIdx,
621                      const float  inHigh[],
622                      const float  inLow[],
623                      const float  inClose[],
624                      int           optInTimePeriod, /* From 2 to 100000 */
625                      int          *outBegIdx,
626                      int          *outNBElement,
627                      double        outReal[] );
628 
629 int TA_CCI_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
630 
631 
632 /*
633  * TA_CDL2CROWS - Two Crows
634  *
635  * Input  = Open, High, Low, Close
636  * Output = int
637  *
638  */
639 TA_RetCode TA_CDL2CROWS( int    startIdx,
640                          int    endIdx,
641                          const double inOpen[],
642                          const double inHigh[],
643                          const double inLow[],
644                          const double inClose[],
645                          int          *outBegIdx,
646                          int          *outNBElement,
647                          int           outInteger[] );
648 
649 TA_RetCode TA_S_CDL2CROWS( int    startIdx,
650                            int    endIdx,
651                            const float  inOpen[],
652                            const float  inHigh[],
653                            const float  inLow[],
654                            const float  inClose[],
655                            int          *outBegIdx,
656                            int          *outNBElement,
657                            int           outInteger[] );
658 
659 int TA_CDL2CROWS_Lookback( void );
660 
661 
662 /*
663  * TA_CDL3BLACKCROWS - Three Black Crows
664  *
665  * Input  = Open, High, Low, Close
666  * Output = int
667  *
668  */
669 TA_RetCode TA_CDL3BLACKCROWS( int    startIdx,
670                               int    endIdx,
671                               const double inOpen[],
672                               const double inHigh[],
673                               const double inLow[],
674                               const double inClose[],
675                               int          *outBegIdx,
676                               int          *outNBElement,
677                               int           outInteger[] );
678 
679 TA_RetCode TA_S_CDL3BLACKCROWS( int    startIdx,
680                                 int    endIdx,
681                                 const float  inOpen[],
682                                 const float  inHigh[],
683                                 const float  inLow[],
684                                 const float  inClose[],
685                                 int          *outBegIdx,
686                                 int          *outNBElement,
687                                 int           outInteger[] );
688 
689 int TA_CDL3BLACKCROWS_Lookback( void );
690 
691 
692 /*
693  * TA_CDL3INSIDE - Three Inside Up/Down
694  *
695  * Input  = Open, High, Low, Close
696  * Output = int
697  *
698  */
699 TA_RetCode TA_CDL3INSIDE( int    startIdx,
700                           int    endIdx,
701                           const double inOpen[],
702                           const double inHigh[],
703                           const double inLow[],
704                           const double inClose[],
705                           int          *outBegIdx,
706                           int          *outNBElement,
707                           int           outInteger[] );
708 
709 TA_RetCode TA_S_CDL3INSIDE( int    startIdx,
710                             int    endIdx,
711                             const float  inOpen[],
712                             const float  inHigh[],
713                             const float  inLow[],
714                             const float  inClose[],
715                             int          *outBegIdx,
716                             int          *outNBElement,
717                             int           outInteger[] );
718 
719 int TA_CDL3INSIDE_Lookback( void );
720 
721 
722 /*
723  * TA_CDL3LINESTRIKE - Three-Line Strike
724  *
725  * Input  = Open, High, Low, Close
726  * Output = int
727  *
728  */
729 TA_RetCode TA_CDL3LINESTRIKE( int    startIdx,
730                               int    endIdx,
731                               const double inOpen[],
732                               const double inHigh[],
733                               const double inLow[],
734                               const double inClose[],
735                               int          *outBegIdx,
736                               int          *outNBElement,
737                               int           outInteger[] );
738 
739 TA_RetCode TA_S_CDL3LINESTRIKE( int    startIdx,
740                                 int    endIdx,
741                                 const float  inOpen[],
742                                 const float  inHigh[],
743                                 const float  inLow[],
744                                 const float  inClose[],
745                                 int          *outBegIdx,
746                                 int          *outNBElement,
747                                 int           outInteger[] );
748 
749 int TA_CDL3LINESTRIKE_Lookback( void );
750 
751 
752 /*
753  * TA_CDL3OUTSIDE - Three Outside Up/Down
754  *
755  * Input  = Open, High, Low, Close
756  * Output = int
757  *
758  */
759 TA_RetCode TA_CDL3OUTSIDE( int    startIdx,
760                            int    endIdx,
761                            const double inOpen[],
762                            const double inHigh[],
763                            const double inLow[],
764                            const double inClose[],
765                            int          *outBegIdx,
766                            int          *outNBElement,
767                            int           outInteger[] );
768 
769 TA_RetCode TA_S_CDL3OUTSIDE( int    startIdx,
770                              int    endIdx,
771                              const float  inOpen[],
772                              const float  inHigh[],
773                              const float  inLow[],
774                              const float  inClose[],
775                              int          *outBegIdx,
776                              int          *outNBElement,
777                              int           outInteger[] );
778 
779 int TA_CDL3OUTSIDE_Lookback( void );
780 
781 
782 /*
783  * TA_CDL3STARSINSOUTH - Three Stars In The South
784  *
785  * Input  = Open, High, Low, Close
786  * Output = int
787  *
788  */
789 TA_RetCode TA_CDL3STARSINSOUTH( int    startIdx,
790                                 int    endIdx,
791                                 const double inOpen[],
792                                 const double inHigh[],
793                                 const double inLow[],
794                                 const double inClose[],
795                                 int          *outBegIdx,
796                                 int          *outNBElement,
797                                 int           outInteger[] );
798 
799 TA_RetCode TA_S_CDL3STARSINSOUTH( int    startIdx,
800                                   int    endIdx,
801                                   const float  inOpen[],
802                                   const float  inHigh[],
803                                   const float  inLow[],
804                                   const float  inClose[],
805                                   int          *outBegIdx,
806                                   int          *outNBElement,
807                                   int           outInteger[] );
808 
809 int TA_CDL3STARSINSOUTH_Lookback( void );
810 
811 
812 /*
813  * TA_CDL3WHITESOLDIERS - Three Advancing White Soldiers
814  *
815  * Input  = Open, High, Low, Close
816  * Output = int
817  *
818  */
819 TA_RetCode TA_CDL3WHITESOLDIERS( int    startIdx,
820                                  int    endIdx,
821                                  const double inOpen[],
822                                  const double inHigh[],
823                                  const double inLow[],
824                                  const double inClose[],
825                                  int          *outBegIdx,
826                                  int          *outNBElement,
827                                  int           outInteger[] );
828 
829 TA_RetCode TA_S_CDL3WHITESOLDIERS( int    startIdx,
830                                    int    endIdx,
831                                    const float  inOpen[],
832                                    const float  inHigh[],
833                                    const float  inLow[],
834                                    const float  inClose[],
835                                    int          *outBegIdx,
836                                    int          *outNBElement,
837                                    int           outInteger[] );
838 
839 int TA_CDL3WHITESOLDIERS_Lookback( void );
840 
841 
842 /*
843  * TA_CDLABANDONEDBABY - Abandoned Baby
844  *
845  * Input  = Open, High, Low, Close
846  * Output = int
847  *
848  * Optional Parameters
849  * -------------------
850  * optInPenetration:(From 0 to TA_REAL_MAX)
851  *    Percentage of penetration of a candle within another candle
852  *
853  *
854  */
855 TA_RetCode TA_CDLABANDONEDBABY( int    startIdx,
856                                 int    endIdx,
857                                 const double inOpen[],
858                                 const double inHigh[],
859                                 const double inLow[],
860                                 const double inClose[],
861                                 double        optInPenetration, /* From 0 to TA_REAL_MAX */
862                                 int          *outBegIdx,
863                                 int          *outNBElement,
864                                 int           outInteger[] );
865 
866 TA_RetCode TA_S_CDLABANDONEDBABY( int    startIdx,
867                                   int    endIdx,
868                                   const float  inOpen[],
869                                   const float  inHigh[],
870                                   const float  inLow[],
871                                   const float  inClose[],
872                                   double        optInPenetration, /* From 0 to TA_REAL_MAX */
873                                   int          *outBegIdx,
874                                   int          *outNBElement,
875                                   int           outInteger[] );
876 
877 int TA_CDLABANDONEDBABY_Lookback( double        optInPenetration );  /* From 0 to TA_REAL_MAX */
878 
879 
880 /*
881  * TA_CDLADVANCEBLOCK - Advance Block
882  *
883  * Input  = Open, High, Low, Close
884  * Output = int
885  *
886  */
887 TA_RetCode TA_CDLADVANCEBLOCK( int    startIdx,
888                                int    endIdx,
889                                const double inOpen[],
890                                const double inHigh[],
891                                const double inLow[],
892                                const double inClose[],
893                                int          *outBegIdx,
894                                int          *outNBElement,
895                                int           outInteger[] );
896 
897 TA_RetCode TA_S_CDLADVANCEBLOCK( int    startIdx,
898                                  int    endIdx,
899                                  const float  inOpen[],
900                                  const float  inHigh[],
901                                  const float  inLow[],
902                                  const float  inClose[],
903                                  int          *outBegIdx,
904                                  int          *outNBElement,
905                                  int           outInteger[] );
906 
907 int TA_CDLADVANCEBLOCK_Lookback( void );
908 
909 
910 /*
911  * TA_CDLBELTHOLD - Belt-hold
912  *
913  * Input  = Open, High, Low, Close
914  * Output = int
915  *
916  */
917 TA_RetCode TA_CDLBELTHOLD( int    startIdx,
918                            int    endIdx,
919                            const double inOpen[],
920                            const double inHigh[],
921                            const double inLow[],
922                            const double inClose[],
923                            int          *outBegIdx,
924                            int          *outNBElement,
925                            int           outInteger[] );
926 
927 TA_RetCode TA_S_CDLBELTHOLD( int    startIdx,
928                              int    endIdx,
929                              const float  inOpen[],
930                              const float  inHigh[],
931                              const float  inLow[],
932                              const float  inClose[],
933                              int          *outBegIdx,
934                              int          *outNBElement,
935                              int           outInteger[] );
936 
937 int TA_CDLBELTHOLD_Lookback( void );
938 
939 
940 /*
941  * TA_CDLBREAKAWAY - Breakaway
942  *
943  * Input  = Open, High, Low, Close
944  * Output = int
945  *
946  */
947 TA_RetCode TA_CDLBREAKAWAY( int    startIdx,
948                             int    endIdx,
949                             const double inOpen[],
950                             const double inHigh[],
951                             const double inLow[],
952                             const double inClose[],
953                             int          *outBegIdx,
954                             int          *outNBElement,
955                             int           outInteger[] );
956 
957 TA_RetCode TA_S_CDLBREAKAWAY( int    startIdx,
958                               int    endIdx,
959                               const float  inOpen[],
960                               const float  inHigh[],
961                               const float  inLow[],
962                               const float  inClose[],
963                               int          *outBegIdx,
964                               int          *outNBElement,
965                               int           outInteger[] );
966 
967 int TA_CDLBREAKAWAY_Lookback( void );
968 
969 
970 /*
971  * TA_CDLCLOSINGMARUBOZU - Closing Marubozu
972  *
973  * Input  = Open, High, Low, Close
974  * Output = int
975  *
976  */
977 TA_RetCode TA_CDLCLOSINGMARUBOZU( int    startIdx,
978                                   int    endIdx,
979                                   const double inOpen[],
980                                   const double inHigh[],
981                                   const double inLow[],
982                                   const double inClose[],
983                                   int          *outBegIdx,
984                                   int          *outNBElement,
985                                   int           outInteger[] );
986 
987 TA_RetCode TA_S_CDLCLOSINGMARUBOZU( int    startIdx,
988                                     int    endIdx,
989                                     const float  inOpen[],
990                                     const float  inHigh[],
991                                     const float  inLow[],
992                                     const float  inClose[],
993                                     int          *outBegIdx,
994                                     int          *outNBElement,
995                                     int           outInteger[] );
996 
997 int TA_CDLCLOSINGMARUBOZU_Lookback( void );
998 
999 
1000 /*
1001  * TA_CDLCONCEALBABYSWALL - Concealing Baby Swallow
1002  *
1003  * Input  = Open, High, Low, Close
1004  * Output = int
1005  *
1006  */
1007 TA_RetCode TA_CDLCONCEALBABYSWALL( int    startIdx,
1008                                    int    endIdx,
1009                                    const double inOpen[],
1010                                    const double inHigh[],
1011                                    const double inLow[],
1012                                    const double inClose[],
1013                                    int          *outBegIdx,
1014                                    int          *outNBElement,
1015                                    int           outInteger[] );
1016 
1017 TA_RetCode TA_S_CDLCONCEALBABYSWALL( int    startIdx,
1018                                      int    endIdx,
1019                                      const float  inOpen[],
1020                                      const float  inHigh[],
1021                                      const float  inLow[],
1022                                      const float  inClose[],
1023                                      int          *outBegIdx,
1024                                      int          *outNBElement,
1025                                      int           outInteger[] );
1026 
1027 int TA_CDLCONCEALBABYSWALL_Lookback( void );
1028 
1029 
1030 /*
1031  * TA_CDLCOUNTERATTACK - Counterattack
1032  *
1033  * Input  = Open, High, Low, Close
1034  * Output = int
1035  *
1036  */
1037 TA_RetCode TA_CDLCOUNTERATTACK( int    startIdx,
1038                                 int    endIdx,
1039                                 const double inOpen[],
1040                                 const double inHigh[],
1041                                 const double inLow[],
1042                                 const double inClose[],
1043                                 int          *outBegIdx,
1044                                 int          *outNBElement,
1045                                 int           outInteger[] );
1046 
1047 TA_RetCode TA_S_CDLCOUNTERATTACK( int    startIdx,
1048                                   int    endIdx,
1049                                   const float  inOpen[],
1050                                   const float  inHigh[],
1051                                   const float  inLow[],
1052                                   const float  inClose[],
1053                                   int          *outBegIdx,
1054                                   int          *outNBElement,
1055                                   int           outInteger[] );
1056 
1057 int TA_CDLCOUNTERATTACK_Lookback( void );
1058 
1059 
1060 /*
1061  * TA_CDLDARKCLOUDCOVER - Dark Cloud Cover
1062  *
1063  * Input  = Open, High, Low, Close
1064  * Output = int
1065  *
1066  * Optional Parameters
1067  * -------------------
1068  * optInPenetration:(From 0 to TA_REAL_MAX)
1069  *    Percentage of penetration of a candle within another candle
1070  *
1071  *
1072  */
1073 TA_RetCode TA_CDLDARKCLOUDCOVER( int    startIdx,
1074                                  int    endIdx,
1075                                  const double inOpen[],
1076                                  const double inHigh[],
1077                                  const double inLow[],
1078                                  const double inClose[],
1079                                  double        optInPenetration, /* From 0 to TA_REAL_MAX */
1080                                  int          *outBegIdx,
1081                                  int          *outNBElement,
1082                                  int           outInteger[] );
1083 
1084 TA_RetCode TA_S_CDLDARKCLOUDCOVER( int    startIdx,
1085                                    int    endIdx,
1086                                    const float  inOpen[],
1087                                    const float  inHigh[],
1088                                    const float  inLow[],
1089                                    const float  inClose[],
1090                                    double        optInPenetration, /* From 0 to TA_REAL_MAX */
1091                                    int          *outBegIdx,
1092                                    int          *outNBElement,
1093                                    int           outInteger[] );
1094 
1095 int TA_CDLDARKCLOUDCOVER_Lookback( double        optInPenetration );  /* From 0 to TA_REAL_MAX */
1096 
1097 
1098 /*
1099  * TA_CDLDOJI - Doji
1100  *
1101  * Input  = Open, High, Low, Close
1102  * Output = int
1103  *
1104  */
1105 TA_RetCode TA_CDLDOJI( int    startIdx,
1106                        int    endIdx,
1107                        const double inOpen[],
1108                        const double inHigh[],
1109                        const double inLow[],
1110                        const double inClose[],
1111                        int          *outBegIdx,
1112                        int          *outNBElement,
1113                        int           outInteger[] );
1114 
1115 TA_RetCode TA_S_CDLDOJI( int    startIdx,
1116                          int    endIdx,
1117                          const float  inOpen[],
1118                          const float  inHigh[],
1119                          const float  inLow[],
1120                          const float  inClose[],
1121                          int          *outBegIdx,
1122                          int          *outNBElement,
1123                          int           outInteger[] );
1124 
1125 int TA_CDLDOJI_Lookback( void );
1126 
1127 
1128 /*
1129  * TA_CDLDOJISTAR - Doji Star
1130  *
1131  * Input  = Open, High, Low, Close
1132  * Output = int
1133  *
1134  */
1135 TA_RetCode TA_CDLDOJISTAR( int    startIdx,
1136                            int    endIdx,
1137                            const double inOpen[],
1138                            const double inHigh[],
1139                            const double inLow[],
1140                            const double inClose[],
1141                            int          *outBegIdx,
1142                            int          *outNBElement,
1143                            int           outInteger[] );
1144 
1145 TA_RetCode TA_S_CDLDOJISTAR( int    startIdx,
1146                              int    endIdx,
1147                              const float  inOpen[],
1148                              const float  inHigh[],
1149                              const float  inLow[],
1150                              const float  inClose[],
1151                              int          *outBegIdx,
1152                              int          *outNBElement,
1153                              int           outInteger[] );
1154 
1155 int TA_CDLDOJISTAR_Lookback( void );
1156 
1157 
1158 /*
1159  * TA_CDLDRAGONFLYDOJI - Dragonfly Doji
1160  *
1161  * Input  = Open, High, Low, Close
1162  * Output = int
1163  *
1164  */
1165 TA_RetCode TA_CDLDRAGONFLYDOJI( int    startIdx,
1166                                 int    endIdx,
1167                                 const double inOpen[],
1168                                 const double inHigh[],
1169                                 const double inLow[],
1170                                 const double inClose[],
1171                                 int          *outBegIdx,
1172                                 int          *outNBElement,
1173                                 int           outInteger[] );
1174 
1175 TA_RetCode TA_S_CDLDRAGONFLYDOJI( int    startIdx,
1176                                   int    endIdx,
1177                                   const float  inOpen[],
1178                                   const float  inHigh[],
1179                                   const float  inLow[],
1180                                   const float  inClose[],
1181                                   int          *outBegIdx,
1182                                   int          *outNBElement,
1183                                   int           outInteger[] );
1184 
1185 int TA_CDLDRAGONFLYDOJI_Lookback( void );
1186 
1187 
1188 /*
1189  * TA_CDLENGULFING - Engulfing Pattern
1190  *
1191  * Input  = Open, High, Low, Close
1192  * Output = int
1193  *
1194  */
1195 TA_RetCode TA_CDLENGULFING( int    startIdx,
1196                             int    endIdx,
1197                             const double inOpen[],
1198                             const double inHigh[],
1199                             const double inLow[],
1200                             const double inClose[],
1201                             int          *outBegIdx,
1202                             int          *outNBElement,
1203                             int           outInteger[] );
1204 
1205 TA_RetCode TA_S_CDLENGULFING( int    startIdx,
1206                               int    endIdx,
1207                               const float  inOpen[],
1208                               const float  inHigh[],
1209                               const float  inLow[],
1210                               const float  inClose[],
1211                               int          *outBegIdx,
1212                               int          *outNBElement,
1213                               int           outInteger[] );
1214 
1215 int TA_CDLENGULFING_Lookback( void );
1216 
1217 
1218 /*
1219  * TA_CDLEVENINGDOJISTAR - Evening Doji Star
1220  *
1221  * Input  = Open, High, Low, Close
1222  * Output = int
1223  *
1224  * Optional Parameters
1225  * -------------------
1226  * optInPenetration:(From 0 to TA_REAL_MAX)
1227  *    Percentage of penetration of a candle within another candle
1228  *
1229  *
1230  */
1231 TA_RetCode TA_CDLEVENINGDOJISTAR( int    startIdx,
1232                                   int    endIdx,
1233                                   const double inOpen[],
1234                                   const double inHigh[],
1235                                   const double inLow[],
1236                                   const double inClose[],
1237                                   double        optInPenetration, /* From 0 to TA_REAL_MAX */
1238                                   int          *outBegIdx,
1239                                   int          *outNBElement,
1240                                   int           outInteger[] );
1241 
1242 TA_RetCode TA_S_CDLEVENINGDOJISTAR( int    startIdx,
1243                                     int    endIdx,
1244                                     const float  inOpen[],
1245                                     const float  inHigh[],
1246                                     const float  inLow[],
1247                                     const float  inClose[],
1248                                     double        optInPenetration, /* From 0 to TA_REAL_MAX */
1249                                     int          *outBegIdx,
1250                                     int          *outNBElement,
1251                                     int           outInteger[] );
1252 
1253 int TA_CDLEVENINGDOJISTAR_Lookback( double        optInPenetration );  /* From 0 to TA_REAL_MAX */
1254 
1255 
1256 /*
1257  * TA_CDLEVENINGSTAR - Evening Star
1258  *
1259  * Input  = Open, High, Low, Close
1260  * Output = int
1261  *
1262  * Optional Parameters
1263  * -------------------
1264  * optInPenetration:(From 0 to TA_REAL_MAX)
1265  *    Percentage of penetration of a candle within another candle
1266  *
1267  *
1268  */
1269 TA_RetCode TA_CDLEVENINGSTAR( int    startIdx,
1270                               int    endIdx,
1271                               const double inOpen[],
1272                               const double inHigh[],
1273                               const double inLow[],
1274                               const double inClose[],
1275                               double        optInPenetration, /* From 0 to TA_REAL_MAX */
1276                               int          *outBegIdx,
1277                               int          *outNBElement,
1278                               int           outInteger[] );
1279 
1280 TA_RetCode TA_S_CDLEVENINGSTAR( int    startIdx,
1281                                 int    endIdx,
1282                                 const float  inOpen[],
1283                                 const float  inHigh[],
1284                                 const float  inLow[],
1285                                 const float  inClose[],
1286                                 double        optInPenetration, /* From 0 to TA_REAL_MAX */
1287                                 int          *outBegIdx,
1288                                 int          *outNBElement,
1289                                 int           outInteger[] );
1290 
1291 int TA_CDLEVENINGSTAR_Lookback( double        optInPenetration );  /* From 0 to TA_REAL_MAX */
1292 
1293 
1294 /*
1295  * TA_CDLGAPSIDESIDEWHITE - Up/Down-gap side-by-side white lines
1296  *
1297  * Input  = Open, High, Low, Close
1298  * Output = int
1299  *
1300  */
1301 TA_RetCode TA_CDLGAPSIDESIDEWHITE( int    startIdx,
1302                                    int    endIdx,
1303                                    const double inOpen[],
1304                                    const double inHigh[],
1305                                    const double inLow[],
1306                                    const double inClose[],
1307                                    int          *outBegIdx,
1308                                    int          *outNBElement,
1309                                    int           outInteger[] );
1310 
1311 TA_RetCode TA_S_CDLGAPSIDESIDEWHITE( int    startIdx,
1312                                      int    endIdx,
1313                                      const float  inOpen[],
1314                                      const float  inHigh[],
1315                                      const float  inLow[],
1316                                      const float  inClose[],
1317                                      int          *outBegIdx,
1318                                      int          *outNBElement,
1319                                      int           outInteger[] );
1320 
1321 int TA_CDLGAPSIDESIDEWHITE_Lookback( void );
1322 
1323 
1324 /*
1325  * TA_CDLGRAVESTONEDOJI - Gravestone Doji
1326  *
1327  * Input  = Open, High, Low, Close
1328  * Output = int
1329  *
1330  */
1331 TA_RetCode TA_CDLGRAVESTONEDOJI( int    startIdx,
1332                                  int    endIdx,
1333                                  const double inOpen[],
1334                                  const double inHigh[],
1335                                  const double inLow[],
1336                                  const double inClose[],
1337                                  int          *outBegIdx,
1338                                  int          *outNBElement,
1339                                  int           outInteger[] );
1340 
1341 TA_RetCode TA_S_CDLGRAVESTONEDOJI( int    startIdx,
1342                                    int    endIdx,
1343                                    const float  inOpen[],
1344                                    const float  inHigh[],
1345                                    const float  inLow[],
1346                                    const float  inClose[],
1347                                    int          *outBegIdx,
1348                                    int          *outNBElement,
1349                                    int           outInteger[] );
1350 
1351 int TA_CDLGRAVESTONEDOJI_Lookback( void );
1352 
1353 
1354 /*
1355  * TA_CDLHAMMER - Hammer
1356  *
1357  * Input  = Open, High, Low, Close
1358  * Output = int
1359  *
1360  */
1361 TA_RetCode TA_CDLHAMMER( int    startIdx,
1362                          int    endIdx,
1363                          const double inOpen[],
1364                          const double inHigh[],
1365                          const double inLow[],
1366                          const double inClose[],
1367                          int          *outBegIdx,
1368                          int          *outNBElement,
1369                          int           outInteger[] );
1370 
1371 TA_RetCode TA_S_CDLHAMMER( int    startIdx,
1372                            int    endIdx,
1373                            const float  inOpen[],
1374                            const float  inHigh[],
1375                            const float  inLow[],
1376                            const float  inClose[],
1377                            int          *outBegIdx,
1378                            int          *outNBElement,
1379                            int           outInteger[] );
1380 
1381 int TA_CDLHAMMER_Lookback( void );
1382 
1383 
1384 /*
1385  * TA_CDLHANGINGMAN - Hanging Man
1386  *
1387  * Input  = Open, High, Low, Close
1388  * Output = int
1389  *
1390  */
1391 TA_RetCode TA_CDLHANGINGMAN( int    startIdx,
1392                              int    endIdx,
1393                              const double inOpen[],
1394                              const double inHigh[],
1395                              const double inLow[],
1396                              const double inClose[],
1397                              int          *outBegIdx,
1398                              int          *outNBElement,
1399                              int           outInteger[] );
1400 
1401 TA_RetCode TA_S_CDLHANGINGMAN( int    startIdx,
1402                                int    endIdx,
1403                                const float  inOpen[],
1404                                const float  inHigh[],
1405                                const float  inLow[],
1406                                const float  inClose[],
1407                                int          *outBegIdx,
1408                                int          *outNBElement,
1409                                int           outInteger[] );
1410 
1411 int TA_CDLHANGINGMAN_Lookback( void );
1412 
1413 
1414 /*
1415  * TA_CDLHARAMI - Harami Pattern
1416  *
1417  * Input  = Open, High, Low, Close
1418  * Output = int
1419  *
1420  */
1421 TA_RetCode TA_CDLHARAMI( int    startIdx,
1422                          int    endIdx,
1423                          const double inOpen[],
1424                          const double inHigh[],
1425                          const double inLow[],
1426                          const double inClose[],
1427                          int          *outBegIdx,
1428                          int          *outNBElement,
1429                          int           outInteger[] );
1430 
1431 TA_RetCode TA_S_CDLHARAMI( int    startIdx,
1432                            int    endIdx,
1433                            const float  inOpen[],
1434                            const float  inHigh[],
1435                            const float  inLow[],
1436                            const float  inClose[],
1437                            int          *outBegIdx,
1438                            int          *outNBElement,
1439                            int           outInteger[] );
1440 
1441 int TA_CDLHARAMI_Lookback( void );
1442 
1443 
1444 /*
1445  * TA_CDLHARAMICROSS - Harami Cross Pattern
1446  *
1447  * Input  = Open, High, Low, Close
1448  * Output = int
1449  *
1450  */
1451 TA_RetCode TA_CDLHARAMICROSS( int    startIdx,
1452                               int    endIdx,
1453                               const double inOpen[],
1454                               const double inHigh[],
1455                               const double inLow[],
1456                               const double inClose[],
1457                               int          *outBegIdx,
1458                               int          *outNBElement,
1459                               int           outInteger[] );
1460 
1461 TA_RetCode TA_S_CDLHARAMICROSS( int    startIdx,
1462                                 int    endIdx,
1463                                 const float  inOpen[],
1464                                 const float  inHigh[],
1465                                 const float  inLow[],
1466                                 const float  inClose[],
1467                                 int          *outBegIdx,
1468                                 int          *outNBElement,
1469                                 int           outInteger[] );
1470 
1471 int TA_CDLHARAMICROSS_Lookback( void );
1472 
1473 
1474 /*
1475  * TA_CDLHIGHWAVE - High-Wave Candle
1476  *
1477  * Input  = Open, High, Low, Close
1478  * Output = int
1479  *
1480  */
1481 TA_RetCode TA_CDLHIGHWAVE( int    startIdx,
1482                            int    endIdx,
1483                            const double inOpen[],
1484                            const double inHigh[],
1485                            const double inLow[],
1486                            const double inClose[],
1487                            int          *outBegIdx,
1488                            int          *outNBElement,
1489                            int           outInteger[] );
1490 
1491 TA_RetCode TA_S_CDLHIGHWAVE( int    startIdx,
1492                              int    endIdx,
1493                              const float  inOpen[],
1494                              const float  inHigh[],
1495                              const float  inLow[],
1496                              const float  inClose[],
1497                              int          *outBegIdx,
1498                              int          *outNBElement,
1499                              int           outInteger[] );
1500 
1501 int TA_CDLHIGHWAVE_Lookback( void );
1502 
1503 
1504 /*
1505  * TA_CDLHIKKAKE - Hikkake Pattern
1506  *
1507  * Input  = Open, High, Low, Close
1508  * Output = int
1509  *
1510  */
1511 TA_RetCode TA_CDLHIKKAKE( int    startIdx,
1512                           int    endIdx,
1513                           const double inOpen[],
1514                           const double inHigh[],
1515                           const double inLow[],
1516                           const double inClose[],
1517                           int          *outBegIdx,
1518                           int          *outNBElement,
1519                           int           outInteger[] );
1520 
1521 TA_RetCode TA_S_CDLHIKKAKE( int    startIdx,
1522                             int    endIdx,
1523                             const float  inOpen[],
1524                             const float  inHigh[],
1525                             const float  inLow[],
1526                             const float  inClose[],
1527                             int          *outBegIdx,
1528                             int          *outNBElement,
1529                             int           outInteger[] );
1530 
1531 int TA_CDLHIKKAKE_Lookback( void );
1532 
1533 
1534 /*
1535  * TA_CDLHIKKAKEMOD - Modified Hikkake Pattern
1536  *
1537  * Input  = Open, High, Low, Close
1538  * Output = int
1539  *
1540  */
1541 TA_RetCode TA_CDLHIKKAKEMOD( int    startIdx,
1542                              int    endIdx,
1543                              const double inOpen[],
1544                              const double inHigh[],
1545                              const double inLow[],
1546                              const double inClose[],
1547                              int          *outBegIdx,
1548                              int          *outNBElement,
1549                              int           outInteger[] );
1550 
1551 TA_RetCode TA_S_CDLHIKKAKEMOD( int    startIdx,
1552                                int    endIdx,
1553                                const float  inOpen[],
1554                                const float  inHigh[],
1555                                const float  inLow[],
1556                                const float  inClose[],
1557                                int          *outBegIdx,
1558                                int          *outNBElement,
1559                                int           outInteger[] );
1560 
1561 int TA_CDLHIKKAKEMOD_Lookback( void );
1562 
1563 
1564 /*
1565  * TA_CDLHOMINGPIGEON - Homing Pigeon
1566  *
1567  * Input  = Open, High, Low, Close
1568  * Output = int
1569  *
1570  */
1571 TA_RetCode TA_CDLHOMINGPIGEON( int    startIdx,
1572                                int    endIdx,
1573                                const double inOpen[],
1574                                const double inHigh[],
1575                                const double inLow[],
1576                                const double inClose[],
1577                                int          *outBegIdx,
1578                                int          *outNBElement,
1579                                int           outInteger[] );
1580 
1581 TA_RetCode TA_S_CDLHOMINGPIGEON( int    startIdx,
1582                                  int    endIdx,
1583                                  const float  inOpen[],
1584                                  const float  inHigh[],
1585                                  const float  inLow[],
1586                                  const float  inClose[],
1587                                  int          *outBegIdx,
1588                                  int          *outNBElement,
1589                                  int           outInteger[] );
1590 
1591 int TA_CDLHOMINGPIGEON_Lookback( void );
1592 
1593 
1594 /*
1595  * TA_CDLIDENTICAL3CROWS - Identical Three Crows
1596  *
1597  * Input  = Open, High, Low, Close
1598  * Output = int
1599  *
1600  */
1601 TA_RetCode TA_CDLIDENTICAL3CROWS( int    startIdx,
1602                                   int    endIdx,
1603                                   const double inOpen[],
1604                                   const double inHigh[],
1605                                   const double inLow[],
1606                                   const double inClose[],
1607                                   int          *outBegIdx,
1608                                   int          *outNBElement,
1609                                   int           outInteger[] );
1610 
1611 TA_RetCode TA_S_CDLIDENTICAL3CROWS( int    startIdx,
1612                                     int    endIdx,
1613                                     const float  inOpen[],
1614                                     const float  inHigh[],
1615                                     const float  inLow[],
1616                                     const float  inClose[],
1617                                     int          *outBegIdx,
1618                                     int          *outNBElement,
1619                                     int           outInteger[] );
1620 
1621 int TA_CDLIDENTICAL3CROWS_Lookback( void );
1622 
1623 
1624 /*
1625  * TA_CDLINNECK - In-Neck Pattern
1626  *
1627  * Input  = Open, High, Low, Close
1628  * Output = int
1629  *
1630  */
1631 TA_RetCode TA_CDLINNECK( int    startIdx,
1632                          int    endIdx,
1633                          const double inOpen[],
1634                          const double inHigh[],
1635                          const double inLow[],
1636                          const double inClose[],
1637                          int          *outBegIdx,
1638                          int          *outNBElement,
1639                          int           outInteger[] );
1640 
1641 TA_RetCode TA_S_CDLINNECK( int    startIdx,
1642                            int    endIdx,
1643                            const float  inOpen[],
1644                            const float  inHigh[],
1645                            const float  inLow[],
1646                            const float  inClose[],
1647                            int          *outBegIdx,
1648                            int          *outNBElement,
1649                            int           outInteger[] );
1650 
1651 int TA_CDLINNECK_Lookback( void );
1652 
1653 
1654 /*
1655  * TA_CDLINVERTEDHAMMER - Inverted Hammer
1656  *
1657  * Input  = Open, High, Low, Close
1658  * Output = int
1659  *
1660  */
1661 TA_RetCode TA_CDLINVERTEDHAMMER( int    startIdx,
1662                                  int    endIdx,
1663                                  const double inOpen[],
1664                                  const double inHigh[],
1665                                  const double inLow[],
1666                                  const double inClose[],
1667                                  int          *outBegIdx,
1668                                  int          *outNBElement,
1669                                  int           outInteger[] );
1670 
1671 TA_RetCode TA_S_CDLINVERTEDHAMMER( int    startIdx,
1672                                    int    endIdx,
1673                                    const float  inOpen[],
1674                                    const float  inHigh[],
1675                                    const float  inLow[],
1676                                    const float  inClose[],
1677                                    int          *outBegIdx,
1678                                    int          *outNBElement,
1679                                    int           outInteger[] );
1680 
1681 int TA_CDLINVERTEDHAMMER_Lookback( void );
1682 
1683 
1684 /*
1685  * TA_CDLKICKING - Kicking
1686  *
1687  * Input  = Open, High, Low, Close
1688  * Output = int
1689  *
1690  */
1691 TA_RetCode TA_CDLKICKING( int    startIdx,
1692                           int    endIdx,
1693                           const double inOpen[],
1694                           const double inHigh[],
1695                           const double inLow[],
1696                           const double inClose[],
1697                           int          *outBegIdx,
1698                           int          *outNBElement,
1699                           int           outInteger[] );
1700 
1701 TA_RetCode TA_S_CDLKICKING( int    startIdx,
1702                             int    endIdx,
1703                             const float  inOpen[],
1704                             const float  inHigh[],
1705                             const float  inLow[],
1706                             const float  inClose[],
1707                             int          *outBegIdx,
1708                             int          *outNBElement,
1709                             int           outInteger[] );
1710 
1711 int TA_CDLKICKING_Lookback( void );
1712 
1713 
1714 /*
1715  * TA_CDLKICKINGBYLENGTH - Kicking - bull/bear determined by the longer marubozu
1716  *
1717  * Input  = Open, High, Low, Close
1718  * Output = int
1719  *
1720  */
1721 TA_RetCode TA_CDLKICKINGBYLENGTH( int    startIdx,
1722                                   int    endIdx,
1723                                   const double inOpen[],
1724                                   const double inHigh[],
1725                                   const double inLow[],
1726                                   const double inClose[],
1727                                   int          *outBegIdx,
1728                                   int          *outNBElement,
1729                                   int           outInteger[] );
1730 
1731 TA_RetCode TA_S_CDLKICKINGBYLENGTH( int    startIdx,
1732                                     int    endIdx,
1733                                     const float  inOpen[],
1734                                     const float  inHigh[],
1735                                     const float  inLow[],
1736                                     const float  inClose[],
1737                                     int          *outBegIdx,
1738                                     int          *outNBElement,
1739                                     int           outInteger[] );
1740 
1741 int TA_CDLKICKINGBYLENGTH_Lookback( void );
1742 
1743 
1744 /*
1745  * TA_CDLLADDERBOTTOM - Ladder Bottom
1746  *
1747  * Input  = Open, High, Low, Close
1748  * Output = int
1749  *
1750  */
1751 TA_RetCode TA_CDLLADDERBOTTOM( int    startIdx,
1752                                int    endIdx,
1753                                const double inOpen[],
1754                                const double inHigh[],
1755                                const double inLow[],
1756                                const double inClose[],
1757                                int          *outBegIdx,
1758                                int          *outNBElement,
1759                                int           outInteger[] );
1760 
1761 TA_RetCode TA_S_CDLLADDERBOTTOM( int    startIdx,
1762                                  int    endIdx,
1763                                  const float  inOpen[],
1764                                  const float  inHigh[],
1765                                  const float  inLow[],
1766                                  const float  inClose[],
1767                                  int          *outBegIdx,
1768                                  int          *outNBElement,
1769                                  int           outInteger[] );
1770 
1771 int TA_CDLLADDERBOTTOM_Lookback( void );
1772 
1773 
1774 /*
1775  * TA_CDLLONGLEGGEDDOJI - Long Legged Doji
1776  *
1777  * Input  = Open, High, Low, Close
1778  * Output = int
1779  *
1780  */
1781 TA_RetCode TA_CDLLONGLEGGEDDOJI( int    startIdx,
1782                                  int    endIdx,
1783                                  const double inOpen[],
1784                                  const double inHigh[],
1785                                  const double inLow[],
1786                                  const double inClose[],
1787                                  int          *outBegIdx,
1788                                  int          *outNBElement,
1789                                  int           outInteger[] );
1790 
1791 TA_RetCode TA_S_CDLLONGLEGGEDDOJI( int    startIdx,
1792                                    int    endIdx,
1793                                    const float  inOpen[],
1794                                    const float  inHigh[],
1795                                    const float  inLow[],
1796                                    const float  inClose[],
1797                                    int          *outBegIdx,
1798                                    int          *outNBElement,
1799                                    int           outInteger[] );
1800 
1801 int TA_CDLLONGLEGGEDDOJI_Lookback( void );
1802 
1803 
1804 /*
1805  * TA_CDLLONGLINE - Long Line Candle
1806  *
1807  * Input  = Open, High, Low, Close
1808  * Output = int
1809  *
1810  */
1811 TA_RetCode TA_CDLLONGLINE( int    startIdx,
1812                            int    endIdx,
1813                            const double inOpen[],
1814                            const double inHigh[],
1815                            const double inLow[],
1816                            const double inClose[],
1817                            int          *outBegIdx,
1818                            int          *outNBElement,
1819                            int           outInteger[] );
1820 
1821 TA_RetCode TA_S_CDLLONGLINE( int    startIdx,
1822                              int    endIdx,
1823                              const float  inOpen[],
1824                              const float  inHigh[],
1825                              const float  inLow[],
1826                              const float  inClose[],
1827                              int          *outBegIdx,
1828                              int          *outNBElement,
1829                              int           outInteger[] );
1830 
1831 int TA_CDLLONGLINE_Lookback( void );
1832 
1833 
1834 /*
1835  * TA_CDLMARUBOZU - Marubozu
1836  *
1837  * Input  = Open, High, Low, Close
1838  * Output = int
1839  *
1840  */
1841 TA_RetCode TA_CDLMARUBOZU( int    startIdx,
1842                            int    endIdx,
1843                            const double inOpen[],
1844                            const double inHigh[],
1845                            const double inLow[],
1846                            const double inClose[],
1847                            int          *outBegIdx,
1848                            int          *outNBElement,
1849                            int           outInteger[] );
1850 
1851 TA_RetCode TA_S_CDLMARUBOZU( int    startIdx,
1852                              int    endIdx,
1853                              const float  inOpen[],
1854                              const float  inHigh[],
1855                              const float  inLow[],
1856                              const float  inClose[],
1857                              int          *outBegIdx,
1858                              int          *outNBElement,
1859                              int           outInteger[] );
1860 
1861 int TA_CDLMARUBOZU_Lookback( void );
1862 
1863 
1864 /*
1865  * TA_CDLMATCHINGLOW - Matching Low
1866  *
1867  * Input  = Open, High, Low, Close
1868  * Output = int
1869  *
1870  */
1871 TA_RetCode TA_CDLMATCHINGLOW( int    startIdx,
1872                               int    endIdx,
1873                               const double inOpen[],
1874                               const double inHigh[],
1875                               const double inLow[],
1876                               const double inClose[],
1877                               int          *outBegIdx,
1878                               int          *outNBElement,
1879                               int           outInteger[] );
1880 
1881 TA_RetCode TA_S_CDLMATCHINGLOW( int    startIdx,
1882                                 int    endIdx,
1883                                 const float  inOpen[],
1884                                 const float  inHigh[],
1885                                 const float  inLow[],
1886                                 const float  inClose[],
1887                                 int          *outBegIdx,
1888                                 int          *outNBElement,
1889                                 int           outInteger[] );
1890 
1891 int TA_CDLMATCHINGLOW_Lookback( void );
1892 
1893 
1894 /*
1895  * TA_CDLMATHOLD - Mat Hold
1896  *
1897  * Input  = Open, High, Low, Close
1898  * Output = int
1899  *
1900  * Optional Parameters
1901  * -------------------
1902  * optInPenetration:(From 0 to TA_REAL_MAX)
1903  *    Percentage of penetration of a candle within another candle
1904  *
1905  *
1906  */
1907 TA_RetCode TA_CDLMATHOLD( int    startIdx,
1908                           int    endIdx,
1909                           const double inOpen[],
1910                           const double inHigh[],
1911                           const double inLow[],
1912                           const double inClose[],
1913                           double        optInPenetration, /* From 0 to TA_REAL_MAX */
1914                           int          *outBegIdx,
1915                           int          *outNBElement,
1916                           int           outInteger[] );
1917 
1918 TA_RetCode TA_S_CDLMATHOLD( int    startIdx,
1919                             int    endIdx,
1920                             const float  inOpen[],
1921                             const float  inHigh[],
1922                             const float  inLow[],
1923                             const float  inClose[],
1924                             double        optInPenetration, /* From 0 to TA_REAL_MAX */
1925                             int          *outBegIdx,
1926                             int          *outNBElement,
1927                             int           outInteger[] );
1928 
1929 int TA_CDLMATHOLD_Lookback( double        optInPenetration );  /* From 0 to TA_REAL_MAX */
1930 
1931 
1932 /*
1933  * TA_CDLMORNINGDOJISTAR - Morning Doji Star
1934  *
1935  * Input  = Open, High, Low, Close
1936  * Output = int
1937  *
1938  * Optional Parameters
1939  * -------------------
1940  * optInPenetration:(From 0 to TA_REAL_MAX)
1941  *    Percentage of penetration of a candle within another candle
1942  *
1943  *
1944  */
1945 TA_RetCode TA_CDLMORNINGDOJISTAR( int    startIdx,
1946                                   int    endIdx,
1947                                   const double inOpen[],
1948                                   const double inHigh[],
1949                                   const double inLow[],
1950                                   const double inClose[],
1951                                   double        optInPenetration, /* From 0 to TA_REAL_MAX */
1952                                   int          *outBegIdx,
1953                                   int          *outNBElement,
1954                                   int           outInteger[] );
1955 
1956 TA_RetCode TA_S_CDLMORNINGDOJISTAR( int    startIdx,
1957                                     int    endIdx,
1958                                     const float  inOpen[],
1959                                     const float  inHigh[],
1960                                     const float  inLow[],
1961                                     const float  inClose[],
1962                                     double        optInPenetration, /* From 0 to TA_REAL_MAX */
1963                                     int          *outBegIdx,
1964                                     int          *outNBElement,
1965                                     int           outInteger[] );
1966 
1967 int TA_CDLMORNINGDOJISTAR_Lookback( double        optInPenetration );  /* From 0 to TA_REAL_MAX */
1968 
1969 
1970 /*
1971  * TA_CDLMORNINGSTAR - Morning Star
1972  *
1973  * Input  = Open, High, Low, Close
1974  * Output = int
1975  *
1976  * Optional Parameters
1977  * -------------------
1978  * optInPenetration:(From 0 to TA_REAL_MAX)
1979  *    Percentage of penetration of a candle within another candle
1980  *
1981  *
1982  */
1983 TA_RetCode TA_CDLMORNINGSTAR( int    startIdx,
1984                               int    endIdx,
1985                               const double inOpen[],
1986                               const double inHigh[],
1987                               const double inLow[],
1988                               const double inClose[],
1989                               double        optInPenetration, /* From 0 to TA_REAL_MAX */
1990                               int          *outBegIdx,
1991                               int          *outNBElement,
1992                               int           outInteger[] );
1993 
1994 TA_RetCode TA_S_CDLMORNINGSTAR( int    startIdx,
1995                                 int    endIdx,
1996                                 const float  inOpen[],
1997                                 const float  inHigh[],
1998                                 const float  inLow[],
1999                                 const float  inClose[],
2000                                 double        optInPenetration, /* From 0 to TA_REAL_MAX */
2001                                 int          *outBegIdx,
2002                                 int          *outNBElement,
2003                                 int           outInteger[] );
2004 
2005 int TA_CDLMORNINGSTAR_Lookback( double        optInPenetration );  /* From 0 to TA_REAL_MAX */
2006 
2007 
2008 /*
2009  * TA_CDLONNECK - On-Neck Pattern
2010  *
2011  * Input  = Open, High, Low, Close
2012  * Output = int
2013  *
2014  */
2015 TA_RetCode TA_CDLONNECK( int    startIdx,
2016                          int    endIdx,
2017                          const double inOpen[],
2018                          const double inHigh[],
2019                          const double inLow[],
2020                          const double inClose[],
2021                          int          *outBegIdx,
2022                          int          *outNBElement,
2023                          int           outInteger[] );
2024 
2025 TA_RetCode TA_S_CDLONNECK( int    startIdx,
2026                            int    endIdx,
2027                            const float  inOpen[],
2028                            const float  inHigh[],
2029                            const float  inLow[],
2030                            const float  inClose[],
2031                            int          *outBegIdx,
2032                            int          *outNBElement,
2033                            int           outInteger[] );
2034 
2035 int TA_CDLONNECK_Lookback( void );
2036 
2037 
2038 /*
2039  * TA_CDLPIERCING - Piercing Pattern
2040  *
2041  * Input  = Open, High, Low, Close
2042  * Output = int
2043  *
2044  */
2045 TA_RetCode TA_CDLPIERCING( int    startIdx,
2046                            int    endIdx,
2047                            const double inOpen[],
2048                            const double inHigh[],
2049                            const double inLow[],
2050                            const double inClose[],
2051                            int          *outBegIdx,
2052                            int          *outNBElement,
2053                            int           outInteger[] );
2054 
2055 TA_RetCode TA_S_CDLPIERCING( int    startIdx,
2056                              int    endIdx,
2057                              const float  inOpen[],
2058                              const float  inHigh[],
2059                              const float  inLow[],
2060                              const float  inClose[],
2061                              int          *outBegIdx,
2062                              int          *outNBElement,
2063                              int           outInteger[] );
2064 
2065 int TA_CDLPIERCING_Lookback( void );
2066 
2067 
2068 /*
2069  * TA_CDLRICKSHAWMAN - Rickshaw Man
2070  *
2071  * Input  = Open, High, Low, Close
2072  * Output = int
2073  *
2074  */
2075 TA_RetCode TA_CDLRICKSHAWMAN( int    startIdx,
2076                               int    endIdx,
2077                               const double inOpen[],
2078                               const double inHigh[],
2079                               const double inLow[],
2080                               const double inClose[],
2081                               int          *outBegIdx,
2082                               int          *outNBElement,
2083                               int           outInteger[] );
2084 
2085 TA_RetCode TA_S_CDLRICKSHAWMAN( int    startIdx,
2086                                 int    endIdx,
2087                                 const float  inOpen[],
2088                                 const float  inHigh[],
2089                                 const float  inLow[],
2090                                 const float  inClose[],
2091                                 int          *outBegIdx,
2092                                 int          *outNBElement,
2093                                 int           outInteger[] );
2094 
2095 int TA_CDLRICKSHAWMAN_Lookback( void );
2096 
2097 
2098 /*
2099  * TA_CDLRISEFALL3METHODS - Rising/Falling Three Methods
2100  *
2101  * Input  = Open, High, Low, Close
2102  * Output = int
2103  *
2104  */
2105 TA_RetCode TA_CDLRISEFALL3METHODS( int    startIdx,
2106                                    int    endIdx,
2107                                    const double inOpen[],
2108                                    const double inHigh[],
2109                                    const double inLow[],
2110                                    const double inClose[],
2111                                    int          *outBegIdx,
2112                                    int          *outNBElement,
2113                                    int           outInteger[] );
2114 
2115 TA_RetCode TA_S_CDLRISEFALL3METHODS( int    startIdx,
2116                                      int    endIdx,
2117                                      const float  inOpen[],
2118                                      const float  inHigh[],
2119                                      const float  inLow[],
2120                                      const float  inClose[],
2121                                      int          *outBegIdx,
2122                                      int          *outNBElement,
2123                                      int           outInteger[] );
2124 
2125 int TA_CDLRISEFALL3METHODS_Lookback( void );
2126 
2127 
2128 /*
2129  * TA_CDLSEPARATINGLINES - Separating Lines
2130  *
2131  * Input  = Open, High, Low, Close
2132  * Output = int
2133  *
2134  */
2135 TA_RetCode TA_CDLSEPARATINGLINES( int    startIdx,
2136                                   int    endIdx,
2137                                   const double inOpen[],
2138                                   const double inHigh[],
2139                                   const double inLow[],
2140                                   const double inClose[],
2141                                   int          *outBegIdx,
2142                                   int          *outNBElement,
2143                                   int           outInteger[] );
2144 
2145 TA_RetCode TA_S_CDLSEPARATINGLINES( int    startIdx,
2146                                     int    endIdx,
2147                                     const float  inOpen[],
2148                                     const float  inHigh[],
2149                                     const float  inLow[],
2150                                     const float  inClose[],
2151                                     int          *outBegIdx,
2152                                     int          *outNBElement,
2153                                     int           outInteger[] );
2154 
2155 int TA_CDLSEPARATINGLINES_Lookback( void );
2156 
2157 
2158 /*
2159  * TA_CDLSHOOTINGSTAR - Shooting Star
2160  *
2161  * Input  = Open, High, Low, Close
2162  * Output = int
2163  *
2164  */
2165 TA_RetCode TA_CDLSHOOTINGSTAR( int    startIdx,
2166                                int    endIdx,
2167                                const double inOpen[],
2168                                const double inHigh[],
2169                                const double inLow[],
2170                                const double inClose[],
2171                                int          *outBegIdx,
2172                                int          *outNBElement,
2173                                int           outInteger[] );
2174 
2175 TA_RetCode TA_S_CDLSHOOTINGSTAR( int    startIdx,
2176                                  int    endIdx,
2177                                  const float  inOpen[],
2178                                  const float  inHigh[],
2179                                  const float  inLow[],
2180                                  const float  inClose[],
2181                                  int          *outBegIdx,
2182                                  int          *outNBElement,
2183                                  int           outInteger[] );
2184 
2185 int TA_CDLSHOOTINGSTAR_Lookback( void );
2186 
2187 
2188 /*
2189  * TA_CDLSHORTLINE - Short Line Candle
2190  *
2191  * Input  = Open, High, Low, Close
2192  * Output = int
2193  *
2194  */
2195 TA_RetCode TA_CDLSHORTLINE( int    startIdx,
2196                             int    endIdx,
2197                             const double inOpen[],
2198                             const double inHigh[],
2199                             const double inLow[],
2200                             const double inClose[],
2201                             int          *outBegIdx,
2202                             int          *outNBElement,
2203                             int           outInteger[] );
2204 
2205 TA_RetCode TA_S_CDLSHORTLINE( int    startIdx,
2206                               int    endIdx,
2207                               const float  inOpen[],
2208                               const float  inHigh[],
2209                               const float  inLow[],
2210                               const float  inClose[],
2211                               int          *outBegIdx,
2212                               int          *outNBElement,
2213                               int           outInteger[] );
2214 
2215 int TA_CDLSHORTLINE_Lookback( void );
2216 
2217 
2218 /*
2219  * TA_CDLSPINNINGTOP - Spinning Top
2220  *
2221  * Input  = Open, High, Low, Close
2222  * Output = int
2223  *
2224  */
2225 TA_RetCode TA_CDLSPINNINGTOP( int    startIdx,
2226                               int    endIdx,
2227                               const double inOpen[],
2228                               const double inHigh[],
2229                               const double inLow[],
2230                               const double inClose[],
2231                               int          *outBegIdx,
2232                               int          *outNBElement,
2233                               int           outInteger[] );
2234 
2235 TA_RetCode TA_S_CDLSPINNINGTOP( int    startIdx,
2236                                 int    endIdx,
2237                                 const float  inOpen[],
2238                                 const float  inHigh[],
2239                                 const float  inLow[],
2240                                 const float  inClose[],
2241                                 int          *outBegIdx,
2242                                 int          *outNBElement,
2243                                 int           outInteger[] );
2244 
2245 int TA_CDLSPINNINGTOP_Lookback( void );
2246 
2247 
2248 /*
2249  * TA_CDLSTALLEDPATTERN - Stalled Pattern
2250  *
2251  * Input  = Open, High, Low, Close
2252  * Output = int
2253  *
2254  */
2255 TA_RetCode TA_CDLSTALLEDPATTERN( int    startIdx,
2256                                  int    endIdx,
2257                                  const double inOpen[],
2258                                  const double inHigh[],
2259                                  const double inLow[],
2260                                  const double inClose[],
2261                                  int          *outBegIdx,
2262                                  int          *outNBElement,
2263                                  int           outInteger[] );
2264 
2265 TA_RetCode TA_S_CDLSTALLEDPATTERN( int    startIdx,
2266                                    int    endIdx,
2267                                    const float  inOpen[],
2268                                    const float  inHigh[],
2269                                    const float  inLow[],
2270                                    const float  inClose[],
2271                                    int          *outBegIdx,
2272                                    int          *outNBElement,
2273                                    int           outInteger[] );
2274 
2275 int TA_CDLSTALLEDPATTERN_Lookback( void );
2276 
2277 
2278 /*
2279  * TA_CDLSTICKSANDWICH - Stick Sandwich
2280  *
2281  * Input  = Open, High, Low, Close
2282  * Output = int
2283  *
2284  */
2285 TA_RetCode TA_CDLSTICKSANDWICH( int    startIdx,
2286                                 int    endIdx,
2287                                 const double inOpen[],
2288                                 const double inHigh[],
2289                                 const double inLow[],
2290                                 const double inClose[],
2291                                 int          *outBegIdx,
2292                                 int          *outNBElement,
2293                                 int           outInteger[] );
2294 
2295 TA_RetCode TA_S_CDLSTICKSANDWICH( int    startIdx,
2296                                   int    endIdx,
2297                                   const float  inOpen[],
2298                                   const float  inHigh[],
2299                                   const float  inLow[],
2300                                   const float  inClose[],
2301                                   int          *outBegIdx,
2302                                   int          *outNBElement,
2303                                   int           outInteger[] );
2304 
2305 int TA_CDLSTICKSANDWICH_Lookback( void );
2306 
2307 
2308 /*
2309  * TA_CDLTAKURI - Takuri (Dragonfly Doji with very long lower shadow)
2310  *
2311  * Input  = Open, High, Low, Close
2312  * Output = int
2313  *
2314  */
2315 TA_RetCode TA_CDLTAKURI( int    startIdx,
2316                          int    endIdx,
2317                          const double inOpen[],
2318                          const double inHigh[],
2319                          const double inLow[],
2320                          const double inClose[],
2321                          int          *outBegIdx,
2322                          int          *outNBElement,
2323                          int           outInteger[] );
2324 
2325 TA_RetCode TA_S_CDLTAKURI( int    startIdx,
2326                            int    endIdx,
2327                            const float  inOpen[],
2328                            const float  inHigh[],
2329                            const float  inLow[],
2330                            const float  inClose[],
2331                            int          *outBegIdx,
2332                            int          *outNBElement,
2333                            int           outInteger[] );
2334 
2335 int TA_CDLTAKURI_Lookback( void );
2336 
2337 
2338 /*
2339  * TA_CDLTASUKIGAP - Tasuki Gap
2340  *
2341  * Input  = Open, High, Low, Close
2342  * Output = int
2343  *
2344  */
2345 TA_RetCode TA_CDLTASUKIGAP( int    startIdx,
2346                             int    endIdx,
2347                             const double inOpen[],
2348                             const double inHigh[],
2349                             const double inLow[],
2350                             const double inClose[],
2351                             int          *outBegIdx,
2352                             int          *outNBElement,
2353                             int           outInteger[] );
2354 
2355 TA_RetCode TA_S_CDLTASUKIGAP( int    startIdx,
2356                               int    endIdx,
2357                               const float  inOpen[],
2358                               const float  inHigh[],
2359                               const float  inLow[],
2360                               const float  inClose[],
2361                               int          *outBegIdx,
2362                               int          *outNBElement,
2363                               int           outInteger[] );
2364 
2365 int TA_CDLTASUKIGAP_Lookback( void );
2366 
2367 
2368 /*
2369  * TA_CDLTHRUSTING - Thrusting Pattern
2370  *
2371  * Input  = Open, High, Low, Close
2372  * Output = int
2373  *
2374  */
2375 TA_RetCode TA_CDLTHRUSTING( int    startIdx,
2376                             int    endIdx,
2377                             const double inOpen[],
2378                             const double inHigh[],
2379                             const double inLow[],
2380                             const double inClose[],
2381                             int          *outBegIdx,
2382                             int          *outNBElement,
2383                             int           outInteger[] );
2384 
2385 TA_RetCode TA_S_CDLTHRUSTING( int    startIdx,
2386                               int    endIdx,
2387                               const float  inOpen[],
2388                               const float  inHigh[],
2389                               const float  inLow[],
2390                               const float  inClose[],
2391                               int          *outBegIdx,
2392                               int          *outNBElement,
2393                               int           outInteger[] );
2394 
2395 int TA_CDLTHRUSTING_Lookback( void );
2396 
2397 
2398 /*
2399  * TA_CDLTRISTAR - Tristar Pattern
2400  *
2401  * Input  = Open, High, Low, Close
2402  * Output = int
2403  *
2404  */
2405 TA_RetCode TA_CDLTRISTAR( int    startIdx,
2406                           int    endIdx,
2407                           const double inOpen[],
2408                           const double inHigh[],
2409                           const double inLow[],
2410                           const double inClose[],
2411                           int          *outBegIdx,
2412                           int          *outNBElement,
2413                           int           outInteger[] );
2414 
2415 TA_RetCode TA_S_CDLTRISTAR( int    startIdx,
2416                             int    endIdx,
2417                             const float  inOpen[],
2418                             const float  inHigh[],
2419                             const float  inLow[],
2420                             const float  inClose[],
2421                             int          *outBegIdx,
2422                             int          *outNBElement,
2423                             int           outInteger[] );
2424 
2425 int TA_CDLTRISTAR_Lookback( void );
2426 
2427 
2428 /*
2429  * TA_CDLUNIQUE3RIVER - Unique 3 River
2430  *
2431  * Input  = Open, High, Low, Close
2432  * Output = int
2433  *
2434  */
2435 TA_RetCode TA_CDLUNIQUE3RIVER( int    startIdx,
2436                                int    endIdx,
2437                                const double inOpen[],
2438                                const double inHigh[],
2439                                const double inLow[],
2440                                const double inClose[],
2441                                int          *outBegIdx,
2442                                int          *outNBElement,
2443                                int           outInteger[] );
2444 
2445 TA_RetCode TA_S_CDLUNIQUE3RIVER( int    startIdx,
2446                                  int    endIdx,
2447                                  const float  inOpen[],
2448                                  const float  inHigh[],
2449                                  const float  inLow[],
2450                                  const float  inClose[],
2451                                  int          *outBegIdx,
2452                                  int          *outNBElement,
2453                                  int           outInteger[] );
2454 
2455 int TA_CDLUNIQUE3RIVER_Lookback( void );
2456 
2457 
2458 /*
2459  * TA_CDLUPSIDEGAP2CROWS - Upside Gap Two Crows
2460  *
2461  * Input  = Open, High, Low, Close
2462  * Output = int
2463  *
2464  */
2465 TA_RetCode TA_CDLUPSIDEGAP2CROWS( int    startIdx,
2466                                   int    endIdx,
2467                                   const double inOpen[],
2468                                   const double inHigh[],
2469                                   const double inLow[],
2470                                   const double inClose[],
2471                                   int          *outBegIdx,
2472                                   int          *outNBElement,
2473                                   int           outInteger[] );
2474 
2475 TA_RetCode TA_S_CDLUPSIDEGAP2CROWS( int    startIdx,
2476                                     int    endIdx,
2477                                     const float  inOpen[],
2478                                     const float  inHigh[],
2479                                     const float  inLow[],
2480                                     const float  inClose[],
2481                                     int          *outBegIdx,
2482                                     int          *outNBElement,
2483                                     int           outInteger[] );
2484 
2485 int TA_CDLUPSIDEGAP2CROWS_Lookback( void );
2486 
2487 
2488 /*
2489  * TA_CDLXSIDEGAP3METHODS - Upside/Downside Gap Three Methods
2490  *
2491  * Input  = Open, High, Low, Close
2492  * Output = int
2493  *
2494  */
2495 TA_RetCode TA_CDLXSIDEGAP3METHODS( int    startIdx,
2496                                    int    endIdx,
2497                                    const double inOpen[],
2498                                    const double inHigh[],
2499                                    const double inLow[],
2500                                    const double inClose[],
2501                                    int          *outBegIdx,
2502                                    int          *outNBElement,
2503                                    int           outInteger[] );
2504 
2505 TA_RetCode TA_S_CDLXSIDEGAP3METHODS( int    startIdx,
2506                                      int    endIdx,
2507                                      const float  inOpen[],
2508                                      const float  inHigh[],
2509                                      const float  inLow[],
2510                                      const float  inClose[],
2511                                      int          *outBegIdx,
2512                                      int          *outNBElement,
2513                                      int           outInteger[] );
2514 
2515 int TA_CDLXSIDEGAP3METHODS_Lookback( void );
2516 
2517 
2518 /*
2519  * TA_CEIL - Vector Ceil
2520  *
2521  * Input  = double
2522  * Output = double
2523  *
2524  */
2525 TA_RetCode TA_CEIL( int    startIdx,
2526                     int    endIdx,
2527                     const double inReal[],
2528                     int          *outBegIdx,
2529                     int          *outNBElement,
2530                     double        outReal[] );
2531 
2532 TA_RetCode TA_S_CEIL( int    startIdx,
2533                       int    endIdx,
2534                       const float  inReal[],
2535                       int          *outBegIdx,
2536                       int          *outNBElement,
2537                       double        outReal[] );
2538 
2539 int TA_CEIL_Lookback( void );
2540 
2541 
2542 /*
2543  * TA_CMO - Chande Momentum Oscillator
2544  *
2545  * Input  = double
2546  * Output = double
2547  *
2548  * Optional Parameters
2549  * -------------------
2550  * optInTimePeriod:(From 2 to 100000)
2551  *    Number of period
2552  *
2553  *
2554  */
2555 TA_RetCode TA_CMO( int    startIdx,
2556                    int    endIdx,
2557                    const double inReal[],
2558                    int           optInTimePeriod, /* From 2 to 100000 */
2559                    int          *outBegIdx,
2560                    int          *outNBElement,
2561                    double        outReal[] );
2562 
2563 TA_RetCode TA_S_CMO( int    startIdx,
2564                      int    endIdx,
2565                      const float  inReal[],
2566                      int           optInTimePeriod, /* From 2 to 100000 */
2567                      int          *outBegIdx,
2568                      int          *outNBElement,
2569                      double        outReal[] );
2570 
2571 int TA_CMO_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
2572 
2573 
2574 /*
2575  * TA_CORREL - Pearson's Correlation Coefficient (r)
2576  *
2577  * Input  = double, double
2578  * Output = double
2579  *
2580  * Optional Parameters
2581  * -------------------
2582  * optInTimePeriod:(From 1 to 100000)
2583  *    Number of period
2584  *
2585  *
2586  */
2587 TA_RetCode TA_CORREL( int    startIdx,
2588                       int    endIdx,
2589                       const double inReal0[],
2590                       const double inReal1[],
2591                       int           optInTimePeriod, /* From 1 to 100000 */
2592                       int          *outBegIdx,
2593                       int          *outNBElement,
2594                       double        outReal[] );
2595 
2596 TA_RetCode TA_S_CORREL( int    startIdx,
2597                         int    endIdx,
2598                         const float  inReal0[],
2599                         const float  inReal1[],
2600                         int           optInTimePeriod, /* From 1 to 100000 */
2601                         int          *outBegIdx,
2602                         int          *outNBElement,
2603                         double        outReal[] );
2604 
2605 int TA_CORREL_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
2606 
2607 
2608 /*
2609  * TA_COS - Vector Trigonometric Cos
2610  *
2611  * Input  = double
2612  * Output = double
2613  *
2614  */
2615 TA_RetCode TA_COS( int    startIdx,
2616                    int    endIdx,
2617                    const double inReal[],
2618                    int          *outBegIdx,
2619                    int          *outNBElement,
2620                    double        outReal[] );
2621 
2622 TA_RetCode TA_S_COS( int    startIdx,
2623                      int    endIdx,
2624                      const float  inReal[],
2625                      int          *outBegIdx,
2626                      int          *outNBElement,
2627                      double        outReal[] );
2628 
2629 int TA_COS_Lookback( void );
2630 
2631 
2632 /*
2633  * TA_COSH - Vector Trigonometric Cosh
2634  *
2635  * Input  = double
2636  * Output = double
2637  *
2638  */
2639 TA_RetCode TA_COSH( int    startIdx,
2640                     int    endIdx,
2641                     const double inReal[],
2642                     int          *outBegIdx,
2643                     int          *outNBElement,
2644                     double        outReal[] );
2645 
2646 TA_RetCode TA_S_COSH( int    startIdx,
2647                       int    endIdx,
2648                       const float  inReal[],
2649                       int          *outBegIdx,
2650                       int          *outNBElement,
2651                       double        outReal[] );
2652 
2653 int TA_COSH_Lookback( void );
2654 
2655 
2656 /*
2657  * TA_DEMA - Double Exponential Moving Average
2658  *
2659  * Input  = double
2660  * Output = double
2661  *
2662  * Optional Parameters
2663  * -------------------
2664  * optInTimePeriod:(From 2 to 100000)
2665  *    Number of period
2666  *
2667  *
2668  */
2669 TA_RetCode TA_DEMA( int    startIdx,
2670                     int    endIdx,
2671                     const double inReal[],
2672                     int           optInTimePeriod, /* From 2 to 100000 */
2673                     int          *outBegIdx,
2674                     int          *outNBElement,
2675                     double        outReal[] );
2676 
2677 TA_RetCode TA_S_DEMA( int    startIdx,
2678                       int    endIdx,
2679                       const float  inReal[],
2680                       int           optInTimePeriod, /* From 2 to 100000 */
2681                       int          *outBegIdx,
2682                       int          *outNBElement,
2683                       double        outReal[] );
2684 
2685 int TA_DEMA_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
2686 
2687 
2688 /*
2689  * TA_DIV - Vector Arithmetic Div
2690  *
2691  * Input  = double, double
2692  * Output = double
2693  *
2694  */
2695 TA_RetCode TA_DIV( int    startIdx,
2696                    int    endIdx,
2697                    const double inReal0[],
2698                    const double inReal1[],
2699                    int          *outBegIdx,
2700                    int          *outNBElement,
2701                    double        outReal[] );
2702 
2703 TA_RetCode TA_S_DIV( int    startIdx,
2704                      int    endIdx,
2705                      const float  inReal0[],
2706                      const float  inReal1[],
2707                      int          *outBegIdx,
2708                      int          *outNBElement,
2709                      double        outReal[] );
2710 
2711 int TA_DIV_Lookback( void );
2712 
2713 
2714 /*
2715  * TA_DX - Directional Movement Index
2716  *
2717  * Input  = High, Low, Close
2718  * Output = double
2719  *
2720  * Optional Parameters
2721  * -------------------
2722  * optInTimePeriod:(From 2 to 100000)
2723  *    Number of period
2724  *
2725  *
2726  */
2727 TA_RetCode TA_DX( int    startIdx,
2728                   int    endIdx,
2729                   const double inHigh[],
2730                   const double inLow[],
2731                   const double inClose[],
2732                   int           optInTimePeriod, /* From 2 to 100000 */
2733                   int          *outBegIdx,
2734                   int          *outNBElement,
2735                   double        outReal[] );
2736 
2737 TA_RetCode TA_S_DX( int    startIdx,
2738                     int    endIdx,
2739                     const float  inHigh[],
2740                     const float  inLow[],
2741                     const float  inClose[],
2742                     int           optInTimePeriod, /* From 2 to 100000 */
2743                     int          *outBegIdx,
2744                     int          *outNBElement,
2745                     double        outReal[] );
2746 
2747 int TA_DX_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
2748 
2749 
2750 /*
2751  * TA_EMA - Exponential Moving Average
2752  *
2753  * Input  = double
2754  * Output = double
2755  *
2756  * Optional Parameters
2757  * -------------------
2758  * optInTimePeriod:(From 2 to 100000)
2759  *    Number of period
2760  *
2761  *
2762  */
2763 TA_RetCode TA_EMA( int    startIdx,
2764                    int    endIdx,
2765                    const double inReal[],
2766                    int           optInTimePeriod, /* From 2 to 100000 */
2767                    int          *outBegIdx,
2768                    int          *outNBElement,
2769                    double        outReal[] );
2770 
2771 TA_RetCode TA_S_EMA( int    startIdx,
2772                      int    endIdx,
2773                      const float  inReal[],
2774                      int           optInTimePeriod, /* From 2 to 100000 */
2775                      int          *outBegIdx,
2776                      int          *outNBElement,
2777                      double        outReal[] );
2778 
2779 int TA_EMA_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
2780 
2781 
2782 /*
2783  * TA_EXP - Vector Arithmetic Exp
2784  *
2785  * Input  = double
2786  * Output = double
2787  *
2788  */
2789 TA_RetCode TA_EXP( int    startIdx,
2790                    int    endIdx,
2791                    const double inReal[],
2792                    int          *outBegIdx,
2793                    int          *outNBElement,
2794                    double        outReal[] );
2795 
2796 TA_RetCode TA_S_EXP( int    startIdx,
2797                      int    endIdx,
2798                      const float  inReal[],
2799                      int          *outBegIdx,
2800                      int          *outNBElement,
2801                      double        outReal[] );
2802 
2803 int TA_EXP_Lookback( void );
2804 
2805 
2806 /*
2807  * TA_FLOOR - Vector Floor
2808  *
2809  * Input  = double
2810  * Output = double
2811  *
2812  */
2813 TA_RetCode TA_FLOOR( int    startIdx,
2814                      int    endIdx,
2815                      const double inReal[],
2816                      int          *outBegIdx,
2817                      int          *outNBElement,
2818                      double        outReal[] );
2819 
2820 TA_RetCode TA_S_FLOOR( int    startIdx,
2821                        int    endIdx,
2822                        const float  inReal[],
2823                        int          *outBegIdx,
2824                        int          *outNBElement,
2825                        double        outReal[] );
2826 
2827 int TA_FLOOR_Lookback( void );
2828 
2829 
2830 /*
2831  * TA_HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period
2832  *
2833  * Input  = double
2834  * Output = double
2835  *
2836  */
2837 TA_RetCode TA_HT_DCPERIOD( int    startIdx,
2838                            int    endIdx,
2839                            const double inReal[],
2840                            int          *outBegIdx,
2841                            int          *outNBElement,
2842                            double        outReal[] );
2843 
2844 TA_RetCode TA_S_HT_DCPERIOD( int    startIdx,
2845                              int    endIdx,
2846                              const float  inReal[],
2847                              int          *outBegIdx,
2848                              int          *outNBElement,
2849                              double        outReal[] );
2850 
2851 int TA_HT_DCPERIOD_Lookback( void );
2852 
2853 
2854 /*
2855  * TA_HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase
2856  *
2857  * Input  = double
2858  * Output = double
2859  *
2860  */
2861 TA_RetCode TA_HT_DCPHASE( int    startIdx,
2862                           int    endIdx,
2863                           const double inReal[],
2864                           int          *outBegIdx,
2865                           int          *outNBElement,
2866                           double        outReal[] );
2867 
2868 TA_RetCode TA_S_HT_DCPHASE( int    startIdx,
2869                             int    endIdx,
2870                             const float  inReal[],
2871                             int          *outBegIdx,
2872                             int          *outNBElement,
2873                             double        outReal[] );
2874 
2875 int TA_HT_DCPHASE_Lookback( void );
2876 
2877 
2878 /*
2879  * TA_HT_PHASOR - Hilbert Transform - Phasor Components
2880  *
2881  * Input  = double
2882  * Output = double, double
2883  *
2884  */
2885 TA_RetCode TA_HT_PHASOR( int    startIdx,
2886                          int    endIdx,
2887                          const double inReal[],
2888                          int          *outBegIdx,
2889                          int          *outNBElement,
2890                          double        outInPhase[],
2891                          double        outQuadrature[] );
2892 
2893 TA_RetCode TA_S_HT_PHASOR( int    startIdx,
2894                            int    endIdx,
2895                            const float  inReal[],
2896                            int          *outBegIdx,
2897                            int          *outNBElement,
2898                            double        outInPhase[],
2899                            double        outQuadrature[] );
2900 
2901 int TA_HT_PHASOR_Lookback( void );
2902 
2903 
2904 /*
2905  * TA_HT_SINE - Hilbert Transform - SineWave
2906  *
2907  * Input  = double
2908  * Output = double, double
2909  *
2910  */
2911 TA_RetCode TA_HT_SINE( int    startIdx,
2912                        int    endIdx,
2913                        const double inReal[],
2914                        int          *outBegIdx,
2915                        int          *outNBElement,
2916                        double        outSine[],
2917                        double        outLeadSine[] );
2918 
2919 TA_RetCode TA_S_HT_SINE( int    startIdx,
2920                          int    endIdx,
2921                          const float  inReal[],
2922                          int          *outBegIdx,
2923                          int          *outNBElement,
2924                          double        outSine[],
2925                          double        outLeadSine[] );
2926 
2927 int TA_HT_SINE_Lookback( void );
2928 
2929 
2930 /*
2931  * TA_HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline
2932  *
2933  * Input  = double
2934  * Output = double
2935  *
2936  */
2937 TA_RetCode TA_HT_TRENDLINE( int    startIdx,
2938                             int    endIdx,
2939                             const double inReal[],
2940                             int          *outBegIdx,
2941                             int          *outNBElement,
2942                             double        outReal[] );
2943 
2944 TA_RetCode TA_S_HT_TRENDLINE( int    startIdx,
2945                               int    endIdx,
2946                               const float  inReal[],
2947                               int          *outBegIdx,
2948                               int          *outNBElement,
2949                               double        outReal[] );
2950 
2951 int TA_HT_TRENDLINE_Lookback( void );
2952 
2953 
2954 /*
2955  * TA_HT_TRENDMODE - Hilbert Transform - Trend vs Cycle Mode
2956  *
2957  * Input  = double
2958  * Output = int
2959  *
2960  */
2961 TA_RetCode TA_HT_TRENDMODE( int    startIdx,
2962                             int    endIdx,
2963                             const double inReal[],
2964                             int          *outBegIdx,
2965                             int          *outNBElement,
2966                             int           outInteger[] );
2967 
2968 TA_RetCode TA_S_HT_TRENDMODE( int    startIdx,
2969                               int    endIdx,
2970                               const float  inReal[],
2971                               int          *outBegIdx,
2972                               int          *outNBElement,
2973                               int           outInteger[] );
2974 
2975 int TA_HT_TRENDMODE_Lookback( void );
2976 
2977 
2978 /*
2979  * TA_KAMA - Kaufman Adaptive Moving Average
2980  *
2981  * Input  = double
2982  * Output = double
2983  *
2984  * Optional Parameters
2985  * -------------------
2986  * optInTimePeriod:(From 2 to 100000)
2987  *    Number of period
2988  *
2989  *
2990  */
2991 TA_RetCode TA_KAMA( int    startIdx,
2992                     int    endIdx,
2993                     const double inReal[],
2994                     int           optInTimePeriod, /* From 2 to 100000 */
2995                     int          *outBegIdx,
2996                     int          *outNBElement,
2997                     double        outReal[] );
2998 
2999 TA_RetCode TA_S_KAMA( int    startIdx,
3000                       int    endIdx,
3001                       const float  inReal[],
3002                       int           optInTimePeriod, /* From 2 to 100000 */
3003                       int          *outBegIdx,
3004                       int          *outNBElement,
3005                       double        outReal[] );
3006 
3007 int TA_KAMA_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3008 
3009 
3010 /*
3011  * TA_LINEARREG - Linear Regression
3012  *
3013  * Input  = double
3014  * Output = double
3015  *
3016  * Optional Parameters
3017  * -------------------
3018  * optInTimePeriod:(From 2 to 100000)
3019  *    Number of period
3020  *
3021  *
3022  */
3023 TA_RetCode TA_LINEARREG( int    startIdx,
3024                          int    endIdx,
3025                          const double inReal[],
3026                          int           optInTimePeriod, /* From 2 to 100000 */
3027                          int          *outBegIdx,
3028                          int          *outNBElement,
3029                          double        outReal[] );
3030 
3031 TA_RetCode TA_S_LINEARREG( int    startIdx,
3032                            int    endIdx,
3033                            const float  inReal[],
3034                            int           optInTimePeriod, /* From 2 to 100000 */
3035                            int          *outBegIdx,
3036                            int          *outNBElement,
3037                            double        outReal[] );
3038 
3039 int TA_LINEARREG_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3040 
3041 
3042 /*
3043  * TA_LINEARREG_ANGLE - Linear Regression Angle
3044  *
3045  * Input  = double
3046  * Output = double
3047  *
3048  * Optional Parameters
3049  * -------------------
3050  * optInTimePeriod:(From 2 to 100000)
3051  *    Number of period
3052  *
3053  *
3054  */
3055 TA_RetCode TA_LINEARREG_ANGLE( int    startIdx,
3056                                int    endIdx,
3057                                const double inReal[],
3058                                int           optInTimePeriod, /* From 2 to 100000 */
3059                                int          *outBegIdx,
3060                                int          *outNBElement,
3061                                double        outReal[] );
3062 
3063 TA_RetCode TA_S_LINEARREG_ANGLE( int    startIdx,
3064                                  int    endIdx,
3065                                  const float  inReal[],
3066                                  int           optInTimePeriod, /* From 2 to 100000 */
3067                                  int          *outBegIdx,
3068                                  int          *outNBElement,
3069                                  double        outReal[] );
3070 
3071 int TA_LINEARREG_ANGLE_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3072 
3073 
3074 /*
3075  * TA_LINEARREG_INTERCEPT - Linear Regression Intercept
3076  *
3077  * Input  = double
3078  * Output = double
3079  *
3080  * Optional Parameters
3081  * -------------------
3082  * optInTimePeriod:(From 2 to 100000)
3083  *    Number of period
3084  *
3085  *
3086  */
3087 TA_RetCode TA_LINEARREG_INTERCEPT( int    startIdx,
3088                                    int    endIdx,
3089                                    const double inReal[],
3090                                    int           optInTimePeriod, /* From 2 to 100000 */
3091                                    int          *outBegIdx,
3092                                    int          *outNBElement,
3093                                    double        outReal[] );
3094 
3095 TA_RetCode TA_S_LINEARREG_INTERCEPT( int    startIdx,
3096                                      int    endIdx,
3097                                      const float  inReal[],
3098                                      int           optInTimePeriod, /* From 2 to 100000 */
3099                                      int          *outBegIdx,
3100                                      int          *outNBElement,
3101                                      double        outReal[] );
3102 
3103 int TA_LINEARREG_INTERCEPT_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3104 
3105 
3106 /*
3107  * TA_LINEARREG_SLOPE - Linear Regression Slope
3108  *
3109  * Input  = double
3110  * Output = double
3111  *
3112  * Optional Parameters
3113  * -------------------
3114  * optInTimePeriod:(From 2 to 100000)
3115  *    Number of period
3116  *
3117  *
3118  */
3119 TA_RetCode TA_LINEARREG_SLOPE( int    startIdx,
3120                                int    endIdx,
3121                                const double inReal[],
3122                                int           optInTimePeriod, /* From 2 to 100000 */
3123                                int          *outBegIdx,
3124                                int          *outNBElement,
3125                                double        outReal[] );
3126 
3127 TA_RetCode TA_S_LINEARREG_SLOPE( int    startIdx,
3128                                  int    endIdx,
3129                                  const float  inReal[],
3130                                  int           optInTimePeriod, /* From 2 to 100000 */
3131                                  int          *outBegIdx,
3132                                  int          *outNBElement,
3133                                  double        outReal[] );
3134 
3135 int TA_LINEARREG_SLOPE_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3136 
3137 
3138 /*
3139  * TA_LN - Vector Log Natural
3140  *
3141  * Input  = double
3142  * Output = double
3143  *
3144  */
3145 TA_RetCode TA_LN( int    startIdx,
3146                   int    endIdx,
3147                   const double inReal[],
3148                   int          *outBegIdx,
3149                   int          *outNBElement,
3150                   double        outReal[] );
3151 
3152 TA_RetCode TA_S_LN( int    startIdx,
3153                     int    endIdx,
3154                     const float  inReal[],
3155                     int          *outBegIdx,
3156                     int          *outNBElement,
3157                     double        outReal[] );
3158 
3159 int TA_LN_Lookback( void );
3160 
3161 
3162 /*
3163  * TA_LOG10 - Vector Log10
3164  *
3165  * Input  = double
3166  * Output = double
3167  *
3168  */
3169 TA_RetCode TA_LOG10( int    startIdx,
3170                      int    endIdx,
3171                      const double inReal[],
3172                      int          *outBegIdx,
3173                      int          *outNBElement,
3174                      double        outReal[] );
3175 
3176 TA_RetCode TA_S_LOG10( int    startIdx,
3177                        int    endIdx,
3178                        const float  inReal[],
3179                        int          *outBegIdx,
3180                        int          *outNBElement,
3181                        double        outReal[] );
3182 
3183 int TA_LOG10_Lookback( void );
3184 
3185 
3186 /*
3187  * TA_MA - Moving average
3188  *
3189  * Input  = double
3190  * Output = double
3191  *
3192  * Optional Parameters
3193  * -------------------
3194  * optInTimePeriod:(From 1 to 100000)
3195  *    Number of period
3196  *
3197  * optInMAType:
3198  *    Type of Moving Average
3199  *
3200  *
3201  */
3202 TA_RetCode TA_MA( int    startIdx,
3203                   int    endIdx,
3204                   const double inReal[],
3205                   int           optInTimePeriod, /* From 1 to 100000 */
3206                   TA_MAType     optInMAType,
3207                   int          *outBegIdx,
3208                   int          *outNBElement,
3209                   double        outReal[] );
3210 
3211 TA_RetCode TA_S_MA( int    startIdx,
3212                     int    endIdx,
3213                     const float  inReal[],
3214                     int           optInTimePeriod, /* From 1 to 100000 */
3215                     TA_MAType     optInMAType,
3216                     int          *outBegIdx,
3217                     int          *outNBElement,
3218                     double        outReal[] );
3219 
3220 int TA_MA_Lookback( int           optInTimePeriod, /* From 1 to 100000 */
3221                   TA_MAType     optInMAType );
3222 
3223 /*
3224  * TA_MACD - Moving Average Convergence/Divergence
3225  *
3226  * Input  = double
3227  * Output = double, double, double
3228  *
3229  * Optional Parameters
3230  * -------------------
3231  * optInFastPeriod:(From 2 to 100000)
3232  *    Number of period for the fast MA
3233  *
3234  * optInSlowPeriod:(From 2 to 100000)
3235  *    Number of period for the slow MA
3236  *
3237  * optInSignalPeriod:(From 1 to 100000)
3238  *    Smoothing for the signal line (nb of period)
3239  *
3240  *
3241  */
3242 TA_RetCode TA_MACD( int    startIdx,
3243                     int    endIdx,
3244                     const double inReal[],
3245                     int           optInFastPeriod, /* From 2 to 100000 */
3246                     int           optInSlowPeriod, /* From 2 to 100000 */
3247                     int           optInSignalPeriod, /* From 1 to 100000 */
3248                     int          *outBegIdx,
3249                     int          *outNBElement,
3250                     double        outMACD[],
3251                     double        outMACDSignal[],
3252                     double        outMACDHist[] );
3253 
3254 TA_RetCode TA_S_MACD( int    startIdx,
3255                       int    endIdx,
3256                       const float  inReal[],
3257                       int           optInFastPeriod, /* From 2 to 100000 */
3258                       int           optInSlowPeriod, /* From 2 to 100000 */
3259                       int           optInSignalPeriod, /* From 1 to 100000 */
3260                       int          *outBegIdx,
3261                       int          *outNBElement,
3262                       double        outMACD[],
3263                       double        outMACDSignal[],
3264                       double        outMACDHist[] );
3265 
3266 int TA_MACD_Lookback( int           optInFastPeriod, /* From 2 to 100000 */
3267                     int           optInSlowPeriod, /* From 2 to 100000 */
3268                     int           optInSignalPeriod );  /* From 1 to 100000 */
3269 
3270 
3271 /*
3272  * TA_MACDEXT - MACD with controllable MA type
3273  *
3274  * Input  = double
3275  * Output = double, double, double
3276  *
3277  * Optional Parameters
3278  * -------------------
3279  * optInFastPeriod:(From 2 to 100000)
3280  *    Number of period for the fast MA
3281  *
3282  * optInFastMAType:
3283  *    Type of Moving Average for fast MA
3284  *
3285  * optInSlowPeriod:(From 2 to 100000)
3286  *    Number of period for the slow MA
3287  *
3288  * optInSlowMAType:
3289  *    Type of Moving Average for slow MA
3290  *
3291  * optInSignalPeriod:(From 1 to 100000)
3292  *    Smoothing for the signal line (nb of period)
3293  *
3294  * optInSignalMAType:
3295  *    Type of Moving Average for signal line
3296  *
3297  *
3298  */
3299 TA_RetCode TA_MACDEXT( int    startIdx,
3300                        int    endIdx,
3301                        const double inReal[],
3302                        int           optInFastPeriod, /* From 2 to 100000 */
3303                        TA_MAType     optInFastMAType,
3304                        int           optInSlowPeriod, /* From 2 to 100000 */
3305                        TA_MAType     optInSlowMAType,
3306                        int           optInSignalPeriod, /* From 1 to 100000 */
3307                        TA_MAType     optInSignalMAType,
3308                        int          *outBegIdx,
3309                        int          *outNBElement,
3310                        double        outMACD[],
3311                        double        outMACDSignal[],
3312                        double        outMACDHist[] );
3313 
3314 TA_RetCode TA_S_MACDEXT( int    startIdx,
3315                          int    endIdx,
3316                          const float  inReal[],
3317                          int           optInFastPeriod, /* From 2 to 100000 */
3318                          TA_MAType     optInFastMAType,
3319                          int           optInSlowPeriod, /* From 2 to 100000 */
3320                          TA_MAType     optInSlowMAType,
3321                          int           optInSignalPeriod, /* From 1 to 100000 */
3322                          TA_MAType     optInSignalMAType,
3323                          int          *outBegIdx,
3324                          int          *outNBElement,
3325                          double        outMACD[],
3326                          double        outMACDSignal[],
3327                          double        outMACDHist[] );
3328 
3329 int TA_MACDEXT_Lookback( int           optInFastPeriod, /* From 2 to 100000 */
3330                        TA_MAType     optInFastMAType,
3331                        int           optInSlowPeriod, /* From 2 to 100000 */
3332                        TA_MAType     optInSlowMAType,
3333                        int           optInSignalPeriod, /* From 1 to 100000 */
3334                        TA_MAType     optInSignalMAType );
3335 
3336 /*
3337  * TA_MACDFIX - Moving Average Convergence/Divergence Fix 12/26
3338  *
3339  * Input  = double
3340  * Output = double, double, double
3341  *
3342  * Optional Parameters
3343  * -------------------
3344  * optInSignalPeriod:(From 1 to 100000)
3345  *    Smoothing for the signal line (nb of period)
3346  *
3347  *
3348  */
3349 TA_RetCode TA_MACDFIX( int    startIdx,
3350                        int    endIdx,
3351                        const double inReal[],
3352                        int           optInSignalPeriod, /* From 1 to 100000 */
3353                        int          *outBegIdx,
3354                        int          *outNBElement,
3355                        double        outMACD[],
3356                        double        outMACDSignal[],
3357                        double        outMACDHist[] );
3358 
3359 TA_RetCode TA_S_MACDFIX( int    startIdx,
3360                          int    endIdx,
3361                          const float  inReal[],
3362                          int           optInSignalPeriod, /* From 1 to 100000 */
3363                          int          *outBegIdx,
3364                          int          *outNBElement,
3365                          double        outMACD[],
3366                          double        outMACDSignal[],
3367                          double        outMACDHist[] );
3368 
3369 int TA_MACDFIX_Lookback( int           optInSignalPeriod );  /* From 1 to 100000 */
3370 
3371 
3372 /*
3373  * TA_MAMA - MESA Adaptive Moving Average
3374  *
3375  * Input  = double
3376  * Output = double, double
3377  *
3378  * Optional Parameters
3379  * -------------------
3380  * optInFastLimit:(From 0.01 to 0.99)
3381  *    Upper limit use in the adaptive algorithm
3382  *
3383  * optInSlowLimit:(From 0.01 to 0.99)
3384  *    Lower limit use in the adaptive algorithm
3385  *
3386  *
3387  */
3388 TA_RetCode TA_MAMA( int    startIdx,
3389                     int    endIdx,
3390                     const double inReal[],
3391                     double        optInFastLimit, /* From 0.01 to 0.99 */
3392                     double        optInSlowLimit, /* From 0.01 to 0.99 */
3393                     int          *outBegIdx,
3394                     int          *outNBElement,
3395                     double        outMAMA[],
3396                     double        outFAMA[] );
3397 
3398 TA_RetCode TA_S_MAMA( int    startIdx,
3399                       int    endIdx,
3400                       const float  inReal[],
3401                       double        optInFastLimit, /* From 0.01 to 0.99 */
3402                       double        optInSlowLimit, /* From 0.01 to 0.99 */
3403                       int          *outBegIdx,
3404                       int          *outNBElement,
3405                       double        outMAMA[],
3406                       double        outFAMA[] );
3407 
3408 int TA_MAMA_Lookback( double        optInFastLimit, /* From 0.01 to 0.99 */
3409                     double        optInSlowLimit );  /* From 0.01 to 0.99 */
3410 
3411 
3412 /*
3413  * TA_MAVP - Moving average with variable period
3414  *
3415  * Input  = double, double
3416  * Output = double
3417  *
3418  * Optional Parameters
3419  * -------------------
3420  * optInMinPeriod:(From 2 to 100000)
3421  *    Value less than minimum will be changed to Minimum period
3422  *
3423  * optInMaxPeriod:(From 2 to 100000)
3424  *    Value higher than maximum will be changed to Maximum period
3425  *
3426  * optInMAType:
3427  *    Type of Moving Average
3428  *
3429  *
3430  */
3431 TA_RetCode TA_MAVP( int    startIdx,
3432                     int    endIdx,
3433                     const double inReal[],
3434                     const double inPeriods[],
3435                     int           optInMinPeriod, /* From 2 to 100000 */
3436                     int           optInMaxPeriod, /* From 2 to 100000 */
3437                     TA_MAType     optInMAType,
3438                     int          *outBegIdx,
3439                     int          *outNBElement,
3440                     double        outReal[] );
3441 
3442 TA_RetCode TA_S_MAVP( int    startIdx,
3443                       int    endIdx,
3444                       const float  inReal[],
3445                       const float  inPeriods[],
3446                       int           optInMinPeriod, /* From 2 to 100000 */
3447                       int           optInMaxPeriod, /* From 2 to 100000 */
3448                       TA_MAType     optInMAType,
3449                       int          *outBegIdx,
3450                       int          *outNBElement,
3451                       double        outReal[] );
3452 
3453 int TA_MAVP_Lookback( int           optInMinPeriod, /* From 2 to 100000 */
3454                     int           optInMaxPeriod, /* From 2 to 100000 */
3455                     TA_MAType     optInMAType );
3456 
3457 /*
3458  * TA_MAX - Highest value over a specified period
3459  *
3460  * Input  = double
3461  * Output = double
3462  *
3463  * Optional Parameters
3464  * -------------------
3465  * optInTimePeriod:(From 2 to 100000)
3466  *    Number of period
3467  *
3468  *
3469  */
3470 TA_RetCode TA_MAX( int    startIdx,
3471                    int    endIdx,
3472                    const double inReal[],
3473                    int           optInTimePeriod, /* From 2 to 100000 */
3474                    int          *outBegIdx,
3475                    int          *outNBElement,
3476                    double        outReal[] );
3477 
3478 TA_RetCode TA_S_MAX( int    startIdx,
3479                      int    endIdx,
3480                      const float  inReal[],
3481                      int           optInTimePeriod, /* From 2 to 100000 */
3482                      int          *outBegIdx,
3483                      int          *outNBElement,
3484                      double        outReal[] );
3485 
3486 int TA_MAX_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3487 
3488 
3489 /*
3490  * TA_MAXINDEX - Index of highest value over a specified period
3491  *
3492  * Input  = double
3493  * Output = int
3494  *
3495  * Optional Parameters
3496  * -------------------
3497  * optInTimePeriod:(From 2 to 100000)
3498  *    Number of period
3499  *
3500  *
3501  */
3502 TA_RetCode TA_MAXINDEX( int    startIdx,
3503                         int    endIdx,
3504                         const double inReal[],
3505                         int           optInTimePeriod, /* From 2 to 100000 */
3506                         int          *outBegIdx,
3507                         int          *outNBElement,
3508                         int           outInteger[] );
3509 
3510 TA_RetCode TA_S_MAXINDEX( int    startIdx,
3511                           int    endIdx,
3512                           const float  inReal[],
3513                           int           optInTimePeriod, /* From 2 to 100000 */
3514                           int          *outBegIdx,
3515                           int          *outNBElement,
3516                           int           outInteger[] );
3517 
3518 int TA_MAXINDEX_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3519 
3520 
3521 /*
3522  * TA_MEDPRICE - Median Price
3523  *
3524  * Input  = High, Low
3525  * Output = double
3526  *
3527  */
3528 TA_RetCode TA_MEDPRICE( int    startIdx,
3529                         int    endIdx,
3530                         const double inHigh[],
3531                         const double inLow[],
3532                         int          *outBegIdx,
3533                         int          *outNBElement,
3534                         double        outReal[] );
3535 
3536 TA_RetCode TA_S_MEDPRICE( int    startIdx,
3537                           int    endIdx,
3538                           const float  inHigh[],
3539                           const float  inLow[],
3540                           int          *outBegIdx,
3541                           int          *outNBElement,
3542                           double        outReal[] );
3543 
3544 int TA_MEDPRICE_Lookback( void );
3545 
3546 
3547 /*
3548  * TA_MFI - Money Flow Index
3549  *
3550  * Input  = High, Low, Close, Volume
3551  * Output = double
3552  *
3553  * Optional Parameters
3554  * -------------------
3555  * optInTimePeriod:(From 2 to 100000)
3556  *    Number of period
3557  *
3558  *
3559  */
3560 TA_RetCode TA_MFI( int    startIdx,
3561                    int    endIdx,
3562                    const double inHigh[],
3563                    const double inLow[],
3564                    const double inClose[],
3565                    const double inVolume[],
3566                    int           optInTimePeriod, /* From 2 to 100000 */
3567                    int          *outBegIdx,
3568                    int          *outNBElement,
3569                    double        outReal[] );
3570 
3571 TA_RetCode TA_S_MFI( int    startIdx,
3572                      int    endIdx,
3573                      const float  inHigh[],
3574                      const float  inLow[],
3575                      const float  inClose[],
3576                      const float  inVolume[],
3577                      int           optInTimePeriod, /* From 2 to 100000 */
3578                      int          *outBegIdx,
3579                      int          *outNBElement,
3580                      double        outReal[] );
3581 
3582 int TA_MFI_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3583 
3584 
3585 /*
3586  * TA_MIDPOINT - MidPoint over period
3587  *
3588  * Input  = double
3589  * Output = double
3590  *
3591  * Optional Parameters
3592  * -------------------
3593  * optInTimePeriod:(From 2 to 100000)
3594  *    Number of period
3595  *
3596  *
3597  */
3598 TA_RetCode TA_MIDPOINT( int    startIdx,
3599                         int    endIdx,
3600                         const double inReal[],
3601                         int           optInTimePeriod, /* From 2 to 100000 */
3602                         int          *outBegIdx,
3603                         int          *outNBElement,
3604                         double        outReal[] );
3605 
3606 TA_RetCode TA_S_MIDPOINT( int    startIdx,
3607                           int    endIdx,
3608                           const float  inReal[],
3609                           int           optInTimePeriod, /* From 2 to 100000 */
3610                           int          *outBegIdx,
3611                           int          *outNBElement,
3612                           double        outReal[] );
3613 
3614 int TA_MIDPOINT_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3615 
3616 
3617 /*
3618  * TA_MIDPRICE - Midpoint Price over period
3619  *
3620  * Input  = High, Low
3621  * Output = double
3622  *
3623  * Optional Parameters
3624  * -------------------
3625  * optInTimePeriod:(From 2 to 100000)
3626  *    Number of period
3627  *
3628  *
3629  */
3630 TA_RetCode TA_MIDPRICE( int    startIdx,
3631                         int    endIdx,
3632                         const double inHigh[],
3633                         const double inLow[],
3634                         int           optInTimePeriod, /* From 2 to 100000 */
3635                         int          *outBegIdx,
3636                         int          *outNBElement,
3637                         double        outReal[] );
3638 
3639 TA_RetCode TA_S_MIDPRICE( int    startIdx,
3640                           int    endIdx,
3641                           const float  inHigh[],
3642                           const float  inLow[],
3643                           int           optInTimePeriod, /* From 2 to 100000 */
3644                           int          *outBegIdx,
3645                           int          *outNBElement,
3646                           double        outReal[] );
3647 
3648 int TA_MIDPRICE_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3649 
3650 
3651 /*
3652  * TA_MIN - Lowest value over a specified period
3653  *
3654  * Input  = double
3655  * Output = double
3656  *
3657  * Optional Parameters
3658  * -------------------
3659  * optInTimePeriod:(From 2 to 100000)
3660  *    Number of period
3661  *
3662  *
3663  */
3664 TA_RetCode TA_MIN( int    startIdx,
3665                    int    endIdx,
3666                    const double inReal[],
3667                    int           optInTimePeriod, /* From 2 to 100000 */
3668                    int          *outBegIdx,
3669                    int          *outNBElement,
3670                    double        outReal[] );
3671 
3672 TA_RetCode TA_S_MIN( int    startIdx,
3673                      int    endIdx,
3674                      const float  inReal[],
3675                      int           optInTimePeriod, /* From 2 to 100000 */
3676                      int          *outBegIdx,
3677                      int          *outNBElement,
3678                      double        outReal[] );
3679 
3680 int TA_MIN_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3681 
3682 
3683 /*
3684  * TA_MININDEX - Index of lowest value over a specified period
3685  *
3686  * Input  = double
3687  * Output = int
3688  *
3689  * Optional Parameters
3690  * -------------------
3691  * optInTimePeriod:(From 2 to 100000)
3692  *    Number of period
3693  *
3694  *
3695  */
3696 TA_RetCode TA_MININDEX( int    startIdx,
3697                         int    endIdx,
3698                         const double inReal[],
3699                         int           optInTimePeriod, /* From 2 to 100000 */
3700                         int          *outBegIdx,
3701                         int          *outNBElement,
3702                         int           outInteger[] );
3703 
3704 TA_RetCode TA_S_MININDEX( int    startIdx,
3705                           int    endIdx,
3706                           const float  inReal[],
3707                           int           optInTimePeriod, /* From 2 to 100000 */
3708                           int          *outBegIdx,
3709                           int          *outNBElement,
3710                           int           outInteger[] );
3711 
3712 int TA_MININDEX_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3713 
3714 
3715 /*
3716  * TA_MINMAX - Lowest and highest values over a specified period
3717  *
3718  * Input  = double
3719  * Output = double, double
3720  *
3721  * Optional Parameters
3722  * -------------------
3723  * optInTimePeriod:(From 2 to 100000)
3724  *    Number of period
3725  *
3726  *
3727  */
3728 TA_RetCode TA_MINMAX( int    startIdx,
3729                       int    endIdx,
3730                       const double inReal[],
3731                       int           optInTimePeriod, /* From 2 to 100000 */
3732                       int          *outBegIdx,
3733                       int          *outNBElement,
3734                       double        outMin[],
3735                       double        outMax[] );
3736 
3737 TA_RetCode TA_S_MINMAX( int    startIdx,
3738                         int    endIdx,
3739                         const float  inReal[],
3740                         int           optInTimePeriod, /* From 2 to 100000 */
3741                         int          *outBegIdx,
3742                         int          *outNBElement,
3743                         double        outMin[],
3744                         double        outMax[] );
3745 
3746 int TA_MINMAX_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3747 
3748 
3749 /*
3750  * TA_MINMAXINDEX - Indexes of lowest and highest values over a specified period
3751  *
3752  * Input  = double
3753  * Output = int, int
3754  *
3755  * Optional Parameters
3756  * -------------------
3757  * optInTimePeriod:(From 2 to 100000)
3758  *    Number of period
3759  *
3760  *
3761  */
3762 TA_RetCode TA_MINMAXINDEX( int    startIdx,
3763                            int    endIdx,
3764                            const double inReal[],
3765                            int           optInTimePeriod, /* From 2 to 100000 */
3766                            int          *outBegIdx,
3767                            int          *outNBElement,
3768                            int           outMinIdx[],
3769                            int           outMaxIdx[] );
3770 
3771 TA_RetCode TA_S_MINMAXINDEX( int    startIdx,
3772                              int    endIdx,
3773                              const float  inReal[],
3774                              int           optInTimePeriod, /* From 2 to 100000 */
3775                              int          *outBegIdx,
3776                              int          *outNBElement,
3777                              int           outMinIdx[],
3778                              int           outMaxIdx[] );
3779 
3780 int TA_MINMAXINDEX_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
3781 
3782 
3783 /*
3784  * TA_MINUS_DI - Minus Directional Indicator
3785  *
3786  * Input  = High, Low, Close
3787  * Output = double
3788  *
3789  * Optional Parameters
3790  * -------------------
3791  * optInTimePeriod:(From 1 to 100000)
3792  *    Number of period
3793  *
3794  *
3795  */
3796 TA_RetCode TA_MINUS_DI( int    startIdx,
3797                         int    endIdx,
3798                         const double inHigh[],
3799                         const double inLow[],
3800                         const double inClose[],
3801                         int           optInTimePeriod, /* From 1 to 100000 */
3802                         int          *outBegIdx,
3803                         int          *outNBElement,
3804                         double        outReal[] );
3805 
3806 TA_RetCode TA_S_MINUS_DI( int    startIdx,
3807                           int    endIdx,
3808                           const float  inHigh[],
3809                           const float  inLow[],
3810                           const float  inClose[],
3811                           int           optInTimePeriod, /* From 1 to 100000 */
3812                           int          *outBegIdx,
3813                           int          *outNBElement,
3814                           double        outReal[] );
3815 
3816 int TA_MINUS_DI_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
3817 
3818 
3819 /*
3820  * TA_MINUS_DM - Minus Directional Movement
3821  *
3822  * Input  = High, Low
3823  * Output = double
3824  *
3825  * Optional Parameters
3826  * -------------------
3827  * optInTimePeriod:(From 1 to 100000)
3828  *    Number of period
3829  *
3830  *
3831  */
3832 TA_RetCode TA_MINUS_DM( int    startIdx,
3833                         int    endIdx,
3834                         const double inHigh[],
3835                         const double inLow[],
3836                         int           optInTimePeriod, /* From 1 to 100000 */
3837                         int          *outBegIdx,
3838                         int          *outNBElement,
3839                         double        outReal[] );
3840 
3841 TA_RetCode TA_S_MINUS_DM( int    startIdx,
3842                           int    endIdx,
3843                           const float  inHigh[],
3844                           const float  inLow[],
3845                           int           optInTimePeriod, /* From 1 to 100000 */
3846                           int          *outBegIdx,
3847                           int          *outNBElement,
3848                           double        outReal[] );
3849 
3850 int TA_MINUS_DM_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
3851 
3852 
3853 /*
3854  * TA_MOM - Momentum
3855  *
3856  * Input  = double
3857  * Output = double
3858  *
3859  * Optional Parameters
3860  * -------------------
3861  * optInTimePeriod:(From 1 to 100000)
3862  *    Number of period
3863  *
3864  *
3865  */
3866 TA_RetCode TA_MOM( int    startIdx,
3867                    int    endIdx,
3868                    const double inReal[],
3869                    int           optInTimePeriod, /* From 1 to 100000 */
3870                    int          *outBegIdx,
3871                    int          *outNBElement,
3872                    double        outReal[] );
3873 
3874 TA_RetCode TA_S_MOM( int    startIdx,
3875                      int    endIdx,
3876                      const float  inReal[],
3877                      int           optInTimePeriod, /* From 1 to 100000 */
3878                      int          *outBegIdx,
3879                      int          *outNBElement,
3880                      double        outReal[] );
3881 
3882 int TA_MOM_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
3883 
3884 
3885 /*
3886  * TA_MULT - Vector Arithmetic Mult
3887  *
3888  * Input  = double, double
3889  * Output = double
3890  *
3891  */
3892 TA_RetCode TA_MULT( int    startIdx,
3893                     int    endIdx,
3894                     const double inReal0[],
3895                     const double inReal1[],
3896                     int          *outBegIdx,
3897                     int          *outNBElement,
3898                     double        outReal[] );
3899 
3900 TA_RetCode TA_S_MULT( int    startIdx,
3901                       int    endIdx,
3902                       const float  inReal0[],
3903                       const float  inReal1[],
3904                       int          *outBegIdx,
3905                       int          *outNBElement,
3906                       double        outReal[] );
3907 
3908 int TA_MULT_Lookback( void );
3909 
3910 
3911 /*
3912  * TA_NATR - Normalized Average True Range
3913  *
3914  * Input  = High, Low, Close
3915  * Output = double
3916  *
3917  * Optional Parameters
3918  * -------------------
3919  * optInTimePeriod:(From 1 to 100000)
3920  *    Number of period
3921  *
3922  *
3923  */
3924 TA_RetCode TA_NATR( int    startIdx,
3925                     int    endIdx,
3926                     const double inHigh[],
3927                     const double inLow[],
3928                     const double inClose[],
3929                     int           optInTimePeriod, /* From 1 to 100000 */
3930                     int          *outBegIdx,
3931                     int          *outNBElement,
3932                     double        outReal[] );
3933 
3934 TA_RetCode TA_S_NATR( int    startIdx,
3935                       int    endIdx,
3936                       const float  inHigh[],
3937                       const float  inLow[],
3938                       const float  inClose[],
3939                       int           optInTimePeriod, /* From 1 to 100000 */
3940                       int          *outBegIdx,
3941                       int          *outNBElement,
3942                       double        outReal[] );
3943 
3944 int TA_NATR_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
3945 
3946 
3947 /*
3948  * TA_OBV - On Balance Volume
3949  *
3950  * Input  = double, Volume
3951  * Output = double
3952  *
3953  */
3954 TA_RetCode TA_OBV( int    startIdx,
3955                    int    endIdx,
3956                    const double inReal[],
3957                    const double inVolume[],
3958                    int          *outBegIdx,
3959                    int          *outNBElement,
3960                    double        outReal[] );
3961 
3962 TA_RetCode TA_S_OBV( int    startIdx,
3963                      int    endIdx,
3964                      const float  inReal[],
3965                      const float  inVolume[],
3966                      int          *outBegIdx,
3967                      int          *outNBElement,
3968                      double        outReal[] );
3969 
3970 int TA_OBV_Lookback( void );
3971 
3972 
3973 /*
3974  * TA_PLUS_DI - Plus Directional Indicator
3975  *
3976  * Input  = High, Low, Close
3977  * Output = double
3978  *
3979  * Optional Parameters
3980  * -------------------
3981  * optInTimePeriod:(From 1 to 100000)
3982  *    Number of period
3983  *
3984  *
3985  */
3986 TA_RetCode TA_PLUS_DI( int    startIdx,
3987                        int    endIdx,
3988                        const double inHigh[],
3989                        const double inLow[],
3990                        const double inClose[],
3991                        int           optInTimePeriod, /* From 1 to 100000 */
3992                        int          *outBegIdx,
3993                        int          *outNBElement,
3994                        double        outReal[] );
3995 
3996 TA_RetCode TA_S_PLUS_DI( int    startIdx,
3997                          int    endIdx,
3998                          const float  inHigh[],
3999                          const float  inLow[],
4000                          const float  inClose[],
4001                          int           optInTimePeriod, /* From 1 to 100000 */
4002                          int          *outBegIdx,
4003                          int          *outNBElement,
4004                          double        outReal[] );
4005 
4006 int TA_PLUS_DI_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
4007 
4008 
4009 /*
4010  * TA_PLUS_DM - Plus Directional Movement
4011  *
4012  * Input  = High, Low
4013  * Output = double
4014  *
4015  * Optional Parameters
4016  * -------------------
4017  * optInTimePeriod:(From 1 to 100000)
4018  *    Number of period
4019  *
4020  *
4021  */
4022 TA_RetCode TA_PLUS_DM( int    startIdx,
4023                        int    endIdx,
4024                        const double inHigh[],
4025                        const double inLow[],
4026                        int           optInTimePeriod, /* From 1 to 100000 */
4027                        int          *outBegIdx,
4028                        int          *outNBElement,
4029                        double        outReal[] );
4030 
4031 TA_RetCode TA_S_PLUS_DM( int    startIdx,
4032                          int    endIdx,
4033                          const float  inHigh[],
4034                          const float  inLow[],
4035                          int           optInTimePeriod, /* From 1 to 100000 */
4036                          int          *outBegIdx,
4037                          int          *outNBElement,
4038                          double        outReal[] );
4039 
4040 int TA_PLUS_DM_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
4041 
4042 
4043 /*
4044  * TA_PPO - Percentage Price Oscillator
4045  *
4046  * Input  = double
4047  * Output = double
4048  *
4049  * Optional Parameters
4050  * -------------------
4051  * optInFastPeriod:(From 2 to 100000)
4052  *    Number of period for the fast MA
4053  *
4054  * optInSlowPeriod:(From 2 to 100000)
4055  *    Number of period for the slow MA
4056  *
4057  * optInMAType:
4058  *    Type of Moving Average
4059  *
4060  *
4061  */
4062 TA_RetCode TA_PPO( int    startIdx,
4063                    int    endIdx,
4064                    const double inReal[],
4065                    int           optInFastPeriod, /* From 2 to 100000 */
4066                    int           optInSlowPeriod, /* From 2 to 100000 */
4067                    TA_MAType     optInMAType,
4068                    int          *outBegIdx,
4069                    int          *outNBElement,
4070                    double        outReal[] );
4071 
4072 TA_RetCode TA_S_PPO( int    startIdx,
4073                      int    endIdx,
4074                      const float  inReal[],
4075                      int           optInFastPeriod, /* From 2 to 100000 */
4076                      int           optInSlowPeriod, /* From 2 to 100000 */
4077                      TA_MAType     optInMAType,
4078                      int          *outBegIdx,
4079                      int          *outNBElement,
4080                      double        outReal[] );
4081 
4082 int TA_PPO_Lookback( int           optInFastPeriod, /* From 2 to 100000 */
4083                    int           optInSlowPeriod, /* From 2 to 100000 */
4084                    TA_MAType     optInMAType );
4085 
4086 /*
4087  * TA_ROC - Rate of change : ((price/prevPrice)-1)*100
4088  *
4089  * Input  = double
4090  * Output = double
4091  *
4092  * Optional Parameters
4093  * -------------------
4094  * optInTimePeriod:(From 1 to 100000)
4095  *    Number of period
4096  *
4097  *
4098  */
4099 TA_RetCode TA_ROC( int    startIdx,
4100                    int    endIdx,
4101                    const double inReal[],
4102                    int           optInTimePeriod, /* From 1 to 100000 */
4103                    int          *outBegIdx,
4104                    int          *outNBElement,
4105                    double        outReal[] );
4106 
4107 TA_RetCode TA_S_ROC( int    startIdx,
4108                      int    endIdx,
4109                      const float  inReal[],
4110                      int           optInTimePeriod, /* From 1 to 100000 */
4111                      int          *outBegIdx,
4112                      int          *outNBElement,
4113                      double        outReal[] );
4114 
4115 int TA_ROC_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
4116 
4117 
4118 /*
4119  * TA_ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice
4120  *
4121  * Input  = double
4122  * Output = double
4123  *
4124  * Optional Parameters
4125  * -------------------
4126  * optInTimePeriod:(From 1 to 100000)
4127  *    Number of period
4128  *
4129  *
4130  */
4131 TA_RetCode TA_ROCP( int    startIdx,
4132                     int    endIdx,
4133                     const double inReal[],
4134                     int           optInTimePeriod, /* From 1 to 100000 */
4135                     int          *outBegIdx,
4136                     int          *outNBElement,
4137                     double        outReal[] );
4138 
4139 TA_RetCode TA_S_ROCP( int    startIdx,
4140                       int    endIdx,
4141                       const float  inReal[],
4142                       int           optInTimePeriod, /* From 1 to 100000 */
4143                       int          *outBegIdx,
4144                       int          *outNBElement,
4145                       double        outReal[] );
4146 
4147 int TA_ROCP_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
4148 
4149 
4150 /*
4151  * TA_ROCR - Rate of change ratio: (price/prevPrice)
4152  *
4153  * Input  = double
4154  * Output = double
4155  *
4156  * Optional Parameters
4157  * -------------------
4158  * optInTimePeriod:(From 1 to 100000)
4159  *    Number of period
4160  *
4161  *
4162  */
4163 TA_RetCode TA_ROCR( int    startIdx,
4164                     int    endIdx,
4165                     const double inReal[],
4166                     int           optInTimePeriod, /* From 1 to 100000 */
4167                     int          *outBegIdx,
4168                     int          *outNBElement,
4169                     double        outReal[] );
4170 
4171 TA_RetCode TA_S_ROCR( int    startIdx,
4172                       int    endIdx,
4173                       const float  inReal[],
4174                       int           optInTimePeriod, /* From 1 to 100000 */
4175                       int          *outBegIdx,
4176                       int          *outNBElement,
4177                       double        outReal[] );
4178 
4179 int TA_ROCR_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
4180 
4181 
4182 /*
4183  * TA_ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100
4184  *
4185  * Input  = double
4186  * Output = double
4187  *
4188  * Optional Parameters
4189  * -------------------
4190  * optInTimePeriod:(From 1 to 100000)
4191  *    Number of period
4192  *
4193  *
4194  */
4195 TA_RetCode TA_ROCR100( int    startIdx,
4196                        int    endIdx,
4197                        const double inReal[],
4198                        int           optInTimePeriod, /* From 1 to 100000 */
4199                        int          *outBegIdx,
4200                        int          *outNBElement,
4201                        double        outReal[] );
4202 
4203 TA_RetCode TA_S_ROCR100( int    startIdx,
4204                          int    endIdx,
4205                          const float  inReal[],
4206                          int           optInTimePeriod, /* From 1 to 100000 */
4207                          int          *outBegIdx,
4208                          int          *outNBElement,
4209                          double        outReal[] );
4210 
4211 int TA_ROCR100_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
4212 
4213 
4214 /*
4215  * TA_RSI - Relative Strength Index
4216  *
4217  * Input  = double
4218  * Output = double
4219  *
4220  * Optional Parameters
4221  * -------------------
4222  * optInTimePeriod:(From 2 to 100000)
4223  *    Number of period
4224  *
4225  *
4226  */
4227 TA_RetCode TA_RSI( int    startIdx,
4228                    int    endIdx,
4229                    const double inReal[],
4230                    int           optInTimePeriod, /* From 2 to 100000 */
4231                    int          *outBegIdx,
4232                    int          *outNBElement,
4233                    double        outReal[] );
4234 
4235 TA_RetCode TA_S_RSI( int    startIdx,
4236                      int    endIdx,
4237                      const float  inReal[],
4238                      int           optInTimePeriod, /* From 2 to 100000 */
4239                      int          *outBegIdx,
4240                      int          *outNBElement,
4241                      double        outReal[] );
4242 
4243 int TA_RSI_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
4244 
4245 
4246 /*
4247  * TA_SAR - Parabolic SAR
4248  *
4249  * Input  = High, Low
4250  * Output = double
4251  *
4252  * Optional Parameters
4253  * -------------------
4254  * optInAcceleration:(From 0 to TA_REAL_MAX)
4255  *    Acceleration Factor used up to the Maximum value
4256  *
4257  * optInMaximum:(From 0 to TA_REAL_MAX)
4258  *    Acceleration Factor Maximum value
4259  *
4260  *
4261  */
4262 TA_RetCode TA_SAR( int    startIdx,
4263                    int    endIdx,
4264                    const double inHigh[],
4265                    const double inLow[],
4266                    double        optInAcceleration, /* From 0 to TA_REAL_MAX */
4267                    double        optInMaximum, /* From 0 to TA_REAL_MAX */
4268                    int          *outBegIdx,
4269                    int          *outNBElement,
4270                    double        outReal[] );
4271 
4272 TA_RetCode TA_S_SAR( int    startIdx,
4273                      int    endIdx,
4274                      const float  inHigh[],
4275                      const float  inLow[],
4276                      double        optInAcceleration, /* From 0 to TA_REAL_MAX */
4277                      double        optInMaximum, /* From 0 to TA_REAL_MAX */
4278                      int          *outBegIdx,
4279                      int          *outNBElement,
4280                      double        outReal[] );
4281 
4282 int TA_SAR_Lookback( double        optInAcceleration, /* From 0 to TA_REAL_MAX */
4283                    double        optInMaximum );  /* From 0 to TA_REAL_MAX */
4284 
4285 
4286 /*
4287  * TA_SAREXT - Parabolic SAR - Extended
4288  *
4289  * Input  = High, Low
4290  * Output = double
4291  *
4292  * Optional Parameters
4293  * -------------------
4294  * optInStartValue:(From TA_REAL_MIN to TA_REAL_MAX)
4295  *    Start value and direction. 0 for Auto, >0 for Long, <0 for Short
4296  *
4297  * optInOffsetOnReverse:(From 0 to TA_REAL_MAX)
4298  *    Percent offset added/removed to initial stop on short/long reversal
4299  *
4300  * optInAccelerationInitLong:(From 0 to TA_REAL_MAX)
4301  *    Acceleration Factor initial value for the Long direction
4302  *
4303  * optInAccelerationLong:(From 0 to TA_REAL_MAX)
4304  *    Acceleration Factor for the Long direction
4305  *
4306  * optInAccelerationMaxLong:(From 0 to TA_REAL_MAX)
4307  *    Acceleration Factor maximum value for the Long direction
4308  *
4309  * optInAccelerationInitShort:(From 0 to TA_REAL_MAX)
4310  *    Acceleration Factor initial value for the Short direction
4311  *
4312  * optInAccelerationShort:(From 0 to TA_REAL_MAX)
4313  *    Acceleration Factor for the Short direction
4314  *
4315  * optInAccelerationMaxShort:(From 0 to TA_REAL_MAX)
4316  *    Acceleration Factor maximum value for the Short direction
4317  *
4318  *
4319  */
4320 TA_RetCode TA_SAREXT( int    startIdx,
4321                       int    endIdx,
4322                       const double inHigh[],
4323                       const double inLow[],
4324                       double        optInStartValue, /* From TA_REAL_MIN to TA_REAL_MAX */
4325                       double        optInOffsetOnReverse, /* From 0 to TA_REAL_MAX */
4326                       double        optInAccelerationInitLong, /* From 0 to TA_REAL_MAX */
4327                       double        optInAccelerationLong, /* From 0 to TA_REAL_MAX */
4328                       double        optInAccelerationMaxLong, /* From 0 to TA_REAL_MAX */
4329                       double        optInAccelerationInitShort, /* From 0 to TA_REAL_MAX */
4330                       double        optInAccelerationShort, /* From 0 to TA_REAL_MAX */
4331                       double        optInAccelerationMaxShort, /* From 0 to TA_REAL_MAX */
4332                       int          *outBegIdx,
4333                       int          *outNBElement,
4334                       double        outReal[] );
4335 
4336 TA_RetCode TA_S_SAREXT( int    startIdx,
4337                         int    endIdx,
4338                         const float  inHigh[],
4339                         const float  inLow[],
4340                         double        optInStartValue, /* From TA_REAL_MIN to TA_REAL_MAX */
4341                         double        optInOffsetOnReverse, /* From 0 to TA_REAL_MAX */
4342                         double        optInAccelerationInitLong, /* From 0 to TA_REAL_MAX */
4343                         double        optInAccelerationLong, /* From 0 to TA_REAL_MAX */
4344                         double        optInAccelerationMaxLong, /* From 0 to TA_REAL_MAX */
4345                         double        optInAccelerationInitShort, /* From 0 to TA_REAL_MAX */
4346                         double        optInAccelerationShort, /* From 0 to TA_REAL_MAX */
4347                         double        optInAccelerationMaxShort, /* From 0 to TA_REAL_MAX */
4348                         int          *outBegIdx,
4349                         int          *outNBElement,
4350                         double        outReal[] );
4351 
4352 int TA_SAREXT_Lookback( double        optInStartValue, /* From TA_REAL_MIN to TA_REAL_MAX */
4353                       double        optInOffsetOnReverse, /* From 0 to TA_REAL_MAX */
4354                       double        optInAccelerationInitLong, /* From 0 to TA_REAL_MAX */
4355                       double        optInAccelerationLong, /* From 0 to TA_REAL_MAX */
4356                       double        optInAccelerationMaxLong, /* From 0 to TA_REAL_MAX */
4357                       double        optInAccelerationInitShort, /* From 0 to TA_REAL_MAX */
4358                       double        optInAccelerationShort, /* From 0 to TA_REAL_MAX */
4359                       double        optInAccelerationMaxShort );  /* From 0 to TA_REAL_MAX */
4360 
4361 
4362 /*
4363  * TA_SIN - Vector Trigonometric Sin
4364  *
4365  * Input  = double
4366  * Output = double
4367  *
4368  */
4369 TA_RetCode TA_SIN( int    startIdx,
4370                    int    endIdx,
4371                    const double inReal[],
4372                    int          *outBegIdx,
4373                    int          *outNBElement,
4374                    double        outReal[] );
4375 
4376 TA_RetCode TA_S_SIN( int    startIdx,
4377                      int    endIdx,
4378                      const float  inReal[],
4379                      int          *outBegIdx,
4380                      int          *outNBElement,
4381                      double        outReal[] );
4382 
4383 int TA_SIN_Lookback( void );
4384 
4385 
4386 /*
4387  * TA_SINH - Vector Trigonometric Sinh
4388  *
4389  * Input  = double
4390  * Output = double
4391  *
4392  */
4393 TA_RetCode TA_SINH( int    startIdx,
4394                     int    endIdx,
4395                     const double inReal[],
4396                     int          *outBegIdx,
4397                     int          *outNBElement,
4398                     double        outReal[] );
4399 
4400 TA_RetCode TA_S_SINH( int    startIdx,
4401                       int    endIdx,
4402                       const float  inReal[],
4403                       int          *outBegIdx,
4404                       int          *outNBElement,
4405                       double        outReal[] );
4406 
4407 int TA_SINH_Lookback( void );
4408 
4409 
4410 /*
4411  * TA_SMA - Simple Moving Average
4412  *
4413  * Input  = double
4414  * Output = double
4415  *
4416  * Optional Parameters
4417  * -------------------
4418  * optInTimePeriod:(From 2 to 100000)
4419  *    Number of period
4420  *
4421  *
4422  */
4423 TA_RetCode TA_SMA( int    startIdx,
4424                    int    endIdx,
4425                    const double inReal[],
4426                    int           optInTimePeriod, /* From 2 to 100000 */
4427                    int          *outBegIdx,
4428                    int          *outNBElement,
4429                    double        outReal[] );
4430 
4431 TA_RetCode TA_S_SMA( int    startIdx,
4432                      int    endIdx,
4433                      const float  inReal[],
4434                      int           optInTimePeriod, /* From 2 to 100000 */
4435                      int          *outBegIdx,
4436                      int          *outNBElement,
4437                      double        outReal[] );
4438 
4439 int TA_SMA_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
4440 
4441 
4442 /*
4443  * TA_SQRT - Vector Square Root
4444  *
4445  * Input  = double
4446  * Output = double
4447  *
4448  */
4449 TA_RetCode TA_SQRT( int    startIdx,
4450                     int    endIdx,
4451                     const double inReal[],
4452                     int          *outBegIdx,
4453                     int          *outNBElement,
4454                     double        outReal[] );
4455 
4456 TA_RetCode TA_S_SQRT( int    startIdx,
4457                       int    endIdx,
4458                       const float  inReal[],
4459                       int          *outBegIdx,
4460                       int          *outNBElement,
4461                       double        outReal[] );
4462 
4463 int TA_SQRT_Lookback( void );
4464 
4465 
4466 /*
4467  * TA_STDDEV - Standard Deviation
4468  *
4469  * Input  = double
4470  * Output = double
4471  *
4472  * Optional Parameters
4473  * -------------------
4474  * optInTimePeriod:(From 2 to 100000)
4475  *    Number of period
4476  *
4477  * optInNbDev:(From TA_REAL_MIN to TA_REAL_MAX)
4478  *    Nb of deviations
4479  *
4480  *
4481  */
4482 TA_RetCode TA_STDDEV( int    startIdx,
4483                       int    endIdx,
4484                       const double inReal[],
4485                       int           optInTimePeriod, /* From 2 to 100000 */
4486                       double        optInNbDev, /* From TA_REAL_MIN to TA_REAL_MAX */
4487                       int          *outBegIdx,
4488                       int          *outNBElement,
4489                       double        outReal[] );
4490 
4491 TA_RetCode TA_S_STDDEV( int    startIdx,
4492                         int    endIdx,
4493                         const float  inReal[],
4494                         int           optInTimePeriod, /* From 2 to 100000 */
4495                         double        optInNbDev, /* From TA_REAL_MIN to TA_REAL_MAX */
4496                         int          *outBegIdx,
4497                         int          *outNBElement,
4498                         double        outReal[] );
4499 
4500 int TA_STDDEV_Lookback( int           optInTimePeriod, /* From 2 to 100000 */
4501                       double        optInNbDev );  /* From TA_REAL_MIN to TA_REAL_MAX */
4502 
4503 
4504 /*
4505  * TA_STOCH - Stochastic
4506  *
4507  * Input  = High, Low, Close
4508  * Output = double, double
4509  *
4510  * Optional Parameters
4511  * -------------------
4512  * optInFastK_Period:(From 1 to 100000)
4513  *    Time period for building the Fast-K line
4514  *
4515  * optInSlowK_Period:(From 1 to 100000)
4516  *    Smoothing for making the Slow-K line. Usually set to 3
4517  *
4518  * optInSlowK_MAType:
4519  *    Type of Moving Average for Slow-K
4520  *
4521  * optInSlowD_Period:(From 1 to 100000)
4522  *    Smoothing for making the Slow-D line
4523  *
4524  * optInSlowD_MAType:
4525  *    Type of Moving Average for Slow-D
4526  *
4527  *
4528  */
4529 TA_RetCode TA_STOCH( int    startIdx,
4530                      int    endIdx,
4531                      const double inHigh[],
4532                      const double inLow[],
4533                      const double inClose[],
4534                      int           optInFastK_Period, /* From 1 to 100000 */
4535                      int           optInSlowK_Period, /* From 1 to 100000 */
4536                      TA_MAType     optInSlowK_MAType,
4537                      int           optInSlowD_Period, /* From 1 to 100000 */
4538                      TA_MAType     optInSlowD_MAType,
4539                      int          *outBegIdx,
4540                      int          *outNBElement,
4541                      double        outSlowK[],
4542                      double        outSlowD[] );
4543 
4544 TA_RetCode TA_S_STOCH( int    startIdx,
4545                        int    endIdx,
4546                        const float  inHigh[],
4547                        const float  inLow[],
4548                        const float  inClose[],
4549                        int           optInFastK_Period, /* From 1 to 100000 */
4550                        int           optInSlowK_Period, /* From 1 to 100000 */
4551                        TA_MAType     optInSlowK_MAType,
4552                        int           optInSlowD_Period, /* From 1 to 100000 */
4553                        TA_MAType     optInSlowD_MAType,
4554                        int          *outBegIdx,
4555                        int          *outNBElement,
4556                        double        outSlowK[],
4557                        double        outSlowD[] );
4558 
4559 int TA_STOCH_Lookback( int           optInFastK_Period, /* From 1 to 100000 */
4560                      int           optInSlowK_Period, /* From 1 to 100000 */
4561                      TA_MAType     optInSlowK_MAType,
4562                      int           optInSlowD_Period, /* From 1 to 100000 */
4563                      TA_MAType     optInSlowD_MAType );
4564 
4565 /*
4566  * TA_STOCHF - Stochastic Fast
4567  *
4568  * Input  = High, Low, Close
4569  * Output = double, double
4570  *
4571  * Optional Parameters
4572  * -------------------
4573  * optInFastK_Period:(From 1 to 100000)
4574  *    Time period for building the Fast-K line
4575  *
4576  * optInFastD_Period:(From 1 to 100000)
4577  *    Smoothing for making the Fast-D line. Usually set to 3
4578  *
4579  * optInFastD_MAType:
4580  *    Type of Moving Average for Fast-D
4581  *
4582  *
4583  */
4584 TA_RetCode TA_STOCHF( int    startIdx,
4585                       int    endIdx,
4586                       const double inHigh[],
4587                       const double inLow[],
4588                       const double inClose[],
4589                       int           optInFastK_Period, /* From 1 to 100000 */
4590                       int           optInFastD_Period, /* From 1 to 100000 */
4591                       TA_MAType     optInFastD_MAType,
4592                       int          *outBegIdx,
4593                       int          *outNBElement,
4594                       double        outFastK[],
4595                       double        outFastD[] );
4596 
4597 TA_RetCode TA_S_STOCHF( int    startIdx,
4598                         int    endIdx,
4599                         const float  inHigh[],
4600                         const float  inLow[],
4601                         const float  inClose[],
4602                         int           optInFastK_Period, /* From 1 to 100000 */
4603                         int           optInFastD_Period, /* From 1 to 100000 */
4604                         TA_MAType     optInFastD_MAType,
4605                         int          *outBegIdx,
4606                         int          *outNBElement,
4607                         double        outFastK[],
4608                         double        outFastD[] );
4609 
4610 int TA_STOCHF_Lookback( int           optInFastK_Period, /* From 1 to 100000 */
4611                       int           optInFastD_Period, /* From 1 to 100000 */
4612                       TA_MAType     optInFastD_MAType );
4613 
4614 /*
4615  * TA_STOCHRSI - Stochastic Relative Strength Index
4616  *
4617  * Input  = double
4618  * Output = double, double
4619  *
4620  * Optional Parameters
4621  * -------------------
4622  * optInTimePeriod:(From 2 to 100000)
4623  *    Number of period
4624  *
4625  * optInFastK_Period:(From 1 to 100000)
4626  *    Time period for building the Fast-K line
4627  *
4628  * optInFastD_Period:(From 1 to 100000)
4629  *    Smoothing for making the Fast-D line. Usually set to 3
4630  *
4631  * optInFastD_MAType:
4632  *    Type of Moving Average for Fast-D
4633  *
4634  *
4635  */
4636 TA_RetCode TA_STOCHRSI( int    startIdx,
4637                         int    endIdx,
4638                         const double inReal[],
4639                         int           optInTimePeriod, /* From 2 to 100000 */
4640                         int           optInFastK_Period, /* From 1 to 100000 */
4641                         int           optInFastD_Period, /* From 1 to 100000 */
4642                         TA_MAType     optInFastD_MAType,
4643                         int          *outBegIdx,
4644                         int          *outNBElement,
4645                         double        outFastK[],
4646                         double        outFastD[] );
4647 
4648 TA_RetCode TA_S_STOCHRSI( int    startIdx,
4649                           int    endIdx,
4650                           const float  inReal[],
4651                           int           optInTimePeriod, /* From 2 to 100000 */
4652                           int           optInFastK_Period, /* From 1 to 100000 */
4653                           int           optInFastD_Period, /* From 1 to 100000 */
4654                           TA_MAType     optInFastD_MAType,
4655                           int          *outBegIdx,
4656                           int          *outNBElement,
4657                           double        outFastK[],
4658                           double        outFastD[] );
4659 
4660 int TA_STOCHRSI_Lookback( int           optInTimePeriod, /* From 2 to 100000 */
4661                         int           optInFastK_Period, /* From 1 to 100000 */
4662                         int           optInFastD_Period, /* From 1 to 100000 */
4663                         TA_MAType     optInFastD_MAType );
4664 
4665 /*
4666  * TA_SUB - Vector Arithmetic Substraction
4667  *
4668  * Input  = double, double
4669  * Output = double
4670  *
4671  */
4672 TA_RetCode TA_SUB( int    startIdx,
4673                    int    endIdx,
4674                    const double inReal0[],
4675                    const double inReal1[],
4676                    int          *outBegIdx,
4677                    int          *outNBElement,
4678                    double        outReal[] );
4679 
4680 TA_RetCode TA_S_SUB( int    startIdx,
4681                      int    endIdx,
4682                      const float  inReal0[],
4683                      const float  inReal1[],
4684                      int          *outBegIdx,
4685                      int          *outNBElement,
4686                      double        outReal[] );
4687 
4688 int TA_SUB_Lookback( void );
4689 
4690 
4691 /*
4692  * TA_SUM - Summation
4693  *
4694  * Input  = double
4695  * Output = double
4696  *
4697  * Optional Parameters
4698  * -------------------
4699  * optInTimePeriod:(From 2 to 100000)
4700  *    Number of period
4701  *
4702  *
4703  */
4704 TA_RetCode TA_SUM( int    startIdx,
4705                    int    endIdx,
4706                    const double inReal[],
4707                    int           optInTimePeriod, /* From 2 to 100000 */
4708                    int          *outBegIdx,
4709                    int          *outNBElement,
4710                    double        outReal[] );
4711 
4712 TA_RetCode TA_S_SUM( int    startIdx,
4713                      int    endIdx,
4714                      const float  inReal[],
4715                      int           optInTimePeriod, /* From 2 to 100000 */
4716                      int          *outBegIdx,
4717                      int          *outNBElement,
4718                      double        outReal[] );
4719 
4720 int TA_SUM_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
4721 
4722 
4723 /*
4724  * TA_T3 - Triple Exponential Moving Average (T3)
4725  *
4726  * Input  = double
4727  * Output = double
4728  *
4729  * Optional Parameters
4730  * -------------------
4731  * optInTimePeriod:(From 2 to 100000)
4732  *    Number of period
4733  *
4734  * optInVFactor:(From 0 to 1)
4735  *    Volume Factor
4736  *
4737  *
4738  */
4739 TA_RetCode TA_T3( int    startIdx,
4740                   int    endIdx,
4741                   const double inReal[],
4742                   int           optInTimePeriod, /* From 2 to 100000 */
4743                   double        optInVFactor, /* From 0 to 1 */
4744                   int          *outBegIdx,
4745                   int          *outNBElement,
4746                   double        outReal[] );
4747 
4748 TA_RetCode TA_S_T3( int    startIdx,
4749                     int    endIdx,
4750                     const float  inReal[],
4751                     int           optInTimePeriod, /* From 2 to 100000 */
4752                     double        optInVFactor, /* From 0 to 1 */
4753                     int          *outBegIdx,
4754                     int          *outNBElement,
4755                     double        outReal[] );
4756 
4757 int TA_T3_Lookback( int           optInTimePeriod, /* From 2 to 100000 */
4758                   double        optInVFactor );  /* From 0 to 1 */
4759 
4760 
4761 /*
4762  * TA_TAN - Vector Trigonometric Tan
4763  *
4764  * Input  = double
4765  * Output = double
4766  *
4767  */
4768 TA_RetCode TA_TAN( int    startIdx,
4769                    int    endIdx,
4770                    const double inReal[],
4771                    int          *outBegIdx,
4772                    int          *outNBElement,
4773                    double        outReal[] );
4774 
4775 TA_RetCode TA_S_TAN( int    startIdx,
4776                      int    endIdx,
4777                      const float  inReal[],
4778                      int          *outBegIdx,
4779                      int          *outNBElement,
4780                      double        outReal[] );
4781 
4782 int TA_TAN_Lookback( void );
4783 
4784 
4785 /*
4786  * TA_TANH - Vector Trigonometric Tanh
4787  *
4788  * Input  = double
4789  * Output = double
4790  *
4791  */
4792 TA_RetCode TA_TANH( int    startIdx,
4793                     int    endIdx,
4794                     const double inReal[],
4795                     int          *outBegIdx,
4796                     int          *outNBElement,
4797                     double        outReal[] );
4798 
4799 TA_RetCode TA_S_TANH( int    startIdx,
4800                       int    endIdx,
4801                       const float  inReal[],
4802                       int          *outBegIdx,
4803                       int          *outNBElement,
4804                       double        outReal[] );
4805 
4806 int TA_TANH_Lookback( void );
4807 
4808 
4809 /*
4810  * TA_TEMA - Triple Exponential Moving Average
4811  *
4812  * Input  = double
4813  * Output = double
4814  *
4815  * Optional Parameters
4816  * -------------------
4817  * optInTimePeriod:(From 2 to 100000)
4818  *    Number of period
4819  *
4820  *
4821  */
4822 TA_RetCode TA_TEMA( int    startIdx,
4823                     int    endIdx,
4824                     const double inReal[],
4825                     int           optInTimePeriod, /* From 2 to 100000 */
4826                     int          *outBegIdx,
4827                     int          *outNBElement,
4828                     double        outReal[] );
4829 
4830 TA_RetCode TA_S_TEMA( int    startIdx,
4831                       int    endIdx,
4832                       const float  inReal[],
4833                       int           optInTimePeriod, /* From 2 to 100000 */
4834                       int          *outBegIdx,
4835                       int          *outNBElement,
4836                       double        outReal[] );
4837 
4838 int TA_TEMA_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
4839 
4840 
4841 /*
4842  * TA_TRANGE - True Range
4843  *
4844  * Input  = High, Low, Close
4845  * Output = double
4846  *
4847  */
4848 TA_RetCode TA_TRANGE( int    startIdx,
4849                       int    endIdx,
4850                       const double inHigh[],
4851                       const double inLow[],
4852                       const double inClose[],
4853                       int          *outBegIdx,
4854                       int          *outNBElement,
4855                       double        outReal[] );
4856 
4857 TA_RetCode TA_S_TRANGE( int    startIdx,
4858                         int    endIdx,
4859                         const float  inHigh[],
4860                         const float  inLow[],
4861                         const float  inClose[],
4862                         int          *outBegIdx,
4863                         int          *outNBElement,
4864                         double        outReal[] );
4865 
4866 int TA_TRANGE_Lookback( void );
4867 
4868 
4869 /*
4870  * TA_TRIMA - Triangular Moving Average
4871  *
4872  * Input  = double
4873  * Output = double
4874  *
4875  * Optional Parameters
4876  * -------------------
4877  * optInTimePeriod:(From 2 to 100000)
4878  *    Number of period
4879  *
4880  *
4881  */
4882 TA_RetCode TA_TRIMA( int    startIdx,
4883                      int    endIdx,
4884                      const double inReal[],
4885                      int           optInTimePeriod, /* From 2 to 100000 */
4886                      int          *outBegIdx,
4887                      int          *outNBElement,
4888                      double        outReal[] );
4889 
4890 TA_RetCode TA_S_TRIMA( int    startIdx,
4891                        int    endIdx,
4892                        const float  inReal[],
4893                        int           optInTimePeriod, /* From 2 to 100000 */
4894                        int          *outBegIdx,
4895                        int          *outNBElement,
4896                        double        outReal[] );
4897 
4898 int TA_TRIMA_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
4899 
4900 
4901 /*
4902  * TA_TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
4903  *
4904  * Input  = double
4905  * Output = double
4906  *
4907  * Optional Parameters
4908  * -------------------
4909  * optInTimePeriod:(From 1 to 100000)
4910  *    Number of period
4911  *
4912  *
4913  */
4914 TA_RetCode TA_TRIX( int    startIdx,
4915                     int    endIdx,
4916                     const double inReal[],
4917                     int           optInTimePeriod, /* From 1 to 100000 */
4918                     int          *outBegIdx,
4919                     int          *outNBElement,
4920                     double        outReal[] );
4921 
4922 TA_RetCode TA_S_TRIX( int    startIdx,
4923                       int    endIdx,
4924                       const float  inReal[],
4925                       int           optInTimePeriod, /* From 1 to 100000 */
4926                       int          *outBegIdx,
4927                       int          *outNBElement,
4928                       double        outReal[] );
4929 
4930 int TA_TRIX_Lookback( int           optInTimePeriod );  /* From 1 to 100000 */
4931 
4932 
4933 /*
4934  * TA_TSF - Time Series Forecast
4935  *
4936  * Input  = double
4937  * Output = double
4938  *
4939  * Optional Parameters
4940  * -------------------
4941  * optInTimePeriod:(From 2 to 100000)
4942  *    Number of period
4943  *
4944  *
4945  */
4946 TA_RetCode TA_TSF( int    startIdx,
4947                    int    endIdx,
4948                    const double inReal[],
4949                    int           optInTimePeriod, /* From 2 to 100000 */
4950                    int          *outBegIdx,
4951                    int          *outNBElement,
4952                    double        outReal[] );
4953 
4954 TA_RetCode TA_S_TSF( int    startIdx,
4955                      int    endIdx,
4956                      const float  inReal[],
4957                      int           optInTimePeriod, /* From 2 to 100000 */
4958                      int          *outBegIdx,
4959                      int          *outNBElement,
4960                      double        outReal[] );
4961 
4962 int TA_TSF_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
4963 
4964 
4965 /*
4966  * TA_TYPPRICE - Typical Price
4967  *
4968  * Input  = High, Low, Close
4969  * Output = double
4970  *
4971  */
4972 TA_RetCode TA_TYPPRICE( int    startIdx,
4973                         int    endIdx,
4974                         const double inHigh[],
4975                         const double inLow[],
4976                         const double inClose[],
4977                         int          *outBegIdx,
4978                         int          *outNBElement,
4979                         double        outReal[] );
4980 
4981 TA_RetCode TA_S_TYPPRICE( int    startIdx,
4982                           int    endIdx,
4983                           const float  inHigh[],
4984                           const float  inLow[],
4985                           const float  inClose[],
4986                           int          *outBegIdx,
4987                           int          *outNBElement,
4988                           double        outReal[] );
4989 
4990 int TA_TYPPRICE_Lookback( void );
4991 
4992 
4993 /*
4994  * TA_ULTOSC - Ultimate Oscillator
4995  *
4996  * Input  = High, Low, Close
4997  * Output = double
4998  *
4999  * Optional Parameters
5000  * -------------------
5001  * optInTimePeriod1:(From 1 to 100000)
5002  *    Number of bars for 1st period.
5003  *
5004  * optInTimePeriod2:(From 1 to 100000)
5005  *    Number of bars fro 2nd period
5006  *
5007  * optInTimePeriod3:(From 1 to 100000)
5008  *    Number of bars for 3rd period
5009  *
5010  *
5011  */
5012 TA_RetCode TA_ULTOSC( int    startIdx,
5013                       int    endIdx,
5014                       const double inHigh[],
5015                       const double inLow[],
5016                       const double inClose[],
5017                       int           optInTimePeriod1, /* From 1 to 100000 */
5018                       int           optInTimePeriod2, /* From 1 to 100000 */
5019                       int           optInTimePeriod3, /* From 1 to 100000 */
5020                       int          *outBegIdx,
5021                       int          *outNBElement,
5022                       double        outReal[] );
5023 
5024 TA_RetCode TA_S_ULTOSC( int    startIdx,
5025                         int    endIdx,
5026                         const float  inHigh[],
5027                         const float  inLow[],
5028                         const float  inClose[],
5029                         int           optInTimePeriod1, /* From 1 to 100000 */
5030                         int           optInTimePeriod2, /* From 1 to 100000 */
5031                         int           optInTimePeriod3, /* From 1 to 100000 */
5032                         int          *outBegIdx,
5033                         int          *outNBElement,
5034                         double        outReal[] );
5035 
5036 int TA_ULTOSC_Lookback( int           optInTimePeriod1, /* From 1 to 100000 */
5037                       int           optInTimePeriod2, /* From 1 to 100000 */
5038                       int           optInTimePeriod3 );  /* From 1 to 100000 */
5039 
5040 
5041 /*
5042  * TA_VAR - Variance
5043  *
5044  * Input  = double
5045  * Output = double
5046  *
5047  * Optional Parameters
5048  * -------------------
5049  * optInTimePeriod:(From 1 to 100000)
5050  *    Number of period
5051  *
5052  * optInNbDev:(From TA_REAL_MIN to TA_REAL_MAX)
5053  *    Nb of deviations
5054  *
5055  *
5056  */
5057 TA_RetCode TA_VAR( int    startIdx,
5058                    int    endIdx,
5059                    const double inReal[],
5060                    int           optInTimePeriod, /* From 1 to 100000 */
5061                    double        optInNbDev, /* From TA_REAL_MIN to TA_REAL_MAX */
5062                    int          *outBegIdx,
5063                    int          *outNBElement,
5064                    double        outReal[] );
5065 
5066 TA_RetCode TA_S_VAR( int    startIdx,
5067                      int    endIdx,
5068                      const float  inReal[],
5069                      int           optInTimePeriod, /* From 1 to 100000 */
5070                      double        optInNbDev, /* From TA_REAL_MIN to TA_REAL_MAX */
5071                      int          *outBegIdx,
5072                      int          *outNBElement,
5073                      double        outReal[] );
5074 
5075 int TA_VAR_Lookback( int           optInTimePeriod, /* From 1 to 100000 */
5076                    double        optInNbDev );  /* From TA_REAL_MIN to TA_REAL_MAX */
5077 
5078 
5079 /*
5080  * TA_WCLPRICE - Weighted Close Price
5081  *
5082  * Input  = High, Low, Close
5083  * Output = double
5084  *
5085  */
5086 TA_RetCode TA_WCLPRICE( int    startIdx,
5087                         int    endIdx,
5088                         const double inHigh[],
5089                         const double inLow[],
5090                         const double inClose[],
5091                         int          *outBegIdx,
5092                         int          *outNBElement,
5093                         double        outReal[] );
5094 
5095 TA_RetCode TA_S_WCLPRICE( int    startIdx,
5096                           int    endIdx,
5097                           const float  inHigh[],
5098                           const float  inLow[],
5099                           const float  inClose[],
5100                           int          *outBegIdx,
5101                           int          *outNBElement,
5102                           double        outReal[] );
5103 
5104 int TA_WCLPRICE_Lookback( void );
5105 
5106 
5107 /*
5108  * TA_WILLR - Williams' %R
5109  *
5110  * Input  = High, Low, Close
5111  * Output = double
5112  *
5113  * Optional Parameters
5114  * -------------------
5115  * optInTimePeriod:(From 2 to 100000)
5116  *    Number of period
5117  *
5118  *
5119  */
5120 TA_RetCode TA_WILLR( int    startIdx,
5121                      int    endIdx,
5122                      const double inHigh[],
5123                      const double inLow[],
5124                      const double inClose[],
5125                      int           optInTimePeriod, /* From 2 to 100000 */
5126                      int          *outBegIdx,
5127                      int          *outNBElement,
5128                      double        outReal[] );
5129 
5130 TA_RetCode TA_S_WILLR( int    startIdx,
5131                        int    endIdx,
5132                        const float  inHigh[],
5133                        const float  inLow[],
5134                        const float  inClose[],
5135                        int           optInTimePeriod, /* From 2 to 100000 */
5136                        int          *outBegIdx,
5137                        int          *outNBElement,
5138                        double        outReal[] );
5139 
5140 int TA_WILLR_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
5141 
5142 
5143 /*
5144  * TA_WMA - Weighted Moving Average
5145  *
5146  * Input  = double
5147  * Output = double
5148  *
5149  * Optional Parameters
5150  * -------------------
5151  * optInTimePeriod:(From 2 to 100000)
5152  *    Number of period
5153  *
5154  *
5155  */
5156 TA_RetCode TA_WMA( int    startIdx,
5157                    int    endIdx,
5158                    const double inReal[],
5159                    int           optInTimePeriod, /* From 2 to 100000 */
5160                    int          *outBegIdx,
5161                    int          *outNBElement,
5162                    double        outReal[] );
5163 
5164 TA_RetCode TA_S_WMA( int    startIdx,
5165                      int    endIdx,
5166                      const float  inReal[],
5167                      int           optInTimePeriod, /* From 2 to 100000 */
5168                      int          *outBegIdx,
5169                      int          *outNBElement,
5170                      double        outReal[] );
5171 
5172 int TA_WMA_Lookback( int           optInTimePeriod );  /* From 2 to 100000 */
5173 
5174 
5175 /* Some TA functions takes a certain amount of input data
5176  * before stabilizing and outputing meaningful data. This is
5177  * a behavior pertaining to the algo of some TA functions and
5178  * is not particular to the TA-Lib implementation.
5179  * TA-Lib allows you to automatically strip off these unstabl
5180  * data from your output and from any internal processing.
5181  * (See documentation for more info)
5182  *
5183  * Examples:
5184  *      TA_SetUnstablePeriod( TA_FUNC_UNST_EMA, 30 );
5185  *           Always strip off 30 price bar for the TA_EMA function.
5186  *
5187  *      TA_SetUnstablePeriod( TA_FUNC_UNST_ALL, 30 );
5188  *           Always strip off 30 price bar from ALL functions
5189  *           having an unstable period.
5190  *
5191  * See ta_defs.h for the enumeration TA_FuncUnstId
5192  */
5193 
5194 TA_RetCode TA_SetUnstablePeriod( TA_FuncUnstId id,
5195                                  unsigned int  unstablePeriod );
5196 
5197 unsigned int TA_GetUnstablePeriod( TA_FuncUnstId id );
5198 
5199 /* You can change slightly the behavior of the TA functions
5200  * by requesting compatibiliy with some existing software.
5201  *
5202  * By default, the behavior is as close as the original
5203  * author of the TA functions intend it to be.
5204  *
5205  * See ta_defs.h for the enumeration TA_Compatibility.
5206  */
5207 TA_RetCode TA_SetCompatibility( TA_Compatibility value );
5208 TA_Compatibility TA_GetCompatibility( void );
5209 
5210 /* Candlesticks struct and functions
5211  * Because candlestick patterns are subjective, it is necessary
5212  * to allow the user to specify what should be the meaning of
5213  * 'long body', 'short shadows', etc.
5214  */
5215 
5216 /* Call TA_SetCandleSettings to set that when comparing a candle
5217  * basing on settingType it must be compared with the average
5218  * of the last avgPeriod candles' rangeType multiplied by factor.
5219  * This setting is valid until TA_RestoreCandleDefaultSettings is called
5220  */
5221 TA_RetCode TA_SetCandleSettings( TA_CandleSettingType settingType,
5222                                  TA_RangeType rangeType,
5223                                  int avgPeriod,
5224                                  double factor );
5225 
5226 /* Call TA_RestoreCandleDefaultSettings after using custom settings
5227  * to restore the default settings for the specified settingType
5228  */
5229 TA_RetCode TA_RestoreCandleDefaultSettings( TA_CandleSettingType settingType );
5230 
5231 #ifdef __cplusplus
5232 }
5233 #endif
5234 
5235 #endif
5236 
5237 /***************/
5238 /* End of File */
5239 /***************/
5240 
5241