用VC开发股票分析软件(一)

最新推荐文章于 2024-10-04 10:22:58 发布
最新推荐文章于 2024-10-04 10:22:58 发布
阅读量1.1w 收藏 12
点赞数 1
文章标签： integer java 算法 图形 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/masterjames/article/details/2974506
版权
 开发思路
 最大的难点：公式算法，图形显示.
   A.算法：凡是涉及公式的MACD,CCI,RSI等的算法，如何解决
   
   
  1. TA_RetCode TA_MACD( int    startIdx,
  2.                     int    endIdx,
  3.                     const double inReal[],
  4.                     int           optInFastPeriod, /* From 2 to 100000 */
  5.                     int           optInSlowPeriod, /* From 2 to 100000 */
  6.                     int           optInSignalPeriod, /* From 1 to 100000 */
  7.                     int          *outBegIdx,
  8.                     int          *outNBElement,
  9.                     double        outMACD[],
  10.                     double        outMACDSignal[],
  11.                     double        outMACDHist[] );
  13. TA_RetCode TA_S_MACD( int    startIdx,
  14.                       int    endIdx,
  15.                       const float  inReal[],
  16.                       int           optInFastPeriod, /* From 2 to 100000 */
  17.                       int           optInSlowPeriod, /* From 2 to 100000 */
  18.                       int           optInSignalPeriod, /* From 1 to 100000 */
  19.                       int          *outBegIdx,
  20.                       int          *outNBElement,
  21.                       double        outMACD[],
  22.                       double        outMACDSignal[],
  23.                       double        outMACDHist[] );
  25. int TA_MACD_Lookback( int           optInFastPeriod, /* From 2 to 100000 */
  26.                     int           optInSlowPeriod, /* From 2 to 100000 */
  27.                     int           optInSignalPeriod );  /* From 1 to 100000 */
 测试MACD
 
  1. // TestMACD.cpp : Defines the entry point for the console application.
  2. //
  4. #include "stdafx.h"
  5. #include "ta_libc.h"
  6. #include "iostream.h"
  9. TA_Real    closePrice[400];
  10. TA_Real    out[400];
  11. TA_Integer outBeg;
  12. TA_Integer outNbElement;
  13. /* ... initialize your closing price here... */
  20. //TA_RetCode retCode = TA_MA(0, 399,&closePrice[0],30,TA_MAType_SMA,&outBeg,&outNbElement,&out[0]);
  21. int main(int argc, char* argv[])
  22. {
  23.     /* The output is displayed here */
  24.    for(int j=0;j<401;)
  25.    {
  26.        closePrice[j++]=1;
  27.       
  28.    }    
  29.    TA_RetCode retCode = TA_MA(0, 399,&closePrice[0],30,TA_MAType_SMA,&outBeg,&outNbElement,&out[0]);
  30.     
  31.    for(int i=0; i < outNbElement; i++ )
  32.    printf( "Day %d = %f/n", outBeg+i, out[i] );
  35.     printf("Hello World!/n");
  36.     return 0;
  37. }
  这些分析函数都是公开源码的。国外有一家学院的研究机构发布了所有证券分析软件公式算法函数。
  如果要用的话，要遵守GPL，采用的TA-LIB的名字，要署名。
  个人非常羡慕这种研究文化....
 
  1. /* List of contributors:
  2.  *
  3.  *  Initial  Name/description
  4.  *  -------------------------------------------------------------------
  5.  *  MF       Mario Fortier
  6.  *  JPP      JP Pienaar (j.pienaar@mci.co.za)
  7.  *
  8.  * Change history:
  9.  *
  10.  *  MMDDYY BY   Description
  11.  *  -------------------------------------------------------------------
  12.  *  112400 MF   Template creation.
  13.  *  052603 MF   Adapt code to compile with .NET Managed C++
  14.  *  080403 JPP  Fix #767653 for logic when swapping periods.
  15.  *
  16.  */
  18. /**** START GENCODE SECTION 1 - DO NOT DELETE THIS LINE ****/
  19. /* All code within this section is automatically
  20.  * generated by gen_code. Any modification will be lost
  21.  * next time gen_code is run.
  22.  */
  23. /* Generated */ 
  24. /* Generated */ #if defined( _MANAGED )
  25. /* Generated */    #include "TA-Lib-Core.h"
  26. /* Generated */    #define TA_INTERNAL_ERROR(Id) (RetCode::InternalError)
  27. /* Generated */    namespace TicTacTec { namespace TA { namespace Library {
  28. /* Generated */ #elif defined( _JAVA )
  29. /* Generated */    #include "ta_defs.h"
  30. /* Generated */    #include "ta_java_defs.h"
  31. /* Generated */    #define TA_INTERNAL_ERROR(Id) (RetCode.InternalError)
  32. /* Generated */ #else
  33. /* Generated */    #include <string.h>
  34. /* Generated */    #include <math.h>
  35. /* Generated */    #include "ta_func.h"
  36. /* Generated */ #endif
  37. /* Generated */ 
  38. /* Generated */ #ifndef TA_UTILITY_H
  39. /* Generated */    #include "ta_utility.h"
  40. /* Generated */ #endif
  41. /* Generated */ 
  42. /* Generated */ #ifndef TA_MEMORY_H
  43. /* Generated */    #include "ta_memory.h"
  44. /* Generated */ #endif
  45. /* Generated */ 
  46. /* Generated */ #define TA_PREFIX(x) TA_##x
  47. /* Generated */ #define INPUT_TYPE   double
  48. /* Generated */ 
  49. /* Generated */ #if defined( _MANAGED )
  50. /* Generated */ int Core::MacdLookback( int           optInFastPeriod, /* From 2 to 100000 */
  51. /* Generated */                       int           optInSlowPeriod, /* From 2 to 100000 */
  52. /* Generated */                       int           optInSignalPeriod )  /* From 1 to 100000 */
  53. /* Generated */ 
  54. /* Generated */ #elif defined( _JAVA )
  55. /* Generated */ public int macdLookback( int           optInFastPeriod, /* From 2 to 100000 */
  56. /* Generated */                        int           optInSlowPeriod, /* From 2 to 100000 */
  57. /* Generated */                        int           optInSignalPeriod )  /* From 1 to 100000 */
  58. /* Generated */ 
  59. /* Generated */ #else
  60. /* Generated */ int TA_MACD_Lookback( int           optInFastPeriod, /* From 2 to 100000 */
  61. /* Generated */                     int           optInSlowPeriod, /* From 2 to 100000 */
  62. /* Generated */                     int           optInSignalPeriod )  /* From 1 to 100000 */
  63. /* Generated */ 
  64. /* Generated */ #endif
  65. /**** END GENCODE SECTION 1 - DO NOT DELETE THIS LINE ****/
  66. {
  67.    /* insert local variable here */
  68.    int tempInteger;
  70. /**** START GENCODE SECTION 2 - DO NOT DELETE THIS LINE ****/
  71. /* Generated */ #ifndef TA_FUNC_NO_RANGE_CHECK
  72. /* Generated */    /* min/max are checked for optInFastPeriod. */
  73. /* Generated */    if( (int)optInFastPeriod == TA_INTEGER_DEFAULT )
  74. /* Generated */       optInFastPeriod = 12;
  75. /* Generated */    else if( ((int)optInFastPeriod < 2) || ((int)optInFastPeriod > 100000) )
  76. /* Generated */       return -1;
  77. /* Generated */ 
  78. /* Generated */    /* min/max are checked for optInSlowPeriod. */
  79. /* Generated */    if( (int)optInSlowPeriod == TA_INTEGER_DEFAULT )
  80. /* Generated */       optInSlowPeriod = 26;
  81. /* Generated */    else if( ((int)optInSlowPeriod < 2) || ((int)optInSlowPeriod > 100000) )
  82. /* Generated */       return -1;
  83. /* Generated */ 
  84. /* Generated */    /* min/max are checked for optInSignalPeriod. */
  85. /* Generated */    if( (int)optInSignalPeriod == TA_INTEGER_DEFAULT )
  86. /* Generated */       optInSignalPeriod = 9;
  87. /* Generated */    else if( ((int)optInSignalPeriod < 1) || ((int)optInSignalPeriod > 100000) )
  88. /* Generated */       return -1;
  89. /* Generated */ 
  90. /* Generated */ #endif /* TA_FUNC_NO_RANGE_CHECK */
  91. /**** END GENCODE SECTION 2 - DO NOT DELETE THIS LINE ****/
  93.    /* insert lookback code here. */
  95.    /* The lookback is driven by the signal line output.
  96.     *
  97.     * (must also account for the initial data consume 
  98.     *  by the slow period).
  99.     */
  101.    /* Make sure slow is really slower than
  102.     * the fast period! if not, swap...
  103.     */
  104.    if( optInSlowPeriod < optInFastPeriod )
  105.    {
  106.        /* swap */
  107.        tempInteger       = optInSlowPeriod;
  108.        optInSlowPeriod = optInFastPeriod;
  109.        optInFastPeriod = tempInteger;
  110.    }
  112.    return   LOOKBACK_CALL(EMA)( optInSlowPeriod   )
  113.           + LOOKBACK_CALL(EMA)( optInSignalPeriod );
  114. }
  117. /**** START GENCODE SECTION 3 - DO NOT DELETE THIS LINE ****/
  118. /*
  119.  * TA_MACD - Moving Average Convergence/Divergence
  120.  * 
  121.  * Input  = double
  122.  * Output = double, double, double
  123.  * 
  124.  * Optional Parameters
  125.  * -------------------
  126.  * optInFastPeriod:(From 2 to 100000)
  127.  *    Number of period for the fast MA
  128.  * 
  129.  * optInSlowPeriod:(From 2 to 100000)
  130.  *    Number of period for the slow MA
  131.  * 
  132.  * optInSignalPeriod:(From 1 to 100000)
  133.  *    Smoothing for the signal line (nb of period)
  134.  * 
  135.  * 
  136.  */
  137. /* Generated */ 
  138. /* Generated */ #if defined( _MANAGED ) && defined( USE_SUBARRAY )
  139. /* Generated */ enum class Core::RetCode Core::Macd( int    startIdx,
  140. /* Generated */                                      int    endIdx,
  141. /* Generated */                                      SubArray^    inReal,
  142. /* Generated */                                      int           optInFastPeriod, /* From 2 to 100000 */
  143. /* Generated */                                      int           optInSlowPeriod, /* From 2 to 100000 */
  144. /* Generated */                                      int           optInSignalPeriod, /* From 1 to 100000 */
  145. /* Generated */                                      [Out]int%    outBegIdx,
  146. /* Generated */                                      [Out]int%    outNBElement,
  147. /* Generated */                                      cli::array<double>^  outMACD,
  148. /* Generated */                                      cli::array<double>^  outMACDSignal,
  149. /* Generated */                                      cli::array<double>^  outMACDHist )
  150. /* Generated */ #elif defined( _MANAGED )
  151. /* Generated */ enum class Core::RetCode Core::Macd( int    startIdx,
  152. /* Generated */                                      int    endIdx,
  153. /* Generated */                                      cli::array<double>^ inReal,
  154. /* Generated */                                      int           optInFastPeriod, /* From 2 to 100000 */
  155. /* Generated */                                      int           optInSlowPeriod, /* From 2 to 100000 */
  156. /* Generated */                                      int           optInSignalPeriod, /* From 1 to 100000 */
  157. /* Generated */                                      [Out]int%    outBegIdx,
  158. /* Generated */                                      [Out]int%    outNBElement,
  159. /* Generated */                                      cli::array<double>^  outMACD,
  160. /* Generated */                                      cli::array<double>^  outMACDSignal,
  161. /* Generated */                                      cli::array<double>^  outMACDHist )
  162. /* Generated */ #elif defined( _JAVA )
  163. /* Generated */ public RetCode macd( int    startIdx,
  164. /* Generated */                      int    endIdx,
  165. /* Generated */                      double       inReal[],
  166. /* Generated */                      int           optInFastPeriod, /* From 2 to 100000 */
  167. /* Generated */                      int           optInSlowPeriod, /* From 2 to 100000 */
  168. /* Generated */                      int           optInSignalPeriod, /* From 1 to 100000 */
  169. /* Generated */                      MInteger     outBegIdx,
  170. /* Generated */                      MInteger     outNBElement,
  171. /* Generated */                      double        outMACD[],
  172. /* Generated */                      double        outMACDSignal[],
  173. /* Generated */                      double        outMACDHist[] )
  174. /* Generated */ #else
  175. /* Generated */ TA_RetCode TA_MACD( int    startIdx,
  176. /* Generated */                     int    endIdx,
  177. /* Generated */                     const double inReal[],
  178. /* Generated */                     int           optInFastPeriod, /* From 2 to 100000 */
  179. /* Generated */                     int           optInSlowPeriod, /* From 2 to 100000 */
  180. /* Generated */                     int           optInSignalPeriod, /* From 1 to 100000 */
  181. /* Generated */                     int          *outBegIdx,
  182. /* Generated */                     int          *outNBElement,
  183. /* Generated */                     double        outMACD[],
  184. /* Generated */                     double        outMACDSignal[],
  185. /* Generated */                     double        outMACDHist[] )
  186. /* Generated */ #endif
  187. /**** END GENCODE SECTION 3 - DO NOT DELETE THIS LINE ****/
  188. {
  189.    /* Insert local variables here. */
  191. /**** START GENCODE SECTION 4 - DO NOT DELETE THIS LINE ****/
  192. /* Generated */ 
  193. /* Generated */ #ifndef TA_FUNC_NO_RANGE_CHECK
  194. /* Generated */ 
  195. /* Generated */    /* Validate the requested output range. */
  196. /* Generated */    if( startIdx < 0 )
  197. /* Generated */       return ENUM_VALUE(RetCode,TA_OUT_OF_RANGE_START_INDEX,OutOfRangeStartIndex);
  198. /* Generated */    if( (endIdx < 0) || (endIdx < startIdx))
  199. /* Generated */       return ENUM_VALUE(RetCode,TA_OUT_OF_RANGE_END_INDEX,OutOfRangeEndIndex);
  200. /* Generated */ 
  201. /* Generated */    #if !defined(_JAVA)
  202. /* Generated */    if( !inReal ) return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  203. /* Generated */    #endif /* !defined(_JAVA)*/
  204. /* Generated */    /* min/max are checked for optInFastPeriod. */
  205. /* Generated */    if( (int)optInFastPeriod == TA_INTEGER_DEFAULT )
  206. /* Generated */       optInFastPeriod = 12;
  207. /* Generated */    else if( ((int)optInFastPeriod < 2) || ((int)optInFastPeriod > 100000) )
  208. /* Generated */       return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  209. /* Generated */ 
  210. /* Generated */    /* min/max are checked for optInSlowPeriod. */
  211. /* Generated */    if( (int)optInSlowPeriod == TA_INTEGER_DEFAULT )
  212. /* Generated */       optInSlowPeriod = 26;
  213. /* Generated */    else if( ((int)optInSlowPeriod < 2) || ((int)optInSlowPeriod > 100000) )
  214. /* Generated */       return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  215. /* Generated */ 
  216. /* Generated */    /* min/max are checked for optInSignalPeriod. */
  217. /* Generated */    if( (int)optInSignalPeriod == TA_INTEGER_DEFAULT )
  218. /* Generated */       optInSignalPeriod = 9;
  219. /* Generated */    else if( ((int)optInSignalPeriod < 1) || ((int)optInSignalPeriod > 100000) )
  220. /* Generated */       return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  221. /* Generated */ 
  222. /* Generated */    #if !defined(_JAVA)
  223. /* Generated */    if( !outMACD )
  224. /* Generated */       return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  225. /* Generated */ 
  226. /* Generated */    if( !outMACDSignal )
  227. /* Generated */       return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  228. /* Generated */ 
  229. /* Generated */    if( !outMACDHist )
  230. /* Generated */       return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  231. /* Generated */ 
  232. /* Generated */    #endif /* !defined(_JAVA) */
  233. /* Generated */ #endif /* TA_FUNC_NO_RANGE_CHECK */
  234. /* Generated */ 
  235. /**** END GENCODE SECTION 4 - DO NOT DELETE THIS LINE ****/
  237.    /* Insert TA function code here. */  
  239.    return FUNCTION_CALL(INT_MACD)( startIdx, endIdx, inReal,
  240.                                    optInFastPeriod,
  241.                                    optInSlowPeriod,
  242.                                    optInSignalPeriod,
  243.                                    outBegIdx,
  244.                                    outNBElement,
  245.                                    outMACD,
  246.                                    outMACDSignal,
  247.                                    outMACDHist );
  248. }
  250. #if defined( _MANAGED ) && defined( USE_SUBARRAY ) && !defined( USE_SINGLE_PRECISION_INPUT )
  251.  enum class Core::RetCode Core::TA_INT_MACD( int    startIdx,
  252.                                              int    endIdx,
  253.                                              SubArray^ inReal,
  254.                                              int    optInFastPeriod, /* 0 is fix 12 */
  255.                                              int    optInSlowPeriod, /* 0 is fix 26 */
  256.                                              int    optInSignalPeriod_2,
  257.                                              [Out]int% outBegIdx,
  258.                                              [Out]int% outNBElement,
  259.                                              cli::array<double>^ outMACD,
  260.                                              cli::array<double>^ outMACDSignal,
  261.                                              cli::array<double>^ outMACDHist )
  262. #elif defined( _MANAGED )
  263.  enum class Core::RetCode Core::TA_INT_MACD( int    startIdx,
  264.                                              int    endIdx,
  265.                                              cli::array<INPUT_TYPE>^ inReal,
  266.                                              int    optInFastPeriod, /* 0 is fix 12 */
  267.                                              int    optInSlowPeriod, /* 0 is fix 26 */
  268.                                              int    optInSignalPeriod_2,
  269.                                              [Out]int% outBegIdx,
  270.                                              [Out]int% outNBElement,
  271.                                              cli::array<double>^ outMACD,
  272.                                              cli::array<double>^ outMACDSignal,
  273.                                              cli::array<double>^ outMACDHist )
  274. #elif defined( _JAVA )
  275. RetCode TA_INT_MACD( int        startIdx,
  276.                      int        endIdx,
  277.                      INPUT_TYPE inReal[],
  278.                      int        optInFastPeriod, /* 0 is fix 12 */
  279.                      int        optInSlowPeriod, /* 0 is fix 26 */
  280.                      int        optInSignalPeriod_2,
  281.                      MInteger   outBegIdx,
  282.                      MInteger   outNBElement,
  283.                      double     outMACD[],
  284.                      double     outMACDSignal[],
  285.                      double     outMACDHist[] )
  287. #else
  288. TA_RetCode TA_PREFIX(INT_MACD)( int    startIdx,
  289.                                 int    endIdx,
  290.                                 const INPUT_TYPE inReal[],
  291.                                 int    optInFastPeriod, /* 0 is fix 12 */
  292.                                 int    optInSlowPeriod, /* 0 is fix 26 */
  293.                                 int    optInSignalPeriod_2,
  294.                                 int   *outBegIdx,
  295.                                 int   *outNBElement,
  296.                                 double       outMACD[],
  297.                                 double       outMACDSignal[],
  298.                                 double       outMACDHist[] )
  299. #endif
  300. {
  301.    ARRAY_REF(slowEMABuffer);
  302.    ARRAY_REF(fastEMABuffer);
  303.    double k1, k2;
  304.    ENUM_DECLARATION(RetCode) retCode;
  305.    int tempInteger;
  306.    VALUE_HANDLE_INT(outBegIdx1);
  307.    VALUE_HANDLE_INT(outNbElement1);
  308.    VALUE_HANDLE_INT(outBegIdx2);
  309.    VALUE_HANDLE_INT(outNbElement2);
  310.    int lookbackTotal, lookbackSignal;
  311.    int i;
  313.    /* !!! A lot of speed optimization could be done
  314.     * !!! with this function. 
  315.     * !!!
  316.     * !!! A better approach would be to use TA_INT_EMA
  317.     * !!! just to get the seeding values for the
  318.     * !!! fast and slow EMA. Then process the difference
  319.     * !!! in an allocated buffer until enough data is
  320.     * !!! available for the first signal value.
  321.     * !!! From that point all the processing can
  322.     * !!! be done in a tight loop.
  323.     * !!!
  324.     * !!! That approach will have the following
  325.     * !!! advantage:
  326.     * !!!   1) One mem allocation needed instead of two.
  327.     * !!!   2) The mem allocation size will be only the
  328.     * !!!      signal lookback period instead of the 
  329.     * !!!      whole range of data.
  330.     * !!!   3) Processing will be done in a tight loop.
  331.     * !!!      allowing to avoid a lot of memory store-load
  332.     * !!!      operation.
  333.     * !!!   4) The memcpy at the end will be eliminated!
  334.     * !!!
  335.     * !!! If only I had time....
  336.     */
  338.    /* Make sure slow is really slower than
  339.     * the fast period! if not, swap...
  340.     */
  341.    if( optInSlowPeriod < optInFastPeriod )
  342.    {
  343.        /* swap */
  344.        tempInteger       = optInSlowPeriod;
  345.        optInSlowPeriod = optInFastPeriod;
  346.        optInFastPeriod = tempInteger;
  347.    }
  349.    /* Catch special case for fix 26/12 MACD. */
  350.    if( optInSlowPeriod != 0 )
  351.       k1 = PER_TO_K(optInSlowPeriod);
  352.    else
  353.    {
  354.       optInSlowPeriod = 26;
  355.       k1 = (double)0.075; /* Fix 26 */
  356.    }
  358.    if( optInFastPeriod != 0 )
  359.       k2 = PER_TO_K(optInFastPeriod);
  360.    else
  361.    {
  362.       optInFastPeriod = 12;
  363.       k2 = (double)0.15; /* Fix 12 */
  364.    }
  366.    lookbackSignal = LOOKBACK_CALL(EMA)( optInSignalPeriod_2 ); 
  368.    /* Move up the start index if there is not
  369.     * enough initial data.
  370.     */
  371.    lookbackTotal =  lookbackSignal;
  372.    lookbackTotal += LOOKBACK_CALL(EMA)( optInSlowPeriod );
  374.    if( startIdx < lookbackTotal )
  375.       startIdx = lookbackTotal;
  377.    /* Make sure there is still something to evaluate. */
  378.    if( startIdx > endIdx )
  379.    {
  380.       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  381.       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  382.       return ENUM_VALUE(RetCode,TA_SUCCESS,Success);
  383.    }
  385.    /* Allocate intermediate buffer for fast/slow EMA. */
  386.    tempInteger = (endIdx-startIdx)+1+lookbackSignal;
  387.    ARRAY_ALLOC( fastEMABuffer, tempInteger );
  388.    #if !defined( _JAVA )
  389.       if( !fastEMABuffer )
  390.       {
  391.          VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  392.          VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  393.          return ENUM_VALUE(RetCode,TA_ALLOC_ERR,AllocErr);
  394.       }
  395.    #endif
  397.    ARRAY_ALLOC( slowEMABuffer, tempInteger );
  398.    #if !defined( _JAVA )
  399.       if( !slowEMABuffer )
  400.       {
  401.          VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  402.          VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  403.          ARRAY_FREE( fastEMABuffer );
  404.          return ENUM_VALUE(RetCode,TA_ALLOC_ERR,AllocErr);
  405.       }
  406.    #endif
  408.    /* Calculate the slow EMA. 
  409.     *
  410.     * Move back the startIdx to get enough data
  411.     * for the signal period. That way, once the
  412.     * signal calculation is done, all the output
  413.     * will start at the requested 'startIdx'.
  414.     */
  415.    tempInteger = startIdx-lookbackSignal;
  416.    retCode = FUNCTION_CALL(INT_EMA)( tempInteger, endIdx,
  417.                                      inReal, optInSlowPeriod, k1,
  418.                                      VALUE_HANDLE_OUT(outBegIdx1), VALUE_HANDLE_OUT(outNbElement1), slowEMABuffer );
  420.    if( retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success) )
  421.    {
  422.       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  423.       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  424.       ARRAY_FREE( fastEMABuffer );
  425.       ARRAY_FREE( slowEMABuffer );
  426.       return retCode;
  427.    }
  429.    /* Calculate the fast EMA. */
  430.    retCode = FUNCTION_CALL(INT_EMA)( tempInteger, endIdx,
  431.                                      inReal, optInFastPeriod, k2,
  432.                                      VALUE_HANDLE_OUT(outBegIdx2), VALUE_HANDLE_OUT(outNbElement2), fastEMABuffer );
  434.    if( retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success) )
  435.    {
  436.       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  437.       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  438.       ARRAY_FREE( fastEMABuffer );
  439.       ARRAY_FREE( slowEMABuffer );
  440.       return retCode;
  441.    }
  443.    /* Parano tests. Will be removed eventually. */
  444.    if( (VALUE_HANDLE_GET(outBegIdx1) != tempInteger) || 
  445.        (VALUE_HANDLE_GET(outBegIdx2) != tempInteger) || 
  446.        (VALUE_HANDLE_GET(outNbElement1) != VALUE_HANDLE_GET(outNbElement2)) ||
  447.        (VALUE_HANDLE_GET(outNbElement1) != (endIdx-startIdx)+1+lookbackSignal) )
  448.    {
  449.       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  450.       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  451.       ARRAY_FREE( fastEMABuffer );
  452.       ARRAY_FREE( slowEMABuffer );
  453.       return TA_INTERNAL_ERROR(119);
  454.    }
  456.    /* Calculate (fast EMA) - (slow EMA). */
  457.    for( i=0; i < VALUE_HANDLE_GET(outNbElement1); i++ )
  458.       fastEMABuffer[i] = fastEMABuffer[i] - slowEMABuffer[i];
  461.    /* Copy the result into the output for the caller. */
  462.    ARRAY_MEMMOVE( outMACD, 0, fastEMABuffer, lookbackSignal, (endIdx-startIdx)+1 );
  464.    /* Calculate the signal/trigger line. */
  465.    retCode = FUNCTION_CALL_DOUBLE(INT_EMA)( 0, VALUE_HANDLE_GET(outNbElement1)-1,
  466.                                             fastEMABuffer, optInSignalPeriod_2, PER_TO_K(optInSignalPeriod_2), 
  467.                                             VALUE_HANDLE_OUT(outBegIdx2), VALUE_HANDLE_OUT(outNbElement2), outMACDSignal );
  470.    ARRAY_FREE( fastEMABuffer );
  471.    ARRAY_FREE( slowEMABuffer );
  473.    if( retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success) )
  474.    {
  475.       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  476.       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  477.       return retCode;
  478.    }
  480.    /* Calculate the histogram. */
  481.    for( i=0; i < VALUE_HANDLE_GET(outNbElement2); i++ )
  482.       outMACDHist[i] = outMACD[i]-outMACDSignal[i];
  485.    /* All done! Indicate the output limits and return success. */
  486.    VALUE_HANDLE_DEREF(outBegIdx)     = startIdx;
  487.    VALUE_HANDLE_DEREF(outNBElement)  = VALUE_HANDLE_GET(outNbElement2);
  489.    return ENUM_VALUE(RetCode,TA_SUCCESS,Success);
  490. }
  493. /**** START GENCODE SECTION 5 - DO NOT DELETE THIS LINE ****/
  494. /* Generated */ 
  495. /* Generated */ #define  USE_SINGLE_PRECISION_INPUT
  496. /* Generated */ #if !defined( _MANAGED ) && !defined( _JAVA )
  497. /* Generated */    #undef   TA_PREFIX
  498. /* Generated */    #define  TA_PREFIX(x) TA_S_##x
  499. /* Generated */ #endif
  500. /* Generated */ #undef   INPUT_TYPE
  501. /* Generated */ #define  INPUT_TYPE float
  502. /* Generated */ #if defined( _MANAGED )
  503. /* Generated */ enum class Core::RetCode Core::Macd( int    startIdx,
  504. /* Generated */                                      int    endIdx,
  505. /* Generated */                                      cli::array<float>^ inReal,
  506. /* Generated */                                      int           optInFastPeriod, /* From 2 to 100000 */
  507. /* Generated */                                      int           optInSlowPeriod, /* From 2 to 100000 */
  508. /* Generated */                                      int           optInSignalPeriod, /* From 1 to 100000 */
  509. /* Generated */                                      [Out]int%    outBegIdx,
  510. /* Generated */                                      [Out]int%    outNBElement,
  511. /* Generated */                                      cli::array<double>^  outMACD,
  512. /* Generated */                                      cli::array<double>^  outMACDSignal,
  513. /* Generated */                                      cli::array<double>^  outMACDHist )
  514. /* Generated */ #elif defined( _JAVA )
  515. /* Generated */ public RetCode macd( int    startIdx,
  516. /* Generated */                      int    endIdx,
  517. /* Generated */                      float        inReal[],
  518. /* Generated */                      int           optInFastPeriod, /* From 2 to 100000 */
  519. /* Generated */                      int           optInSlowPeriod, /* From 2 to 100000 */
  520. /* Generated */                      int           optInSignalPeriod, /* From 1 to 100000 */
  521. /* Generated */                      MInteger     outBegIdx,
  522. /* Generated */                      MInteger     outNBElement,
  523. /* Generated */                      double        outMACD[],
  524. /* Generated */                      double        outMACDSignal[],
  525. /* Generated */                      double        outMACDHist[] )
  526. /* Generated */ #else
  527. /* Generated */ TA_RetCode TA_S_MACD( int    startIdx,
  528. /* Generated */                       int    endIdx,
  529. /* Generated */                       const float  inReal[],
  530. /* Generated */                       int           optInFastPeriod, /* From 2 to 100000 */
  531. /* Generated */                       int           optInSlowPeriod, /* From 2 to 100000 */
  532. /* Generated */                       int           optInSignalPeriod, /* From 1 to 100000 */
  533. /* Generated */                       int          *outBegIdx,
  534. /* Generated */                       int          *outNBElement,
  535. /* Generated */                       double        outMACD[],
  536. /* Generated */                       double        outMACDSignal[],
  537. /* Generated */                       double        outMACDHist[] )
  538. /* Generated */ #endif
  539. /* Generated */ {
  540. /* Generated */  #ifndef TA_FUNC_NO_RANGE_CHECK
  541. /* Generated */     if( startIdx < 0 )
  542. /* Generated */        return ENUM_VALUE(RetCode,TA_OUT_OF_RANGE_START_INDEX,OutOfRangeStartIndex);
  543. /* Generated */     if( (endIdx < 0) || (endIdx < startIdx))
  544. /* Generated */        return ENUM_VALUE(RetCode,TA_OUT_OF_RANGE_END_INDEX,OutOfRangeEndIndex);
  545. /* Generated */     #if !defined(_JAVA)
  546. /* Generated */     if( !inReal ) return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  547. /* Generated */     #endif 
  548. /* Generated */     if( (int)optInFastPeriod == TA_INTEGER_DEFAULT )
  549. /* Generated */        optInFastPeriod = 12;
  550. /* Generated */     else if( ((int)optInFastPeriod < 2) || ((int)optInFastPeriod > 100000) )
  551. /* Generated */        return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  552. /* Generated */     if( (int)optInSlowPeriod == TA_INTEGER_DEFAULT )
  553. /* Generated */        optInSlowPeriod = 26;
  554. /* Generated */     else if( ((int)optInSlowPeriod < 2) || ((int)optInSlowPeriod > 100000) )
  555. /* Generated */        return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  556. /* Generated */     if( (int)optInSignalPeriod == TA_INTEGER_DEFAULT )
  557. /* Generated */        optInSignalPeriod = 9;
  558. /* Generated */     else if( ((int)optInSignalPeriod < 1) || ((int)optInSignalPeriod > 100000) )
  559. /* Generated */        return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  560. /* Generated */     #if !defined(_JAVA)
  561. /* Generated */     if( !outMACD )
  562. /* Generated */        return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  563. /* Generated */     if( !outMACDSignal )
  564. /* Generated */        return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  565. /* Generated */     if( !outMACDHist )
  566. /* Generated */        return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
  567. /* Generated */     #endif 
  568. /* Generated */  #endif 
  569. /* Generated */    return FUNCTION_CALL(INT_MACD)( startIdx, endIdx, inReal,
  570. /* Generated */                                    optInFastPeriod,
  571. /* Generated */                                    optInSlowPeriod,
  572. /* Generated */                                    optInSignalPeriod,
  573. /* Generated */                                    outBegIdx,
  574. /* Generated */                                    outNBElement,
  575. /* Generated */                                    outMACD,
  576. /* Generated */                                    outMACDSignal,
  577. /* Generated */                                    outMACDHist );
  578. /* Generated */ }
  579. /* Generated */ #if defined( _MANAGED ) && defined( USE_SUBARRAY ) && !defined( USE_SINGLE_PRECISION_INPUT )
  580. /* Generated */  enum class Core::RetCode Core::TA_INT_MACD( int    startIdx,
  581. /* Generated */                                              int    endIdx,
  582. /* Generated */                                              SubArray^ inReal,
  583. /* Generated */                                              int    optInFastPeriod, 
  584. /* Generated */                                              int    optInSlowPeriod, 
  585. /* Generated */                                              int    optInSignalPeriod_2,
  586. /* Generated */                                              [Out]int% outBegIdx,
  587. /* Generated */                                              [Out]int% outNBElement,
  588. /* Generated */                                              cli::array<double>^ outMACD,
  589. /* Generated */                                              cli::array<double>^ outMACDSignal,
  590. /* Generated */                                              cli::array<double>^ outMACDHist )
  591. /* Generated */ #elif defined( _MANAGED )
  592. /* Generated */  enum class Core::RetCode Core::TA_INT_MACD( int    startIdx,
  593. /* Generated */                                              int    endIdx,
  594. /* Generated */                                              cli::array<INPUT_TYPE>^ inReal,
  595. /* Generated */                                              int    optInFastPeriod, 
  596. /* Generated */                                              int    optInSlowPeriod, 
  597. /* Generated */                                              int    optInSignalPeriod_2,
  598. /* Generated */                                              [Out]int% outBegIdx,
  599. /* Generated */                                              [Out]int% outNBElement,
  600. /* Generated */                                              cli::array<double>^ outMACD,
  601. /* Generated */                                              cli::array<double>^ outMACDSignal,
  602. /* Generated */                                              cli::array<double>^ outMACDHist )
  603. /* Generated */ #elif defined( _JAVA )
  604. /* Generated */ RetCode TA_INT_MACD( int        startIdx,
  605. /* Generated */                      int        endIdx,
  606. /* Generated */                      INPUT_TYPE inReal[],
  607. /* Generated */                      int        optInFastPeriod, 
  608. /* Generated */                      int        optInSlowPeriod, 
  609. /* Generated */                      int        optInSignalPeriod_2,
  610. /* Generated */                      MInteger   outBegIdx,
  611. /* Generated */                      MInteger   outNBElement,
  612. /* Generated */                      double     outMACD[],
  613. /* Generated */                      double     outMACDSignal[],
  614. /* Generated */                      double     outMACDHist[] )
  615. /* Generated */ #else
  616. /* Generated */ TA_RetCode TA_PREFIX(INT_MACD)( int    startIdx,
  617. /* Generated */                                 int    endIdx,
  618. /* Generated */                                 const INPUT_TYPE inReal[],
  619. /* Generated */                                 int    optInFastPeriod, 
  620. /* Generated */                                 int    optInSlowPeriod, 
  621. /* Generated */                                 int    optInSignalPeriod_2,
  622. /* Generated */                                 int   *outBegIdx,
  623. /* Generated */                                 int   *outNBElement,
  624. /* Generated */                                 double       outMACD[],
  625. /* Generated */                                 double       outMACDSignal[],
  626. /* Generated */                                 double       outMACDHist[] )
  627. /* Generated */ #endif
  628. /* Generated */ {
  629. /* Generated */    ARRAY_REF(slowEMABuffer);
  630. /* Generated */    ARRAY_REF(fastEMABuffer);
  631. /* Generated */    double k1, k2;
  632. /* Generated */    ENUM_DECLARATION(RetCode) retCode;
  633. /* Generated */    int tempInteger;
  634. /* Generated */    VALUE_HANDLE_INT(outBegIdx1);
  635. /* Generated */    VALUE_HANDLE_INT(outNbElement1);
  636. /* Generated */    VALUE_HANDLE_INT(outBegIdx2);
  637. /* Generated */    VALUE_HANDLE_INT(outNbElement2);
  638. /* Generated */    int lookbackTotal, lookbackSignal;
  639. /* Generated */    int i;
  640. /* Generated */    if( optInSlowPeriod < optInFastPeriod )
  641. /* Generated */    {
  642. /* Generated */        tempInteger       = optInSlowPeriod;
  643. /* Generated */        optInSlowPeriod = optInFastPeriod;
  644. /* Generated */        optInFastPeriod = tempInteger;
  645. /* Generated */    }
  646. /* Generated */    if( optInSlowPeriod != 0 )
  647. /* Generated */       k1 = PER_TO_K(optInSlowPeriod);
  648. /* Generated */    else
  649. /* Generated */    {
  650. /* Generated */       optInSlowPeriod = 26;
  651. /* Generated */       k1 = (double)0.075; 
  652. /* Generated */    }
  653. /* Generated */    if( optInFastPeriod != 0 )
  654. /* Generated */       k2 = PER_TO_K(optInFastPeriod);
  655. /* Generated */    else
  656. /* Generated */    {
  657. /* Generated */       optInFastPeriod = 12;
  658. /* Generated */       k2 = (double)0.15; 
  659. /* Generated */    }
  660. /* Generated */    lookbackSignal = LOOKBACK_CALL(EMA)( optInSignalPeriod_2 ); 
  661. /* Generated */    lookbackTotal =  lookbackSignal;
  662. /* Generated */    lookbackTotal += LOOKBACK_CALL(EMA)( optInSlowPeriod );
  663. /* Generated */    if( startIdx < lookbackTotal )
  664. /* Generated */       startIdx = lookbackTotal;
  665. /* Generated */    if( startIdx > endIdx )
  666. /* Generated */    {
  667. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  668. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  669. /* Generated */       return ENUM_VALUE(RetCode,TA_SUCCESS,Success);
  670. /* Generated */    }
  671. /* Generated */    tempInteger = (endIdx-startIdx)+1+lookbackSignal;
  672. /* Generated */    ARRAY_ALLOC( fastEMABuffer, tempInteger );
  673. /* Generated */    #if !defined( _JAVA )
  674. /* Generated */       if( !fastEMABuffer )
  675. /* Generated */       {
  676. /* Generated */          VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  677. /* Generated */          VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  678. /* Generated */          return ENUM_VALUE(RetCode,TA_ALLOC_ERR,AllocErr);
  679. /* Generated */       }
  680. /* Generated */    #endif
  681. /* Generated */    ARRAY_ALLOC( slowEMABuffer, tempInteger );
  682. /* Generated */    #if !defined( _JAVA )
  683. /* Generated */       if( !slowEMABuffer )
  684. /* Generated */       {
  685. /* Generated */          VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  686. /* Generated */          VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  687. /* Generated */          ARRAY_FREE( fastEMABuffer );
  688. /* Generated */          return ENUM_VALUE(RetCode,TA_ALLOC_ERR,AllocErr);
  689. /* Generated */       }
  690. /* Generated */    #endif
  691. /* Generated */    tempInteger = startIdx-lookbackSignal;
  692. /* Generated */    retCode = FUNCTION_CALL(INT_EMA)( tempInteger, endIdx,
  693. /* Generated */                                      inReal, optInSlowPeriod, k1,
  694. /* Generated */                                      VALUE_HANDLE_OUT(outBegIdx1), VALUE_HANDLE_OUT(outNbElement1), slowEMABuffer );
  695. /* Generated */    if( retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success) )
  696. /* Generated */    {
  697. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  698. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  699. /* Generated */       ARRAY_FREE( fastEMABuffer );
  700. /* Generated */       ARRAY_FREE( slowEMABuffer );
  701. /* Generated */       return retCode;
  702. /* Generated */    }
  703. /* Generated */    retCode = FUNCTION_CALL(INT_EMA)( tempInteger, endIdx,
  704. /* Generated */                                      inReal, optInFastPeriod, k2,
  705. /* Generated */                                      VALUE_HANDLE_OUT(outBegIdx2), VALUE_HANDLE_OUT(outNbElement2), fastEMABuffer );
  706. /* Generated */    if( retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success) )
  707. /* Generated */    {
  708. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  709. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  710. /* Generated */       ARRAY_FREE( fastEMABuffer );
  711. /* Generated */       ARRAY_FREE( slowEMABuffer );
  712. /* Generated */       return retCode;
  713. /* Generated */    }
  714. /* Generated */    if( (VALUE_HANDLE_GET(outBegIdx1) != tempInteger) || 
  715. /* Generated */        (VALUE_HANDLE_GET(outBegIdx2) != tempInteger) || 
  716. /* Generated */        (VALUE_HANDLE_GET(outNbElement1) != VALUE_HANDLE_GET(outNbElement2)) ||
  717. /* Generated */        (VALUE_HANDLE_GET(outNbElement1) != (endIdx-startIdx)+1+lookbackSignal) )
  718. /* Generated */    {
  719. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  720. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  721. /* Generated */       ARRAY_FREE( fastEMABuffer );
  722. /* Generated */       ARRAY_FREE( slowEMABuffer );
  723. /* Generated */       return TA_INTERNAL_ERROR(119);
  724. /* Generated */    }
  725. /* Generated */    for( i=0; i < VALUE_HANDLE_GET(outNbElement1); i++ )
  726. /* Generated */       fastEMABuffer[i] = fastEMABuffer[i] - slowEMABuffer[i];
  727. /* Generated */    ARRAY_MEMMOVE( outMACD, 0, fastEMABuffer, lookbackSignal, (endIdx-startIdx)+1 );
  728. /* Generated */    retCode = FUNCTION_CALL_DOUBLE(INT_EMA)( 0, VALUE_HANDLE_GET(outNbElement1)-1,
  729. /* Generated */                                             fastEMABuffer, optInSignalPeriod_2, PER_TO_K(optInSignalPeriod_2), 
  730. /* Generated */                                             VALUE_HANDLE_OUT(outBegIdx2), VALUE_HANDLE_OUT(outNbElement2), outMACDSignal );
  731. /* Generated */    ARRAY_FREE( fastEMABuffer );
  732. /* Generated */    ARRAY_FREE( slowEMABuffer );
  733. /* Generated */    if( retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success) )
  734. /* Generated */    {
  735. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outBegIdx);
  736. /* Generated */       VALUE_HANDLE_DEREF_TO_ZERO(outNBElement);
  737. /* Generated */       return retCode;
  738. /* Generated */    }
  739. /* Generated */    for( i=0; i < VALUE_HANDLE_GET(outNbElement2); i++ )
  740. /* Generated */       outMACDHist[i] = outMACD[i]-outMACDSignal[i];
  741. /* Generated */    VALUE_HANDLE_DEREF(outBegIdx)     = startIdx;
  742. /* Generated */    VALUE_HANDLE_DEREF(outNBElement)  = VALUE_HANDLE_GET(outNbElement2);
  743. /* Generated */    return ENUM_VALUE(RetCode,TA_SUCCESS,Success);
  744. /* Generated */ }
  745. /* Generated */ 
  746. /* Generated */ #if defined( _MANAGED )
  747. /* Generated */ }}} // Close namespace TicTacTec.TA.Lib
  748. /* Generated */ #endif
  下一部分，分析一下TA-LIB包

  
masterjames
关注
VC++6.0股票软件源代码
03-12
VC++6.0股票软件源代码，看看吧，很好的源代码.，一款很适合DIY的软件，基本上自己有什么想法都能通过修改该软件来实现，还需要花大力气重新开发一个吗？
用VC开发股票分析软件(四)
masterjames的专栏
10-06 6217
  K线已经绘制成功，下面要做一个分析软件的简单框架。新建三个VIEW。  第一个为CDataView，显示交易数据  第二个为CFormulaView,显示公式，将用到TA-LIB库文件  第三个为CKlineView，显示K线图  将窗口分成三份，左侧上方为CKlineView，下方为CFormulaView，右侧为CDataView  新建一个MFC MDI程序。  在ChildFrm.cp
股票交易系统开发，如何打造专属的个人股票交易系统
最新发布
股票量化交易自动交易程序化交易接口
10-04 975
个人股票交易系统的开发融合多方面知识与技能，涵盖技术分析、资金管理等。通过合理设计与不断优化，能提升交易成功率，帮助投资者在股市中获利。
简单的股票分时图 VC6.0实现
04-25
本程序用vc生成的MFC框架，再加上一些C++标准库的小知识综合而成。这是我做得第一个小程序，做得不太好，见笑了。
VC++开发股票软件
BruceWoo的专栏
02-05 6645
VC炒股软件开发 文档说明： 此文档适合VC++的初学者，高手也可参考（希望能提出宝贵意见）。   开发前准备： 这是一个根据股票信息的数据绘的几个制界面，数据来源通信达软件的数据文件，通常在安装了通信达以后并下载数据到本地以后就有了。 1.数据文件的准备： 假如你安装通信达的目录是：D:\jcb_gx。那么对应的数据文件就在D:\jcb_gx\vipdoc\目录下，里面每一个目录下
用VC开发股票分析软件(二)
masterjames的专栏
09-26 5870
TA_Real    closePrice[400];TA_Real    out[400];TA_Integer outBeg;TA_Integer outNbElement;这是定义参数的地方int main(int argc, char* argv[]){    /* The output is displayed here */   for(int j=0;j   {       clos
股票软件源代码.zip
06-01
股票软件源代码.zip是一个包含股票分析软件开发相关源代码的压缩包。该软件设计类似知名的股票分析工具“分析家”和“大智慧”，提供了一个指标编写平台，支持筹码分布等功能，这表明它具有深度的数据分析和自定义...
NetTS.rar_C++ 股票 接收_VC股票软件_netts_vc 股票_股票 接收
07-15
这个软件可能是用于接收实时证券行情数据，并且它在Visual C++（VC）环境下开发，可能包含了一个名为“netts”的组件或类库，专门处理股票相关的数据接收。 描述中的“接收证券行情数据接口的VC源代码”意味着这个...
股市分析代码所需要用的工具VC6.0之win10通用版
01-28
本文将详细探讨“股市分析代码所需要用的工具VC6.0之win10通用版”，帮助读者理解如何在Windows 10操作系统上利用Visual C++ 6.0（简称VC6.0）这一经典编译器进行股票分析代码的编写。 Visual C++ 6.0是微软公司...
vc6.0---股票客户端源代码.
02-01
【VC6.0---股票客户端源代码】是一个与软件开发相关的知识主题，主要涉及的是使用Microsoft Visual C++ 6.0（简称VC6.0）编程环境开发的股票交易客户端程序。VC6.0是微软在20世纪末发布的一款经典集成开发环境，尤其...
基于macd、kdj、ma技术指标分析股票多空方向——应用开发3 计算股票相关技术指标数据
m0_64902855的博客
01-18 2557
接上一节，我们获取了000001.SZ股票过去一年的历史数据stock_df，接下来我们就计算技术指标 所用包 pandas_ta import pandas_ta as ta 关于pandas_ta 可以在GitHub - twopirllc/pandas-ta: Technical Analysis Indicators - Pandas TA is an easy to use Python 3 Pandas Extension with 130+ Indicators这里了解更多...
VC 机器人编程
09-21
vc的机器人编程
股票分析软件dll函数编程规范
11-22
分析家、大智慧、通达信的dll函数编程规范，用于扩展股票分析软件的技术指标或选股公式。
mytrader-开源股票期货金融软件+支持C/C++/Python/Excel/VBA/麦语言的量化分析交易平台
热门推荐
章志强的专栏
10-15 2万+
基于XSocket、mdb、zq构建端到端高性能可视化量化分析交易系统 包含服务器、客户端，支持多种部署模式，可以BS模式、CS模式、单机模式等 支持Excel/VBA/Python/C/C++开发
炒股笔记C++开发套件介绍
C++ 爱好者 make_it_simple888
06-04 910
有C++基础，或者Qt基础；以研究代码和股票为乐趣的；沪深两市个股与指数历史数据下载更新；炒股笔记软件：记录笔记，查看K线；自己实现C++投资算法验证自己的投资思路；
股市编辑器常用函数说明
Venus 的博客
12-11 2877
板块函数： 1、板块平均：求板块里某一数据项的平均值。 用法：BLOCKAVG(&N),N表示选择的数据项。例如：BLOCKAVG(&NEW)表示这个板块里所有股票当前时刻的平均价。 2、板块最小值：求板块里某一数据项的最小值。 用法：BLOCKMIN(&N)，N表示选择的数据项。例如：BLOCKMIN(&LOW)表示这个板块里所有股票当天的最低价。 3、板块最大值：求板块里某一数据项的最大值。 用法：BLOCKMAX(&N)，N表示选择的数据项。例如：B
python 获取macd数据_如何通过MACD函数获取MACD的5分钟对应值
weixin_39834205的博客
12-08 1936
如何通过MACD函数获取MACD的5分钟对应值如何通过MACD函数获取MACD的5分钟对应值Author: only油, Created: 2018-03-01 10:28:37, Updated:var records = exchange.GetRecords(PERIOD_M5);.var macd = TA.MACD(records, 12, 26, 9);Log(“DIF:”, macd...
c++编写更高效的股票系统
cjh4312的博客
04-16 4273
看盘的主界面上分了4大块区域（个人习惯），一个显示所有股票的实时数据，一个只显示涨速，一个自选股，最右边显示个股的详细信息，包括分时图，买卖一到五及其分笔成交细节。A股，美股，港股全部都使用同样的数据结构，这样可以很方便界面的切换。有强迫症的我觉得必须qt重写，整体界面基本和python一样的，那效率真是不可同日而语。重载鼠标的单击和双击，单击显示个股详细信息，双击显示个股的k线图。前面用python写的，总觉效率不高，虽然运行也还是能行。F10资料，主要指标，经营分析，3大报表，板块资金流。
ta-lib 源码简单分析
陆多多的专栏
06-02 3912
ta-lib的源码比较简单，重要的类就那么几个，如下: 类功能介绍 Core 指标分析实现的地方，类行数很多，ta-lib的核心 包含一些特性设置和功能实现，以macd为例，包含macdLookback,macd,macdExtLookback,macdExt,macdFixLookback,macdFix等实现。 可以发现，这些方法和参数都是有规律的。 macd指标实现方法为macd...
VC开发LED字模提取软件介绍
VC即Visual C++，是微软公司推出的一款集成开发环境（IDE），主要用于C/C++语言的程序开发。VC提供了丰富的库函数和工具，使得开发者可以方便地创建复杂的Windows应用程序。 4. 源码修改： 开发者在使用源码时，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值