/**** Global functions definitions. ****/ ErrorNumber allocLib( TA_UDBase **uDBasePtr ) { TA_InitializeParam initializeParam; TA_RetCode retCode; TA_UDBase *uDBase; /* Initialize the library. */ memset( &initializeParam, 0, sizeof( TA_InitializeParam ) ); initializeParam.logOutput = stdout; retCode = TA_Initialize( &initializeParam ); if( retCode != TA_SUCCESS ) { printf( "TA_Initialize failed [%d]\n", retCode ); return TA_TESTUTIL_INIT_FAILED; } /* Install a fatal error handler. */ retCode = TA_SetFatalErrorHandler( myFatalHandler ); if( retCode != TA_SUCCESS ) { printf( "TA_SetFatalErrorHandler failed [%d]\n", retCode ); TA_Shutdown(); return TA_TESTUTIL_SET_FATAL_ERROR_FAILED; } /* Create an unified database. */ retCode = TA_UDBaseAlloc( &uDBase ); if( retCode != TA_SUCCESS ) { printf( "TA_UDBaseAlloc failed [%d]\n", retCode ); TA_Shutdown(); return TA_TESTUTIL_UDBASE_ALLOC_FAILED; } *uDBasePtr = uDBase; return TA_TEST_PASS; }
ErrorNumber freeLib( TA_UDBase *uDBase ) { TA_RetCode retCode; /* For testing purpose */ /* TA_FATAL_RET( "Test again", 100, 200, 0 ); */ retCode = TA_UDBaseFree( uDBase ); if( retCode != TA_SUCCESS ) { printf( "TA_UDBaseFree failed [%d]\n", retCode ); return TA_TESTUTIL_UDBASE_FREE_FAILED; } retCode = TA_Shutdown(); if( retCode != TA_SUCCESS ) { printf( "TA_Shutdown failed [%d]\n", retCode ); return TA_TESTUTIL_SHUTDOWN_FAILED; } return TA_TEST_PASS; }
int main( int argc, char **argv ) { TA_RetCode retCode; int retValue; /* Verify the parameters. */ if( argc != 2 ) { print_usage( "Bad Parameter" ); return -1; } /* Initialize TA-LIB. */ retCode = TA_Initialize( NULL ); if( retCode != TA_SUCCESS ) { print_error( retCode ); return -1; } /* Fetch and display the WebPage. */ retCode = TA_WebFetch( argv[1], stdout ); if( retCode != TA_SUCCESS ) { print_error( retCode ); retValue = -1; } else retValue = 0; /* Clean-up and exit. */ TA_Shutdown(); return retValue; }
TALIB::~TALIB () { TA_Shutdown(); }
Datum ta_f( PG_FUNCTION_ARGS) { // Declare for TA TA_RetCode retCode; TA_Real *closePrice = NULL; TA_Real *out; TA_Integer outBeg; TA_Integer outNbElement; // Declare for postgres FuncCallContext *funcctx; int call_cntr; int max_calls; Datum *result = NULL; int dim; int z; ArrayType *ur = PG_GETARG_ARRAYTYPE_P(0); if (array_contains_nulls(ur)) { ereport(ERROR, ( errcode(ERRCODE_ARRAY_ELEMENT_ERROR), errmsg("cannot work with arrays containing NULLs") )); } dim = ARRNELEMS(ur); closePrice = ARRPTR(ur); if (SRF_IS_FIRSTCALL()) { MemoryContext oldcontext; funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); /* One-time setup code appears here: */ retCode = TA_Initialize(); if (retCode != TA_SUCCESS) { ereport(ERROR, ( errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Cannot initialize TA-Lib (%d)!\n", retCode) )); } out = palloc(dim * sizeof(TA_Real)); retCode = TA_MA(0, dim - 1, &closePrice[0], 5, TA_MAType_SMA, &outBeg, &outNbElement, &out[0]); result = palloc(outNbElement * sizeof(Datum)); // Error log for debugging /* ereport(NOTICE, (errmsg("dims %d, outBeg: %d, outNbElement %d\n", dim, outBeg, outNbElement))); */ for (z = 0; z < dim; z++) { // Error log for debugging //ereport(NOTICE, (errmsg("z: %d, out[z]: %5.1f", z, out[z]))); if(z > outBeg-1) { result[z] = Float8GetDatum(out[z-outBeg]); continue; } result[z] = NULL; } TA_Shutdown(); funcctx->max_calls = dim; funcctx->user_fctx = result; MemoryContextSwitchTo(oldcontext); } /* stuff done on every call of the function */ funcctx = SRF_PERCALL_SETUP(); call_cntr = funcctx->call_cntr; max_calls = funcctx->max_calls; if (call_cntr < max_calls) { if(((Datum *) funcctx->user_fctx)[call_cntr]) { SRF_RETURN_NEXT(funcctx, ((Datum *) funcctx->user_fctx)[call_cntr]); } SRF_RETURN_NEXT_NULL(funcctx); } SRF_RETURN_DONE(funcctx); }
static ErrorNumber testHistoryAlloc( void ) { TA_UDBase *unifiedDatabase; TA_History *data; TA_RetCode retCode; TA_InitializeParam param; TA_AddDataSourceParam addParam; TA_HistoryAllocParam histParam; memset( ¶m, 0, sizeof( TA_InitializeParam ) ); param.logOutput = stdout; retCode = TA_Initialize( ¶m ); if( retCode != TA_SUCCESS ) { printf( "Cannot initialize TA-LIB (%d)!", retCode ); return TA_REGTEST_HISTORYALLOC_0; } /* Create an unified database. */ if( TA_UDBaseAlloc( &unifiedDatabase ) != TA_SUCCESS ) { TA_Shutdown(); return TA_REGTEST_HISTORYALLOC_1; } /* USE SIMULATOR DATA */ memset( &addParam, 0, sizeof( TA_AddDataSourceParam ) ); addParam.id = TA_SIMULATOR; addParam.flags = TA_NO_FLAGS; retCode = TA_AddDataSource( unifiedDatabase, &addParam ); /* Now, display all daily close price available * for the DAILY_REF_0 symbol. */ if( retCode != TA_SUCCESS ) return TA_REGTEST_ADDDSOURCE_FAILED; #if defined __BORLANDC__ #pragma warn -ccc #pragma warn -rch #endif #define CHECK_FIELDSUBSET(field_par) \ { \ memset( &histParam, 0, sizeof( TA_HistoryAllocParam ) ); \ histParam.category = "TA_SIM_REF"; \ histParam.symbol = "DAILY_REF_0"; \ histParam.field = field_par; \ histParam.period = TA_DAILY; \ retCode = TA_HistoryAlloc( unifiedDatabase, &histParam, &data ); \ if( retCode == TA_SUCCESS ) \ { \ if( (field_par) & TA_OPEN ) \ { \ if( !data->open ) \ return TA_REGTEST_HISTORYALLOC_2; \ if( data->open[0] != 92.5 ) \ return TA_REGTEST_HISTORYALLOC_3; \ } \ else \ { \ if( data->open ) \ return TA_REGTEST_HISTORYALLOC_4; \ } \ if( (field_par) & TA_HIGH ) \ { \ if( !data->high ) \ return TA_REGTEST_HISTORYALLOC_5; \ if( data->high[0] != 93.25 ) \ return TA_REGTEST_HISTORYALLOC_6; \ } \ else \ { \ if( data->high ) \ return TA_REGTEST_HISTORYALLOC_7; \ } \ if( (field_par) & TA_LOW ) \ { \ if( !data->low ) \ return TA_REGTEST_HISTORYALLOC_8; \ if( data->low[0] != 90.75 ) \ return TA_REGTEST_HISTORYALLOC_9; \ } \ else \ { \ if( data->low ) \ return TA_REGTEST_HISTORYALLOC_10; \ } \ if( (field_par) & TA_CLOSE ) \ { \ if( !data->close ) \ return TA_REGTEST_HISTORYALLOC_11; \ if( data->close[0] != 91.50 ) \ return TA_REGTEST_HISTORYALLOC_12; \ } \ else \ { \ if( data->close ) \ return TA_REGTEST_HISTORYALLOC_13; \ } \ if( (field_par) & TA_VOLUME ) \ { \ if( !data->volume ) \ return TA_REGTEST_HISTORYALLOC_14; \ if( data->volume[0] != 4077500) \ return TA_REGTEST_HISTORYALLOC_15; \ } \ else \ { \ if( data->volume ) \ return TA_REGTEST_HISTORYALLOC_16; \ } \ if( (field_par) & TA_TIMESTAMP ) \ { \ if( !data->timestamp ) \ return TA_REGTEST_HISTORYALLOC_17; \ } \ else \ { \ if( data->timestamp ) \ return TA_REGTEST_HISTORYALLOC_18; \ } \ TA_HistoryFree( data ); \ } \ else \ { \ printf( "Cannot TA_HistoryAlloc for TA_SIM_REF (%d)!\n", retCode ); \ return TA_REGTEST_HISTORYALLOC_19; \ } \ } /* 6 Fields */ CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_HIGH|TA_LOW|TA_VOLUME) /* 5 Fields */ CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_HIGH|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_HIGH|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_HIGH|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_HIGH|TA_VOLUME) /* 4 Fields */ CHECK_FIELDSUBSET(TA_CLOSE|TA_HIGH|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_OPEN|TA_HIGH|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_HIGH|TA_VOLUME) CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_HIGH|TA_LOW) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_HIGH|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_HIGH|TA_LOW) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_HIGH|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_HIGH|TA_LOW) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_LOW) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_HIGH) /* 3 Fields */ CHECK_FIELDSUBSET(TA_HIGH|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_CLOSE|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_CLOSE|TA_HIGH|TA_VOLUME) CHECK_FIELDSUBSET(TA_CLOSE|TA_HIGH|TA_LOW) CHECK_FIELDSUBSET(TA_OPEN|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_OPEN|TA_HIGH|TA_VOLUME) CHECK_FIELDSUBSET(TA_OPEN|TA_HIGH|TA_LOW) CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_VOLUME) CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_LOW) CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_HIGH) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_HIGH) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_LOW) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH|TA_LOW) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH|TA_CLOSE) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_LOW|TA_CLOSE) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_VOLUME) /* Two field. */ CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_LOW) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE) CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_VOLUME) CHECK_FIELDSUBSET(TA_OPEN|TA_HIGH) CHECK_FIELDSUBSET(TA_OPEN|TA_LOW) CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE) CHECK_FIELDSUBSET(TA_OPEN|TA_VOLUME) CHECK_FIELDSUBSET(TA_HIGH|TA_LOW) CHECK_FIELDSUBSET(TA_HIGH|TA_CLOSE) CHECK_FIELDSUBSET(TA_HIGH|TA_VOLUME) CHECK_FIELDSUBSET(TA_LOW|TA_CLOSE) CHECK_FIELDSUBSET(TA_LOW|TA_VOLUME) CHECK_FIELDSUBSET(TA_CLOSE|TA_VOLUME) /* One Field */ CHECK_FIELDSUBSET(TA_TIMESTAMP); CHECK_FIELDSUBSET(TA_OPEN); CHECK_FIELDSUBSET(TA_HIGH) CHECK_FIELDSUBSET(TA_LOW) CHECK_FIELDSUBSET(TA_CLOSE) CHECK_FIELDSUBSET(TA_VOLUME) #undef CHECK_FIELDSUBSET /* Clean-up and exit. */ TA_UDBaseFree( unifiedDatabase ); TA_Shutdown(); return TA_SUCCESS; }
TA_RetCode TA_Initialize( const TA_InitializeParam *param ) { /* Note: Keep that function simple. * No tracing, no stdio and no assert. */ TA_RetCode retCode; #if !defined( TA_SINGLE_THREAD ) unsigned int again; /* Boolean */ unsigned int i; #endif /* Allocate the "global variable" used to manage the global * variables of all other modules... */ memset( TA_Globals, 0, sizeof( TA_LibcPriv ) ); TA_Globals->magicNb = TA_LIBC_PRIV_MAGIC_NB; if( param ) { if( param->logOutput ) { /* Override someone intention to use stdin!? */ if( param->logOutput == stdin ) TA_Globals->stdioFile = stdout; else TA_Globals->stdioFile = param->logOutput; TA_Globals->stdioEnabled = 1; } if( param->userLocalDrive ) TA_Globals->localCachePath = param->userLocalDrive; } #if !defined( TA_SINGLE_THREAD ) /* For multithread, allocate all semaphores * protecting the module's globals. */ again = 1; for( i=0; i < TA_NB_GLOBAL_ID && again; i++ ) { retCode = TA_SemaInit( &(TA_Globals->moduleControl[i].sema), 1 ); if( retCode != TA_SUCCESS ) again = 0; } if( again == 0 ) { /* Clean-up and exit. */ for( i=0; i < TA_NB_GLOBAL_ID; i++ ) TA_SemaDestroy( &(TA_Globals->moduleControl[i].sema) ); memset( TA_Globals, 0, sizeof( TA_LibcPriv ) ); return TA_INTERNAL_ERROR(4); } #endif /* Force immediatly the initialization of the memory module. * Note: No call to the tracing capability are allowed in TA_MemInit. */ retCode = TA_MemInit( sizeof( TA_LibcPriv ) ); /* Force immediatly the initialization of the tracing module. */ if( retCode == TA_SUCCESS ) retCode = TA_TraceInit(); if( retCode != TA_SUCCESS ) { /* Clean-up and exit. */ #if !defined( TA_SINGLE_THREAD ) for( i=0; i < TA_NB_GLOBAL_ID; i++ ) TA_SemaDestroy( &(TA_Globals->moduleControl[i].sema) ); #endif memset( TA_Globals, 0, sizeof( TA_LibcPriv ) ); return TA_INTERNAL_ERROR(5); } /* Tracing can now be safely used by the memory module until * shutdown in TA_Shutdown. */ TA_Globals->traceEnabled = 1; /*** At this point, TA_Shutdown can be called to clean-up. ***/ /* Allocate the default string cache used throughout the library. */ retCode = TA_StringCacheAlloc( &(TA_Globals->dfltCache) ); if( retCode != TA_SUCCESS ) { TA_Shutdown(); return retCode; } return TA_SUCCESS; }