int TA_STOCH_Lookback( TA_Integer optInFastK_Period_0, /* From 1 to TA_INTEGER_MAX */
TA_Integer optInSlowK_Period_1, /* From 1 to TA_INTEGER_MAX */
TA_MAType optInSlowK_MAType_2,
TA_Integer optInSlowD_Period_3, /* From 1 to TA_INTEGER_MAX */
TA_MAType optInSlowD_MAType_4 )
/**** END GENCODE SECTION 1 - DO NOT DELETE THIS LINE ****/
{
/* insert lookback code here. */
int retValue;
/* Account for the initial data needed for Fast-K. */
retValue = (optInFastK_Period_0 - 1);
/* Add the smoothing being done for %K slow */
retValue += TA_MA_Lookback( optInSlowK_Period_1, optInSlowK_MAType_2 );
/* Add the smoothing being done for %D slow. */
retValue += TA_MA_Lookback( optInSlowD_Period_3, optInSlowD_MAType_4 );
return retValue;
}
/* Generated */ TA_RetCode TA_S_STOCHF( int startIdx,
/* Generated */ int endIdx,
/* Generated */ const float inHigh_0[],
/* Generated */ const float inLow_0[],
/* Generated */ const float inClose_0[],
/* Generated */ int optInFastK_Period_0, /* From 1 to 100000 */
/* Generated */ int optInFastD_Period_1, /* From 1 to 100000 */
/* Generated */ TA_MAType optInFastD_MAType_2,
/* Generated */ int *outBegIdx,
/* Generated */ int *outNbElement,
/* Generated */ double outFastK_0[],
/* Generated */ double outFastD_1[] )
/* Generated */ #endif
/* Generated */ {
/* Generated */ TA_RetCode retCode;
/* Generated */ double lowest, highest, tmp, diff;
/* Generated */ ARRAY_REF( tempBuffer );
/* Generated */ int outIdx, lowestIdx, highestIdx;
/* Generated */ int lookbackTotal, lookbackK, lookbackFastD;
/* Generated */ int trailingIdx, today, i;
/* Generated */ #if !defined( _MANAGED ) && !defined(USE_SINGLE_PRECISION_INPUT)
/* Generated */ int bufferIsAllocated;
/* Generated */ #endif
/* Generated */ #ifndef TA_FUNC_NO_RANGE_CHECK
/* Generated */ if( startIdx < 0 )
/* Generated */ return TA_OUT_OF_RANGE_START_INDEX;
/* Generated */ if( (endIdx < 0) || (endIdx < startIdx))
/* Generated */ return TA_OUT_OF_RANGE_END_INDEX;
/* Generated */ if(!inHigh_0||!inLow_0||!inClose_0)
/* Generated */ return TA_BAD_PARAM;
/* Generated */ if( (int)optInFastK_Period_0 == TA_INTEGER_DEFAULT )
/* Generated */ optInFastK_Period_0 = 5;
/* Generated */ else if( ((int)optInFastK_Period_0 < 1) || ((int)optInFastK_Period_0 > 100000) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ if( (int)optInFastD_Period_1 == TA_INTEGER_DEFAULT )
/* Generated */ optInFastD_Period_1 = 3;
/* Generated */ else if( ((int)optInFastD_Period_1 < 1) || ((int)optInFastD_Period_1 > 100000) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #if !defined(_MANAGED)
/* Generated */ if( (int)optInFastD_MAType_2 == TA_INTEGER_DEFAULT )
/* Generated */ optInFastD_MAType_2 = 0;
/* Generated */ else if( ((int)optInFastD_MAType_2 < 0) || ((int)optInFastD_MAType_2 > 8) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #endif
/* Generated */ if( outFastK_0 == NULL )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ if( outFastD_1 == NULL )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #endif
/* Generated */ lookbackK = optInFastK_Period_0-1;
/* Generated */ lookbackFastD = TA_MA_Lookback( optInFastD_Period_1, optInFastD_MAType_2 );
/* Generated */ lookbackTotal = lookbackK + lookbackFastD;
/* Generated */ if( startIdx < lookbackTotal )
/* Generated */ startIdx = lookbackTotal;
/* Generated */ if( startIdx > endIdx )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ return TA_SUCCESS;
/* Generated */ }
/* Generated */ outIdx = 0;
/* Generated */ trailingIdx = startIdx-lookbackTotal;
/* Generated */ today = trailingIdx+lookbackK;
/* Generated */ lowestIdx = highestIdx = -1;
/* Generated */ diff = highest = lowest = 0.0;
/* Generated */ #if !defined( _MANAGED ) && !defined(USE_SINGLE_PRECISION_INPUT)
/* Generated */ bufferIsAllocated = 0;
/* Generated */ #endif
/* Generated */ #if defined(USE_SINGLE_PRECISION_INPUT)
/* Generated */ ARRAY_ALLOC( tempBuffer, endIdx-today+1 );
/* Generated */ #else
/* Generated */ if( (outFastK_0 == inHigh_0) ||
/* Generated */ (outFastK_0 == inLow_0) ||
/* Generated */ (outFastK_0 == inClose_0) )
/* Generated */ {
/* Generated */ tempBuffer = outFastK_0;
/* Generated */ }
/* Generated */ else if( (outFastD_1 == inHigh_0) ||
/* Generated */ (outFastD_1 == inLow_0) ||
/* Generated */ (outFastD_1 == inClose_0) )
/* Generated */ {
/* Generated */ tempBuffer = outFastD_1;
/* Generated */ }
/* Generated */ else
/* Generated */ {
/* Generated */ #if !defined( _MANAGED )
/* Generated */ bufferIsAllocated = 1;
/* Generated */ #endif
/* Generated */ ARRAY_ALLOC(tempBuffer, endIdx-today+1 );
/* Generated */ }
/* Generated */ #endif
/* Generated */ while( today <= endIdx )
/* Generated */ {
/* Generated */ tmp = inLow_0[today];
/* Generated */ if( lowestIdx < trailingIdx )
/* Generated */ {
/* Generated */ lowestIdx = trailingIdx;
/* Generated */ lowest = inLow_0[lowestIdx];
/* Generated */ i = lowestIdx;
/* Generated */ while( ++i<=today )
/* Generated */ {
/* Generated */ tmp = inLow_0[i];
/* Generated */ if( tmp < lowest )
/* Generated */ {
/* Generated */ lowestIdx = i;
/* Generated */ lowest = tmp;
/* Generated */ }
/* Generated */ }
/* Generated */ diff = (highest - lowest)/100.0;
/* Generated */ }
/* Generated */ else if( tmp <= lowest )
/* Generated */ {
/* Generated */ lowestIdx = today;
/* Generated */ lowest = tmp;
/* Generated */ diff = (highest - lowest)/100.0;
/* Generated */ }
/* Generated */ tmp = inHigh_0[today];
/* Generated */ if( highestIdx < trailingIdx )
/* Generated */ {
/* Generated */ highestIdx = trailingIdx;
/* Generated */ highest = inHigh_0[highestIdx];
/* Generated */ i = highestIdx;
/* Generated */ while( ++i<=today )
/* Generated */ {
/* Generated */ tmp = inHigh_0[i];
/* Generated */ if( tmp > highest )
/* Generated */ {
/* Generated */ highestIdx = i;
/* Generated */ highest = tmp;
/* Generated */ }
/* Generated */ }
/* Generated */ diff = (highest - lowest)/100.0;
/* Generated */ }
/* Generated */ else if( tmp >= highest )
/* Generated */ {
/* Generated */ highestIdx = today;
/* Generated */ highest = tmp;
/* Generated */ diff = (highest - lowest)/100.0;
/* Generated */ }
/* Generated */ if( diff != 0.0 )
/* Generated */ tempBuffer[outIdx++] = (inClose_0[today]-lowest)/diff;
/* Generated */ else
/* Generated */ tempBuffer[outIdx++] = 0.0;
/* Generated */ trailingIdx++;
/* Generated */ today++;
/* Generated */ }
/* Generated */ retCode = TA_MA( 0, outIdx-1,
/* Generated */ tempBuffer, optInFastD_Period_1,
/* Generated */ optInFastD_MAType_2,
/* Generated */ outBegIdx, outNbElement, outFastD_1 );
/* Generated */ if( (retCode != TA_SUCCESS) || (*outNbElement == 0) )
/* Generated */ {
/* Generated */ #if defined(USE_SINGLE_PRECISION_INPUT)
/* Generated */ ARRAY_FREE( tempBuffer );
/* Generated */ #else
/* Generated */ ARRAY_FREE_COND( bufferIsAllocated, tempBuffer );
/* Generated */ #endif
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ return retCode;
/* Generated */ }
/* Generated */ ARRAY_MEMMOVE( outFastK_0, 0, tempBuffer, lookbackFastD, *outNbElement );
/* Generated */ #if defined(USE_SINGLE_PRECISION_INPUT)
/* Generated */ ARRAY_FREE( tempBuffer );
/* Generated */ #else
/* Generated */ ARRAY_FREE_COND( bufferIsAllocated, tempBuffer );
/* Generated */ #endif
/* Generated */ if( retCode != TA_SUCCESS )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ return retCode;
/* Generated */ }
/* Generated */ *outBegIdx = startIdx;
/* Generated */ return TA_SUCCESS;
/* Generated */ }
/* Generated */ TA_RetCode TA_S_MACDEXT( int startIdx,
/* Generated */ int endIdx,
/* Generated */ const float inReal[],
/* Generated */ int optInFastPeriod, /* From 2 to 100000 */
/* Generated */ TA_MAType optInFastMAType,
/* Generated */ int optInSlowPeriod, /* From 2 to 100000 */
/* Generated */ TA_MAType optInSlowMAType,
/* Generated */ int optInSignalPeriod, /* From 1 to 100000 */
/* Generated */ TA_MAType optInSignalMAType,
/* Generated */ int *outBegIdx,
/* Generated */ int *outNbElement,
/* Generated */ double outMACD[],
/* Generated */ double outMACDSignal[],
/* Generated */ double outMACDHist[] )
/* Generated */ #endif
/* Generated */ {
/* Generated */ ARRAY_REF( slowMABuffer );
/* Generated */ ARRAY_REF( fastMABuffer );
/* Generated */ TA_RetCode retCode;
/* Generated */ int tempInteger, outBegIdx1, outNbElement1;
/* Generated */ int outBegIdx2, outNbElement2;
/* Generated */ int lookbackTotal, lookbackSignal, lookbackLargest;
/* Generated */ int i;
/* Generated */ TA_MAType tempMAType;
/* Generated */ #ifndef TA_FUNC_NO_RANGE_CHECK
/* Generated */ if( startIdx < 0 )
/* Generated */ return TA_OUT_OF_RANGE_START_INDEX;
/* Generated */ if( (endIdx < 0) || (endIdx < startIdx))
/* Generated */ return TA_OUT_OF_RANGE_END_INDEX;
/* Generated */ if( !inReal ) return TA_BAD_PARAM;
/* Generated */ if( (int)optInFastPeriod == TA_INTEGER_DEFAULT )
/* Generated */ optInFastPeriod = 12;
/* Generated */ else if( ((int)optInFastPeriod < 2) || ((int)optInFastPeriod > 100000) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #if !defined(_MANAGED)
/* Generated */ if( (int)optInFastMAType == TA_INTEGER_DEFAULT )
/* Generated */ optInFastMAType = 0;
/* Generated */ else if( ((int)optInFastMAType < 0) || ((int)optInFastMAType > 8) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #endif
/* Generated */ if( (int)optInSlowPeriod == TA_INTEGER_DEFAULT )
/* Generated */ optInSlowPeriod = 26;
/* Generated */ else if( ((int)optInSlowPeriod < 2) || ((int)optInSlowPeriod > 100000) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #if !defined(_MANAGED)
/* Generated */ if( (int)optInSlowMAType == TA_INTEGER_DEFAULT )
/* Generated */ optInSlowMAType = 0;
/* Generated */ else if( ((int)optInSlowMAType < 0) || ((int)optInSlowMAType > 8) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #endif
/* Generated */ if( (int)optInSignalPeriod == TA_INTEGER_DEFAULT )
/* Generated */ optInSignalPeriod = 9;
/* Generated */ else if( ((int)optInSignalPeriod < 1) || ((int)optInSignalPeriod > 100000) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #if !defined(_MANAGED)
/* Generated */ if( (int)optInSignalMAType == TA_INTEGER_DEFAULT )
/* Generated */ optInSignalMAType = 0;
/* Generated */ else if( ((int)optInSignalMAType < 0) || ((int)optInSignalMAType > 8) )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #endif
/* Generated */ if( outMACD == NULL )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ if( outMACDSignal == NULL )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ if( outMACDHist == NULL )
/* Generated */ return TA_BAD_PARAM;
/* Generated */ #endif
/* Generated */ if( optInSlowPeriod < optInFastPeriod )
/* Generated */ {
/* Generated */ tempInteger = optInSlowPeriod;
/* Generated */ optInSlowPeriod = optInFastPeriod;
/* Generated */ optInFastPeriod = tempInteger;
/* Generated */ tempMAType = optInSlowMAType;
/* Generated */ optInSlowMAType = optInFastMAType;
/* Generated */ optInFastMAType = tempMAType;
/* Generated */ }
/* Generated */ lookbackLargest = TA_MA_Lookback( optInFastPeriod, optInFastMAType );
/* Generated */ tempInteger = TA_MA_Lookback( optInSlowPeriod, optInSlowMAType );
/* Generated */ if( tempInteger > lookbackLargest )
/* Generated */ lookbackLargest = tempInteger;
/* Generated */ lookbackSignal = TA_MA_Lookback( optInSignalPeriod, optInSignalMAType );
/* Generated */ lookbackTotal = lookbackSignal+lookbackLargest;
/* Generated */ if( startIdx < lookbackTotal )
/* Generated */ startIdx = lookbackTotal;
/* Generated */ if( startIdx > endIdx )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ return TA_SUCCESS;
/* Generated */ }
/* Generated */ tempInteger = (endIdx-startIdx)+1+lookbackSignal;
/* Generated */ ARRAY_ALLOC( fastMABuffer, tempInteger );
/* Generated */ if( !fastMABuffer )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ return TA_ALLOC_ERR;
/* Generated */ }
/* Generated */ ARRAY_ALLOC( slowMABuffer, tempInteger );
/* Generated */ if( !slowMABuffer )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ ARRAY_FREE( fastMABuffer );
/* Generated */ return TA_ALLOC_ERR;
/* Generated */ }
/* Generated */ tempInteger = startIdx-lookbackSignal;
/* Generated */ retCode = TA_PREFIX(MA)( tempInteger, endIdx,
/* Generated */ inReal, optInSlowPeriod, optInSlowMAType,
/* Generated */ &outBegIdx1, &outNbElement1, slowMABuffer );
/* Generated */ if( retCode != TA_SUCCESS )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ ARRAY_FREE( fastMABuffer );
/* Generated */ ARRAY_FREE( slowMABuffer );
/* Generated */ return retCode;
/* Generated */ }
/* Generated */ retCode = TA_PREFIX(MA)( tempInteger, endIdx,
/* Generated */ inReal, optInFastPeriod, optInFastMAType,
/* Generated */ &outBegIdx2, &outNbElement2, fastMABuffer );
/* Generated */ if( retCode != TA_SUCCESS )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ ARRAY_FREE( fastMABuffer );
/* Generated */ ARRAY_FREE( slowMABuffer );
/* Generated */ return retCode;
/* Generated */ }
/* Generated */ if( (outBegIdx1 != tempInteger) ||
/* Generated */ (outBegIdx2 != tempInteger) ||
/* Generated */ (outNbElement1 != outNbElement2) ||
/* Generated */ (outNbElement1 != (endIdx-startIdx)+1+lookbackSignal) )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ ARRAY_FREE( fastMABuffer );
/* Generated */ ARRAY_FREE( slowMABuffer );
/* Generated */ return TA_INTERNAL_ERROR(119);
/* Generated */ }
/* Generated */ for( i=0; i < outNbElement1; i++ )
/* Generated */ fastMABuffer[i] = fastMABuffer[i] - slowMABuffer[i];
/* Generated */ ARRAY_MEMMOVE( outMACD, 0, fastMABuffer, lookbackSignal, (endIdx-startIdx)+1 );
/* Generated */ retCode = TA_MA( 0, outNbElement1-1,
/* Generated */ fastMABuffer, optInSignalPeriod, optInSignalMAType,
/* Generated */ &outBegIdx2, &outNbElement2, outMACDSignal );
/* Generated */ ARRAY_FREE( fastMABuffer );
/* Generated */ ARRAY_FREE( slowMABuffer );
/* Generated */ if( retCode != TA_SUCCESS )
/* Generated */ {
/* Generated */ *outBegIdx = 0;
/* Generated */ *outNbElement = 0;
/* Generated */ return retCode;
/* Generated */ }
/* Generated */ for( i=0; i < outNbElement2; i++ )
/* Generated */ outMACDHist[i] = outMACD[i]-outMACDSignal[i];
/* Generated */ *outBegIdx = startIdx;
/* Generated */ *outNbElement = outNbElement2;
/* Generated */ return TA_SUCCESS;
/* Generated */ }
static ErrorNumber do_test_ma( const TA_History *history,
const TA_Test *test )
{
TA_RetCode retCode;
ErrorNumber errNb;
TA_Integer outBegIdx;
TA_Integer outNbElement;
TA_RangeTestParam testParam;
TA_Integer temp, temp2;
const TA_Real *referenceInput;
TA_SetCompatibility( test->compatibility );
/* Set to NAN all the elements of the gBuffers. */
clearAllBuffers();
/* Build the input. */
setInputBuffer( 0, history->close, history->nbBars );
setInputBuffer( 1, history->close, history->nbBars );
/* Re-initialize all the unstable period to zero. */
TA_SetUnstablePeriod( TA_FUNC_UNST_ALL, 0 );
/* Set the unstable period requested for that test. */
switch( test->optInMAType_1 )
{
case TA_MAType_TEMA:
case TA_MAType_DEMA:
case TA_MAType_EMA:
retCode = TA_SetUnstablePeriod( TA_FUNC_UNST_EMA, test->unstablePeriod );
break;
case TA_MAType_KAMA:
retCode = TA_SetUnstablePeriod( TA_FUNC_UNST_KAMA, test->unstablePeriod );
break;
case TA_MAType_MAMA:
retCode = TA_SetUnstablePeriod( TA_FUNC_UNST_MAMA, test->unstablePeriod );
break;
case TA_MAType_T3:
retCode = TA_SetUnstablePeriod( TA_FUNC_UNST_T3, test->unstablePeriod );
break;
default:
retCode = TA_SUCCESS;
break;
}
if( retCode != TA_SUCCESS )
return TA_TEST_TFRR_SETUNSTABLE_PERIOD_FAIL;
/* Transform the inputs for MAMA (it is an AVGPRICE in John Ehlers book). */
if( test->optInMAType_1 == TA_MAType_MAMA )
{
TA_MEDPRICE( 0, history->nbBars-1, history->high, history->low,
&outBegIdx, &outNbElement, gBuffer[0].in );
TA_MEDPRICE( 0, history->nbBars-1, history->high, history->low,
&outBegIdx, &outNbElement, gBuffer[1].in );
/* Will be use as reference */
TA_MEDPRICE( 0, history->nbBars-1, history->high, history->low,
&outBegIdx, &outNbElement, gBuffer[2].in );
referenceInput = gBuffer[2].in;
}
else
referenceInput = history->close;
/* Make a simple first call. */
switch( test->id )
{
case TA_ANY_MA_TEST:
retCode = TA_MA( test->startIdx,
test->endIdx,
gBuffer[0].in,
test->optInTimePeriod_0,
test->optInMAType_1,
&outBegIdx,
&outNbElement,
gBuffer[0].out0 );
break;
case TA_MAMA_TEST:
retCode = TA_MAMA( test->startIdx,
test->endIdx,
gBuffer[0].in,
0.5, 0.05,
&outBegIdx,
&outNbElement,
gBuffer[0].out0,
gBuffer[0].out2 );
break;
case TA_FAMA_TEST:
retCode = TA_MAMA( test->startIdx,
test->endIdx,
gBuffer[0].in,
0.5, 0.05,
&outBegIdx,
&outNbElement,
gBuffer[0].out2,
gBuffer[0].out0 );
break;
}
errNb = checkDataSame( gBuffer[0].in, referenceInput, history->nbBars );
if( errNb != TA_TEST_PASS )
return errNb;
errNb = checkExpectedValue( gBuffer[0].out0,
retCode, test->expectedRetCode,
outBegIdx, test->expectedBegIdx,
outNbElement, test->expectedNbElement,
test->oneOfTheExpectedOutReal,
test->oneOfTheExpectedOutRealIndex );
if( errNb != TA_TEST_PASS )
return errNb;
outBegIdx = outNbElement = 0;
/* Make another call where the input and the output are the
* same buffer.
*/
switch( test->id )
{
case TA_ANY_MA_TEST:
retCode = TA_MA( test->startIdx,
test->endIdx,
gBuffer[1].in,
test->optInTimePeriod_0,
test->optInMAType_1,
&outBegIdx,
&outNbElement,
gBuffer[1].in );
break;
case TA_MAMA_TEST:
retCode = TA_MAMA( test->startIdx,
test->endIdx,
gBuffer[1].in,
0.5, 0.05,
&outBegIdx,
&outNbElement,
gBuffer[1].in,
gBuffer[0].out2 );
break;
case TA_FAMA_TEST:
retCode = TA_MAMA( test->startIdx,
test->endIdx,
gBuffer[1].in,
0.5, 0.05,
&outBegIdx,
&outNbElement,
gBuffer[0].out2,
gBuffer[1].in );
break;
}
/* The previous call to TA_MA should have the same output
* as this call.
*
* checkSameContent verify that all value different than NAN in
* the first parameter is identical in the second parameter.
*/
errNb = checkSameContent( gBuffer[0].out0, gBuffer[1].in );
if( errNb != TA_TEST_PASS )
return errNb;
errNb = checkExpectedValue( gBuffer[1].in,
retCode, test->expectedRetCode,
outBegIdx, test->expectedBegIdx,
outNbElement, test->expectedNbElement,
test->oneOfTheExpectedOutReal,
test->oneOfTheExpectedOutRealIndex );
if( errNb != TA_TEST_PASS )
return errNb;
/* Verify that the "all-purpose" TA_MA_Lookback is consistent
* with the corresponding moving average lookback function.
*/
switch( test->optInMAType_1 )
{
case TA_MAType_WMA:
temp = TA_WMA_Lookback( test->optInTimePeriod_0 );
break;
case TA_MAType_SMA:
temp = TA_SMA_Lookback( test->optInTimePeriod_0 );
break;
case TA_MAType_EMA:
temp = TA_EMA_Lookback( test->optInTimePeriod_0 );
break;
case TA_MAType_DEMA:
temp = TA_DEMA_Lookback( test->optInTimePeriod_0 );
break;
case TA_MAType_TEMA:
temp = TA_TEMA_Lookback( test->optInTimePeriod_0 );
break;
case TA_MAType_KAMA:
temp = TA_KAMA_Lookback( test->optInTimePeriod_0 );
break;
case TA_MAType_MAMA:
temp = TA_MAMA_Lookback( 0.5, 0.05 );
break;
case TA_MAType_TRIMA:
temp = TA_TRIMA_Lookback( test->optInTimePeriod_0 );
break;
case TA_MAType_T3:
temp = TA_T3_Lookback( test->optInTimePeriod_0, 0.7 );
break;
default:
return TA_TEST_TFRR_BAD_MA_TYPE;
}
temp2 = TA_MA_Lookback( test->optInTimePeriod_0, test->optInMAType_1 );
if( temp != temp2 )
return TA_TEST_TFFR_BAD_MA_LOOKBACK;
/* Do a systematic test of most of the
* possible startIdx/endIdx range.
*/
testParam.test = test;
testParam.close = referenceInput;
if( test->doRangeTestFlag )
{
switch( test->optInMAType_1 )
{
case TA_MAType_TEMA:
case TA_MAType_DEMA:
case TA_MAType_EMA:
errNb = doRangeTest( rangeTestFunction,
TA_FUNC_UNST_EMA,
(void *)&testParam, 1, 0 );
break;
case TA_MAType_T3:
errNb = doRangeTest( rangeTestFunction,
TA_FUNC_UNST_T3,
(void *)&testParam, 1, 0 );
break;
case TA_MAType_KAMA:
errNb = doRangeTest( rangeTestFunction,
TA_FUNC_UNST_KAMA,
(void *)&testParam, 1, 0 );
break;
case TA_MAType_MAMA:
errNb = doRangeTest( rangeTestFunction,
TA_FUNC_UNST_MAMA,
(void *)&testParam, 2, 0 );
break;
default:
errNb = doRangeTest( rangeTestFunction,
TA_FUNC_UNST_NONE,
(void *)&testParam, 1, 0 );
}
if( errNb != TA_TEST_PASS )
return errNb;
}
return TA_TEST_PASS;
}
/**** Local functions definitions. ****/
static TA_RetCode rangeTestFunction(
TA_Integer startIdx,
TA_Integer endIdx,
TA_Real *outputBuffer,
TA_Integer *outBegIdx,
TA_Integer *outNbElement,
TA_Integer *lookback,
void *opaqueData,
unsigned int outputNb )
{
TA_RetCode retCode;
TA_RangeTestParam *testParam;
TA_Real *dummyBuffer;
testParam = (TA_RangeTestParam *)opaqueData;
switch( testParam->test->optInMAType_1 )
{
case TA_MAType_MAMA:
dummyBuffer = TA_Malloc( sizeof(TA_Real)*(endIdx-startIdx+600) );
if( outputNb == 0 )
{
retCode = TA_MAMA( startIdx,
endIdx,
testParam->close,
0.5, 0.05,
outBegIdx,
outNbElement,
outputBuffer,
&dummyBuffer[300] );
}
else
{
retCode = TA_MAMA( startIdx,
endIdx,
testParam->close,
0.5, 0.05,
outBegIdx,
outNbElement,
&dummyBuffer[300],
outputBuffer );
}
TA_Free( dummyBuffer );
*lookback = TA_MAMA_Lookback( 0.5, 0.05 );
break;
default:
/* Test for the TA_MA function. All the MA can be done
* through that function.
*/
retCode = TA_MA( startIdx,
endIdx,
testParam->close,
testParam->test->optInTimePeriod_0,
testParam->test->optInMAType_1,
outBegIdx,
outNbElement,
outputBuffer );
*lookback = TA_MA_Lookback( testParam->test->optInTimePeriod_0,
testParam->test->optInMAType_1 );
break;
}
return retCode;
}
TA_RetCode TA_STOCH( TA_Integer startIdx,
TA_Integer endIdx,
const TA_Real inHigh_0[],
const TA_Real inLow_0[],
const TA_Real inClose_0[],
TA_Integer optInFastK_Period_0, /* From 1 to TA_INTEGER_MAX */
TA_Integer optInSlowK_Period_1, /* From 1 to TA_INTEGER_MAX */
TA_MAType optInSlowK_MAType_2,
TA_Integer optInSlowD_Period_3, /* From 1 to TA_INTEGER_MAX */
TA_MAType optInSlowD_MAType_4,
TA_Integer *outBegIdx,
TA_Integer *outNbElement,
TA_Real outSlowK_0[],
TA_Real outSlowD_1[] )
/**** END GENCODE SECTION 2 - DO NOT DELETE THIS LINE ****/
{
/* Insert local variables here. */
TA_RetCode retCode;
TA_Real lowest, highest, tmp, diff;
TA_Real *tempBuffer;
TA_Integer outIdx, lowestIdx, highestIdx;
TA_Integer lookbackTotal, lookbackK, lookbackKSlow, lookbackDSlow;
TA_Integer trailingIdx, today, i, bufferIsAllocated;
/**** START GENCODE SECTION 3 - DO NOT DELETE THIS LINE ****/
#ifndef TA_FUNC_NO_RANGE_CHECK
/* Validate the requested output range. */
if( startIdx < 0 )
return TA_OUT_OF_RANGE_START_INDEX;
if( (endIdx < 0) || (endIdx < startIdx))
return TA_OUT_OF_RANGE_END_INDEX;
/* Validate the parameters. */
/* Verify required price component. */
if(!inHigh_0||!inLow_0||!inClose_0)
return TA_BAD_PARAM;
/* min/max are checked for optInFastK_Period_0. */
if( (TA_Integer)optInFastK_Period_0 == TA_INTEGER_DEFAULT )
optInFastK_Period_0 = 5;
else if( ((TA_Integer)optInFastK_Period_0 < 1) || ((TA_Integer)optInFastK_Period_0 > 2147483647) )
return TA_BAD_PARAM;
/* min/max are checked for optInSlowK_Period_1. */
if( (TA_Integer)optInSlowK_Period_1 == TA_INTEGER_DEFAULT )
optInSlowK_Period_1 = 3;
else if( ((TA_Integer)optInSlowK_Period_1 < 1) || ((TA_Integer)optInSlowK_Period_1 > 2147483647) )
return TA_BAD_PARAM;
if( (TA_Integer)optInSlowK_MAType_2 == TA_INTEGER_DEFAULT )
optInSlowK_MAType_2 = 0;
else if( ((TA_Integer)optInSlowK_MAType_2 < 0) || ((TA_Integer)optInSlowK_MAType_2 > 8) )
return TA_BAD_PARAM;
/* min/max are checked for optInSlowD_Period_3. */
if( (TA_Integer)optInSlowD_Period_3 == TA_INTEGER_DEFAULT )
optInSlowD_Period_3 = 3;
else if( ((TA_Integer)optInSlowD_Period_3 < 1) || ((TA_Integer)optInSlowD_Period_3 > 2147483647) )
return TA_BAD_PARAM;
if( (TA_Integer)optInSlowD_MAType_4 == TA_INTEGER_DEFAULT )
optInSlowD_MAType_4 = 0;
else if( ((TA_Integer)optInSlowD_MAType_4 < 0) || ((TA_Integer)optInSlowD_MAType_4 > 8) )
return TA_BAD_PARAM;
if( outSlowK_0 == NULL )
return TA_BAD_PARAM;
if( outSlowD_1 == NULL )
return TA_BAD_PARAM;
#endif /* TA_FUNC_NO_RANGE_CHECK */
/**** END GENCODE SECTION 3 - DO NOT DELETE THIS LINE ****/
/* Insert TA function code here. */
/* With stochastic, there is a total of 4 different lines that
* are defined: FASTK, FASTD, SLOWK and SLOWD.
*
* The D is the signal line usually drawn over its
* corresponding K function.
*
* (Today's Close - LowestLow)
* FASTK(Kperiod) = --------------------------- * 100
* (HighestHigh - LowestLow)
*
* FASTD(FastDperiod, MA type) = MA Smoothed FASTK over FastDperiod
*
* SLOWK(SlowKperiod, MA type) = MA Smoothed FASTK over SlowKperiod
*
* SLOWD(SlowDperiod, MA Type) = MA Smoothed SLOWK over SlowDperiod
*
* The HighestHigh and LowestLow are the extreme values among the
* last 'Kperiod'.
*
* SLOWK and FASTD are equivalent when using the same period.
*
* The following shows how these four lines are made available in TA-LIB:
*
* TA_STOCH : Returns the SLOWK and SLOWD
* TA_STOCHF : Returns the FASTK and FASTD
*
* The TA_STOCH function correspond to the more widely implemented version
* found in many software/charting package. The TA_STOCHF is more rarely
* used because its higher volatility cause often whipsaws.
*/
/* Identify the lookback needed. */
lookbackK = optInFastK_Period_0-1;
lookbackKSlow = TA_MA_Lookback( optInSlowK_Period_1, optInSlowK_MAType_2 );
lookbackDSlow = TA_MA_Lookback( optInSlowD_Period_3, optInSlowD_MAType_4 );
lookbackTotal = lookbackK + lookbackDSlow + lookbackKSlow;
/* Move up the start index if there is not
* enough initial data.
*/
if( startIdx < lookbackTotal )
startIdx = lookbackTotal;
/* Make sure there is still something to evaluate. */
if( startIdx > endIdx )
{
/* Succeed... but no data in the output. */
*outBegIdx = 0;
*outNbElement = 0;
return TA_SUCCESS;
}
/* Do the K calculation:
*
* Kt = 100 x ((Ct-Lt)/(Ht-Lt))
*
* Kt is today stochastic
* Ct is today closing price.
* Lt is the lowest price of the last K Period (including today)
* Ht is the highest price of the last K Period (including today)
*/
/* Proceed with the calculation for the requested range.
* Note that this algorithm allows the input and
* output to be the same buffer.
*/
outIdx = 0;
/* Calculate just enough K for ending up with the caller
* requested range. (The range of k must consider all
* the lookback involve with the smoothing).
*/
trailingIdx = startIdx-lookbackTotal;
today = trailingIdx+lookbackK;
lowestIdx = highestIdx = -1;
diff = highest = lowest = 0.0;
/* Allocate a temporary buffer large enough to
* store the K.
*
* If the output is the same as the input, great
* we just save ourself one memory allocation.
*/
bufferIsAllocated = 0;
if( (outSlowK_0 == inHigh_0) ||
(outSlowK_0 == inLow_0) ||
(outSlowK_0 == inClose_0) )
{
tempBuffer = outSlowK_0;
}
else if( (outSlowD_1 == inHigh_0) ||
(outSlowD_1 == inLow_0) ||
(outSlowD_1 == inClose_0) )
{
tempBuffer = outSlowD_1;
}
else
{
bufferIsAllocated = 1;
tempBuffer = TA_Malloc( (endIdx-today+1)*sizeof(TA_Real) );
}
/* Do the K calculation */
while( today <= endIdx )
{
/* Set the lowest low */
tmp = inLow_0[today];
if( lowestIdx < trailingIdx )
{
lowestIdx = trailingIdx;
lowest = inLow_0[lowestIdx];
i = lowestIdx;
while( ++i<=today )
{
tmp = inLow_0[i];
if( tmp < lowest )
{
lowestIdx = i;
lowest = tmp;
}
}
diff = (highest - lowest)/100.0;
}
else if( tmp <= lowest )
{
lowestIdx = today;
lowest = tmp;
diff = (highest - lowest)/100.0;
}
/* Set the highest high */
tmp = inHigh_0[today];
if( highestIdx < trailingIdx )
{
highestIdx = trailingIdx;
highest = inHigh_0[highestIdx];
i = highestIdx;
while( ++i<=today )
{
tmp = inHigh_0[i];
if( tmp > highest )
{
highestIdx = i;
highest = tmp;
}
}
diff = (highest - lowest)/100.0;
}
else if( tmp >= highest )
{
highestIdx = today;
highest = tmp;
diff = (highest - lowest)/100.0;
}
/* Calculate stochastic. */
if( diff != 0.0 )
tempBuffer[outIdx++] = (inClose_0[today]-lowest)/diff;
else
tempBuffer[outIdx++] = 0.0;
trailingIdx++;
today++;
}
/* Un-smoothed K calculation completed. This K calculation is not returned
* to the caller. It is always smoothed and then return.
* Some documentation will refer to the smoothed version as being
* "K-Slow", but often this end up to be shorten to "K".
*/
retCode = TA_MA( 0, outIdx-1,
tempBuffer, optInSlowK_Period_1,
optInSlowK_MAType_2,
outBegIdx, outNbElement, tempBuffer );
if( (retCode != TA_SUCCESS) || (*outNbElement == 0) )
{
if( bufferIsAllocated )
TA_Free( tempBuffer );
/* Something wrong happen? No further data? */
*outBegIdx = 0;
*outNbElement = 0;
return retCode;
}
/* Calculate the %D which is simply a moving average of
* the already smoothed %K.
*/
retCode = TA_MA( 0, (*outNbElement)-1,
tempBuffer, optInSlowD_Period_3,
optInSlowD_MAType_4,
outBegIdx, outNbElement, outSlowD_1 );
/* Copy tempBuffer into the caller buffer.
* (Calculation could not be done directly in the
* caller buffer because more input data then the
* requested range was needed for doing %D).
*/
memmove( outSlowK_0, &tempBuffer[lookbackDSlow], (*outNbElement) * sizeof(TA_Real) );
/* Don't need K anymore, free it if it was allocated here. */
if( bufferIsAllocated )
TA_Free( tempBuffer );
if( retCode != TA_SUCCESS )
{
/* Something wrong happen while processing %D? */
*outBegIdx = 0;
*outNbElement = 0;
return retCode;
}
/* Note: Keep the outBegIdx relative to the
* caller input before returning.
*/
*outBegIdx = startIdx;
return TA_SUCCESS;
}
/* This is an un-optimized version of the STOCH function */
static TA_RetCode referenceStoch( TA_Integer startIdx,
TA_Integer endIdx,
const TA_Real inHigh_0[],
const TA_Real inLow_0[],
const TA_Real inClose_0[],
TA_Integer optInFastK_Period_0, /* From 1 to TA_INTEGER_MAX */
TA_Integer optInSlowK_Period_1, /* From 1 to TA_INTEGER_MAX */
TA_Integer optInSlowK_MAType_2,
TA_Integer optInSlowD_Period_3, /* From 1 to TA_INTEGER_MAX */
TA_Integer optInSlowD_MAType_4,
TA_Integer *outBegIdx,
TA_Integer *outNbElement,
TA_Real outSlowK_0[],
TA_Real outSlowD_1[] )
/**** END GENCODE SECTION 2 - DO NOT DELETE THIS LINE ****/
{
/* Insert local variables here. */
TA_RetCode retCode;
TA_Real Lt, Ht, tmp, *tempBuffer;
TA_Integer outIdx;
TA_Integer lookbackTotal, lookbackK, lookbackKSlow, lookbackDSlow;
TA_Integer trailingIdx, today, i, bufferIsAllocated;
/**** START GENCODE SECTION 3 - DO NOT DELETE THIS LINE ****/
#ifndef TA_FUNC_NO_RANGE_CHECK
/* Validate the requested output range. */
if( startIdx < 0 )
return TA_OUT_OF_RANGE_START_INDEX;
if( (endIdx < 0) || (endIdx < startIdx))
return TA_OUT_OF_RANGE_END_INDEX;
/* Validate the parameters. */
/* Verify required price component. */
if(!inHigh_0||!inLow_0||!inClose_0)
return TA_BAD_PARAM;
/* min/max are checked for optInFastK_Period_0. */
if( optInFastK_Period_0 == TA_INTEGER_DEFAULT )
optInFastK_Period_0 = 5;
else if( (optInFastK_Period_0 < 1) || (optInFastK_Period_0 > 2147483647) )
return TA_BAD_PARAM;
/* min/max are checked for optInSlowK_Period_1. */
if( optInSlowK_Period_1 == TA_INTEGER_DEFAULT )
optInSlowK_Period_1 = 3;
else if( (optInSlowK_Period_1 < 1) || (optInSlowK_Period_1 > 2147483647) )
return TA_BAD_PARAM;
if( optInSlowK_MAType_2 == TA_INTEGER_DEFAULT )
optInSlowK_MAType_2 = 0;
else if( (optInSlowK_MAType_2 < 0) || (optInSlowK_MAType_2 > 4) )
return TA_BAD_PARAM;
/* min/max are checked for optInSlowD_Period_3. */
if( optInSlowD_Period_3 == TA_INTEGER_DEFAULT )
optInSlowD_Period_3 = 3;
else if( (optInSlowD_Period_3 < 1) || (optInSlowD_Period_3 > 2147483647) )
return TA_BAD_PARAM;
if( optInSlowD_MAType_4 == TA_INTEGER_DEFAULT )
optInSlowD_MAType_4 = 0;
else if( (optInSlowD_MAType_4 < 0) || (optInSlowD_MAType_4 > 4) )
return TA_BAD_PARAM;
if( outSlowK_0 == NULL )
return TA_BAD_PARAM;
if( outSlowD_1 == NULL )
return TA_BAD_PARAM;
#endif /* TA_FUNC_NO_RANGE_CHECK */
/**** END GENCODE SECTION 3 - DO NOT DELETE THIS LINE ****/
/* Insert TA function code here. */
/* Identify the lookback needed. */
lookbackK = optInFastK_Period_0-1;
lookbackKSlow = TA_MA_Lookback( optInSlowK_Period_1, optInSlowK_MAType_2 );
lookbackDSlow = TA_MA_Lookback( optInSlowD_Period_3, optInSlowD_MAType_4 );
lookbackTotal = lookbackK + lookbackDSlow + lookbackKSlow;
/* Move up the start index if there is not
* enough initial data.
*/
if( startIdx < lookbackTotal )
startIdx = lookbackTotal;
/* Make sure there is still something to evaluate. */
if( startIdx > endIdx )
{
/* Succeed... but no data in the output. */
*outBegIdx = 0;
*outNbElement = 0;
return TA_SUCCESS;
}
/* Do the K calculation:
*
* Kt = 100 x ((Ct-Lt)/(Ht-Lt))
*
* Kt is today stochastic
* Ct is today closing price.
* Lt is the lowest price of the last K Period (including today)
* Ht is the highest price of the last K Period (including today)
*/
/* Proceed with the calculation for the requested range.
* Note that this algorithm allows the input and
* output to be the same buffer.
*/
outIdx = 0;
/* Calculate just enough K for ending up with the caller
* requested range. (The range of k must consider all
* the lookback involve with the smoothing).
*/
trailingIdx = startIdx-lookbackTotal;
today = trailingIdx+lookbackK;
/* Allocate a temporary buffer large enough to
* store the K.
*
* If the output is the same as the input, great
* we just save ourself one memory allocation.
*/
bufferIsAllocated = 0;
if( (outSlowK_0 == inHigh_0) ||
(outSlowK_0 == inLow_0) ||
(outSlowK_0 == inClose_0) )
{
tempBuffer = outSlowK_0;
}
else if( (outSlowD_1 == inHigh_0) ||
(outSlowD_1 == inLow_0) ||
(outSlowD_1 == inClose_0) )
{
tempBuffer = outSlowD_1;
}
else
{
bufferIsAllocated = 1;
tempBuffer = TA_Malloc( (endIdx-today+1)*sizeof(TA_Real) );
}
/* Do the K calculation */
while( today <= endIdx )
{
/* Find Lt and Ht for the requested K period. */
Lt = inLow_0 [trailingIdx];
Ht = inHigh_0[trailingIdx];
trailingIdx++;
for( i=trailingIdx; i <= today; i++ )
{
tmp = inLow_0[i];
if( tmp < Lt ) Lt = tmp;
tmp = inHigh_0[i];
if( tmp > Ht ) Ht = tmp;
}
/* Calculate stochastic. */
tmp = Ht-Lt;
if( tmp > 0.0 )
tempBuffer[outIdx++] = 100.0*((inClose_0[today]-Lt)/tmp);
else
tempBuffer[outIdx++] = 100.0;
today++;
}
/* Un-smoothed K calculation completed. This K calculation is not returned
* to the caller. It is always smoothed and then return.
* Some documentation will refer to the smoothed version as being
* "K-Slow", but often this end up to be shorten to "K".
*/
retCode = TA_MA( 0, outIdx-1,
tempBuffer, optInSlowK_Period_1,
optInSlowK_MAType_2,
outBegIdx, outNbElement, tempBuffer );
if( (retCode != TA_SUCCESS) || (*outNbElement == 0) )
{
if( bufferIsAllocated )
TA_Free( tempBuffer );
/* Something wrong happen? No further data? */
*outBegIdx = 0;
*outNbElement = 0;
return retCode;
}
/* Calculate the %D which is simply a moving average of
* the already smoothed %K.
*/
retCode = TA_MA( 0, (*outNbElement)-1,
tempBuffer, optInSlowD_Period_3,
optInSlowD_MAType_4,
outBegIdx, outNbElement, outSlowD_1 );
/* Copy tempBuffer into the caller buffer.
* (Calculation could not be done directly in the
* caller buffer because more input data then the
* requested range was needed for doing %D).
*/
memmove( outSlowK_0, &tempBuffer[lookbackDSlow], (*outNbElement) * sizeof(TA_Real) );
/* Don't need K anymore, free it if it was allocated here. */
if( bufferIsAllocated )
TA_Free( tempBuffer );
if( retCode != TA_SUCCESS )
{
/* Something wrong happen while processing %D? */
*outBegIdx = 0;
*outNbElement = 0;
return retCode;
}
/* Note: Keep the outBegIdx relative to the
* caller input before returning.
*/
*outBegIdx = startIdx;
return TA_SUCCESS;
}
