int main(void) {
//Seed the Random number generator
srand((unsigned)time(0));
int i,j ;
struct point pt;
float distances1[500] = {0};
float distances2[500] = {0};
//Two Random Walks
runTrial(500, distances1, 'U');
graph_new(LINE, distances1, 500, "legend=1st Walk, xlabel=Step Number, ylabel=Distance from the origin");
runTrial(500, distances2, 'U');
graph_new(LINE, distances2, 500, "legend=2nd Walk, xlabel=Step Number, ylabel=Distance from the origin, title=2 Random Walks");
graph_show();
//Simulate 300 Random Walks with 500 steps each
simulate(300,500);
simulateEW(300,500);
simulateBiased(300,500);
graph_show();
return 0;
}
int main(){
int T=2;
double mu=0.1, sigma=0.2,deltat1=0.5, deltat2=0.01;
gsl_rng* r;
r=gsl_rng_alloc(gsl_rng_mt19937);
runTrial(T,mu,sigma,deltat1,r,1);
runTrial(T,mu,sigma,deltat2,r,2);
return 0;
}
double petabricks::PetabricksRuntime::optimizeParameter(jalib::JTunable& tunable, int min, int max, int step){
if(max<=min) return -1;
if(step<0){
step=(max-min)/SEARCH_BRANCH_FACTOR;
}
if(step<=0) step = 1;
int best=max;
double bestVal = std::numeric_limits<double>::max();
//scan the search space
for(int n=min; n<max+step; n+=step){
tunable.setValue(n);
double avg = runTrial(bestVal, ACCTRAIN);
if(avg<=bestVal){
bestVal=avg;
best=n;
}
}
if(step>1){
int newStep = step/SEARCH_BRANCH_FACTOR;
int newMin = best-step;
int newMax = best+step;
if(newMin<min) newMin = min;
if(newMax>max) newMax = max;
return optimizeParameter(tunable, newMin, newMax, newStep);
}else{
tunable.setValue(best);
return bestVal;
}
}
void simulateEW(int numSims, int numSteps) {
int sim;
float lastPointX[numSims];
float lastPointY[numSims];
float average[numSteps];
memset(average,0,numSteps * sizeof(float));
int step;
for (sim = 0; sim < numSims; sim++) {
struct point final_xy;
final_xy = runTrial(numSteps, average, 'L');
//Add to the average array
lastPointX[sim] = final_xy.x;
lastPointY[sim] = final_xy.y;
}
for (step=0; step < numSteps; step++)
average[step] = average[step] / (float) numSims;
graph_new(LINE, average, numSteps, "legend=EW Walk,title=Repititive Simulations,xlabel=Step Number,ylabel=Distance(averaged)");
graph_xy(SCATTER,lastPointX,lastPointY, numSims, "legend=End Points(EW Walk), title=Last Point in each Trial, xlabel=x-coordinate, ylabel=y-coordinate");
printf("Final Distance EW:%f\n", average[numSteps - 1] );
}
void MCTSPlayer::MakeMove()
{
//clock_t time = clock();
//clock_t endTime = time+thinkTime;
int i=0;
//while (clock() < endTime)
while(++i<thinkTime)
{
runTrial(curNode,true);
}
if (g->gameStatus(curState)==Game::status::ONGOING)
{
MCTSNodePtr best=curNode->bestMove();
curState = best->getState();
curNode = best;
}
/*
clock_t time = clock();
clock_t endTime = time+thinkTime;
int i=0;
while (++i<30)
{
runTrial(curNode,true);
}
if (g->gameStatus(curState)==Game::status::ONGOING)
{
MCTSNodePtr best=curNode->bestMove();
curState = best->getState();
curNode = best;
}
*/
}
double petabricks::PetabricksRuntime::runTrial(double thresh, bool train){
SubprocessTestIsolation sti(thresh);
static DummyTestIsolation dti;
TestIsolation* ti;
if(ISOLATION) ti = &sti;
else ti = &dti;
return runTrial(*ti, train);
}
void petabricks::PetabricksRuntime::runGraphTemplate(){
int i=0;
for(; _main!=NULL; _main=_main->nextTemplateMain(),++i){
double avg = runTrial(GRAPH_MAX_SEC, ACCTRAIN);
if(theAccuracies.empty()){
printf("%d %.6f\n", i, avg);
}else{
printf("%d %.6f %.6f %.6f\n", i, avg, _main->accuracyTarget(), _mean(theAccuracies));
theAccuracies.clear();
}
}
}
void petabricks::PetabricksRuntime::runGraphParallelMode() {
GRAPH_MIN = std::max(GRAPH_MIN, worker_threads.min().i());
GRAPH_MAX = std::min(GRAPH_MAX, worker_threads.max().i());
for(int n=GRAPH_MIN; n<=GRAPH_MAX; n=_incN(n)){
worker_threads.setValue(n);
if(!ISOLATION)
DynamicScheduler::cpuScheduler().startWorkerThreads(worker_threads);
double avg = runTrial(GRAPH_MAX_SEC, ACCTRAIN);
if(avg<std::numeric_limits<double>::max())
printf("%d %.6lf\n", n, avg);
fflush(stdout);
if(avg > GRAPH_MAX_SEC) break;
}
}
int main( int argc, char **argv )
{
size_t const numTradingDays = 252;
double const dt = 1.0 / numTradingDays;
double const sqrtDT = sqrt( dt );
double priceMeans[NS];
for ( size_t i=0; i<NS; ++i )
priceMeans[i] = 25.0/numTradingDays;
double priceDevs[NS];
for ( size_t i=0; i<NS; ++i )
priceDevs[i] = 25.0/numTradingDays;
uint32_t seed = initialSeed(0);
double priceCorrelations[NS][NS];
randomCorrelation( priceCorrelations, seed );
double priceCovariance[NS][NS];
for ( size_t i=0; i<NS; ++i )
{
for ( size_t j=0; j<NS; ++j )
{
priceCovariance[i][j] = priceDevs[i] * priceDevs[j] * priceCorrelations[i][j];
}
}
double choleskyTrans[NS][NS];
computeCholeskyTrans( priceCovariance, choleskyTrans );
double drifts[NS];
for ( size_t i=0; i<NS; ++i )
drifts[i] = priceMeans[i] - priceCovariance[i][i]/2.0;
size_t const numTrials = 1048576;
double *trialResults = new double[numTrials];
for ( size_t trial=0; trial<numTrials; ++trial )
{
trialResults[trial] = runTrial( trial, numTradingDays, dt, sqrtDT, choleskyTrans, drifts );
}
qsort( trialResults, numTrials, sizeof(double), doubleCompare );
printf( "VaR = %.16f\n", 100.0*NS - trialResults[(size_t)floor( 0.05 * numTrials )] );
delete [] trialResults;
return 0;
}
void petabricks::PetabricksRuntime::runGraphMode(){
for(int n=GRAPH_MIN; n<=GRAPH_MAX; n=_incN(n)){
setSize(n);
double avg = runTrial(GRAPH_MAX_SEC, ACCTRAIN);
if(avg<std::numeric_limits<double>::max()){
if(theAccuracies.empty()){
printf("%d %.6f\n", n, avg);
}else{
printf("%d %.6f %.6f\n", n, avg, _mean(theAccuracies));
theAccuracies.clear();
}
}
fflush(stdout);
if(avg > GRAPH_MAX_SEC) break;
}
}
void *threadEntry( void *_args )
{
Args const *args = (Args const *)_args;
for ( size_t index = args->startIndex;
index != args->endIndex; ++index )
{
args->trialResults[index] = runTrial(
index,
args->fixedArgs->numTradingDays,
args->fixedArgs->dt,
args->fixedArgs->sqrtDT,
args->fixedArgs->choleskyTrans,
args->fixedArgs->drifts
);
}
return 0;
}
void petabricks::PetabricksRuntime::runGraphParamMode(const std::string& param){
jalib::JTunable* tunable = jalib::JTunableManager::instance().getReverseMap()[param];
JASSERT(tunable!=0)(param).Text("parameter not found");
GRAPH_MIN = std::max(GRAPH_MIN, tunable->min().i());
GRAPH_MAX = std::min(GRAPH_MAX, tunable->max().i());
for(int n=GRAPH_MIN; n<=GRAPH_MAX; n=_incN(n)){
tunable->setValue(n);
double avg = runTrial(GRAPH_MAX_SEC, ACCTRAIN);
if(avg<std::numeric_limits<double>::max()){
if(theAccuracies.empty()){
printf("%d %.6f\n", n, avg);
}else{
printf("%d %.6f %.6f\n", n, avg, _mean(theAccuracies));
theAccuracies.clear();
}
}
fflush(stdout);
if(avg > GRAPH_MAX_SEC) break;
}
}
Game::status MCTSPlayer::runTrial( MCTSNodePtr node, bool myTurn )
{
Game::status returnStatus;
node->visit();
if (!node->isLeaf())
{
//selection
returnStatus=runTrial(node->bestSelection(myTurn), !myTurn);
}
else
{
//expansion
vector<StringGameStatePtr>& a = g->getPossibleMoves(node->getState());
node->expand(a);
if (!node->isLeaf())
{
node=node->getRandomChild();
node->visit();
}
//simulation
returnStatus=simulateFrom(node->getState());
}
//back prorogation
if (IWin(returnStatus))
{
node->setScore(node->getScore()+1);
}
if (ILose(returnStatus))
{
node->setScore(node->getScore()-1);
}
return returnStatus;
}
int petabricks::PetabricksRuntime::runMain(){
#ifdef HAVE_OPENCL
int err;
#endif
JTIMER_SCOPE(runMain);
switch(MODE){
case MODE_RUN_IO:
#ifdef HAVE_OPENCL
if( 0 != ( err = OpenCLUtil::init( ) ) )
{
std::cout << "Failed to initialize OpenCL: error " << err << "." << std::endl;
exit( -1 );
}
#endif
runNormal();
break;
case MODE_IOGEN_CREATE:
iogenCreate(iogenFiles(IOGEN_PFX));
break;
case MODE_IOGEN_RUN:
iogenRun(iogenFiles(IOGEN_PFX));
break;
case MODE_RACE_CONFIGS:
raceConfigs(_randSize);
return _rv;
break;
case MODE_RUN_RANDOM:
#ifdef HAVE_OPENCL
if( 0 != ( err = OpenCLUtil::init( ) ) )
{
std::cout << "Failed to initialize OpenCL: error " << err << "." << std::endl;
exit(-1 );
}
#endif
runTrial(GRAPH_MAX_SEC, ACCTRAIN);
break;
case MODE_GRAPH_INPUTSIZE:
runGraphMode();
break;
case MODE_GRAPH_PARAM:
runGraphParamMode(graphParam);
break;
case MODE_GRAPH_TEMPLATE:
runGraphTemplate();
break;
case MODE_GRAPH_THREADS:
runGraphParallelMode();
break;
case MODE_AUTOTUNE_PARAM:
optimizeParameter(graphParam);
break;
case MODE_ABORT:
case MODE_HELP:
break;
}
if(FORCEOUTPUT && _rv==0){
JTIMER_SCOPE(forceoutput);
std::vector<std::string> tmp;
for(int i=_main->numInputs(); i-->0;)
tmp.push_back(DEVNULL);
for(int i=_main->numOutputs(); i-->0;)
tmp.push_back("-");
_main->writeOutputs(tmp);
}
ACCURACY=!theAccuracies.empty();
DUMPTIMING=!theTimings.empty();
if(ACCURACY || DUMPTIMING || HASH) std::cout << "<root>\n <stats>\n";
if(ACCURACY){
std::cout << " <accuracy";
_dumpStats(std::cout, theAccuracies);
std::cout << " />\n";
}
if(DUMPTIMING){
std::cout << " <timing";
_dumpStats(std::cout, theTimings);
std::cout << " />\n";
}
if(HASH){
std::cout << " <outputhash value=\"0x" << theLastHash << "\" />\n";
}
if(ACCURACY || DUMPTIMING || HASH) std::cout << " </stats>\n</root>\n" << std::flush;
return _rv;
}
