int main(int argc, char* argv[]) {
double discountFactor = 0.9;
FILE* initFileFd = NULL;
FILE** combinedFd = NULL;
FILE* optimalFd = NULL;
optimistic_instance* optimistic = NULL;
random_search_instance* random_search = NULL;
uct_instance* uct = NULL;
uniform_instance* uniform = NULL;
unsigned int maxDepth = 0;
unsigned int i = 0;
unsigned int n = 0;
state** initialStates = NULL;
unsigned int timestamp = time(NULL);
double* optimalValues = NULL;
int readFscanf = -1;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state");
struct arg_int* d = arg_int1("d", NULL, "<n>", "Maximum depth of an uniform tree which the number of call per step");
struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_file* optimal = arg_file1(NULL, "optimal", "<file>", "File containing the optimal values");
struct arg_end* end = arg_end(6);
void* argtable[6];
int nerrors = 0;
argtable[0] = initFile;
argtable[1] = where;
argtable[2] = d;
argtable[3] = k;
argtable[4] = optimal;
argtable[5] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 6);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 6);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
K = k->ival[0];
initGenerativeModel();
optimalFd = fopen(optimal->filename[0], "r");
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &n);
initialStates = (state**)malloc(sizeof(state*) * n);
for(i = 0; i < n; i++) {
char str[1024];
readFscanf = fscanf(initFileFd, "%s\n", str);
initialStates[i] = makeState(str);
}
maxDepth = d->ival[0];
combinedFd = (FILE**)malloc(sizeof(FILE*) * maxDepth);
for(i = 1; i <= maxDepth; i++) {
char str[1024];
sprintf(str, "%s/%u_combined_%u_%u.csv", where->filename[0], timestamp, K, i);
combinedFd[i - 1] = fopen(str, "w");
fprintf(combinedFd[i - 1], "n,optimistic,random search,uct,uniform\n");
}
arg_freetable(argtable, 6);
optimalValues = (double*)malloc(sizeof(double) * K);
optimistic = optimistic_initInstance(initialStates[0], discountFactor);
random_search = random_search_initInstance(initialStates[0], discountFactor);
uct = uct_initInstance(initialStates[0], discountFactor);
uniform = uniform_initInstance(initialStates[0], discountFactor);
for(i = 0; i < n; i++) {
unsigned int j = 1;
unsigned int maxNbIterations = K;
unsigned int optimalAction = 0;
char str[1024];
readFscanf = fscanf(optimalFd, "%s\n", str);
optimalValues[0] = strtod(strtok(str, ","), NULL);
printf("%.15f,",optimalValues[0]);
for(; j < K; j++) {
optimalValues[j] = strtod(strtok(NULL, ","), NULL);
printf("%.15f,",optimalValues[j]);
}
optimalAction = atol(strtok(NULL, ","));
printf("%u\n",optimalAction);
for(j = 1; j <= maxDepth; j++) {
unsigned int crtOptimalAction = getActionId(optimistic_planning(optimistic, maxNbIterations));
fprintf(combinedFd[j - 1], "%u,", maxNbIterations);
fprintf(combinedFd[j - 1], "%.15f,", crtOptimalAction == optimalAction ? 0.0 : optimalValues[optimalAction] - optimalValues[crtOptimalAction]);
maxNbIterations += pow(K, j+1);
}
if(i < (n - 1))
optimistic_resetInstance(optimistic, initialStates[i+1]);
printf("optimistic: %uth initial state processed\n", i+1);
fflush(NULL);
maxNbIterations = K;
for(j = 1; j <= maxDepth; j++) {
unsigned int crtOptimalAction = getActionId(random_search_planning(random_search, maxNbIterations));
fprintf(combinedFd[j - 1], "%.15f,", crtOptimalAction == optimalAction ? 0.0 : optimalValues[optimalAction] - optimalValues[crtOptimalAction]);
maxNbIterations += pow(K, j+1);
}
if(i < (n - 1))
random_search_resetInstance(random_search, initialStates[i + 1]);
printf("random_search: %uth initial state processed\n", i+1);
fflush(NULL);
maxNbIterations = K;
for(j = 1; j <= maxDepth; j++) {
unsigned int crtOptimalAction = getActionId(uct_planning(uct, maxNbIterations));
fprintf(combinedFd[j - 1], "%.15f,", crtOptimalAction == optimalAction ? 0.0 : optimalValues[optimalAction] - optimalValues[crtOptimalAction]);
maxNbIterations += pow(K, j+1);
}
if(i < (n - 1))
uct_resetInstance(uct, initialStates[i + 1]);
printf("uct: %uth initial state processed\n", i+1);
fflush(NULL);
maxNbIterations = K;
for(j = 1; j <= maxDepth; j++) {
unsigned int crtOptimalAction = getActionId(uniform_planning(uniform, maxNbIterations));
fprintf(combinedFd[j - 1], "%.15f\n", crtOptimalAction == optimalAction ? 0.0 : optimalValues[optimalAction] - optimalValues[crtOptimalAction]);
maxNbIterations += pow(K, j+1);
}
if(i < (n - 1))
uniform_resetInstance(uniform, initialStates[i + 1]);
printf("uniform: %uth initial state processed\n", i+1);
printf("%uth initial state processed\n", i+1);
fflush(NULL);
}
for(i = 0; i < maxDepth; i++) {
fclose(combinedFd[i]);
}
for(i = 0; i < n; i++)
freeState(initialStates[i]);
free(initialStates);
free(combinedFd);
optimistic_uninitInstance(&optimistic);
random_search_uninitInstance(&random_search);
uct_uninitInstance(&uct);
uniform_uninitInstance(&uniform);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char** argv) {
int i, ret;
int nerrors[NUMBER_OF_DIFFERENT_SYNTAXES + 1];
/* argtable setup */
/* SYNTAX 1: [--info] */
info1 = arg_lit1(NULL, "info", "Show information about the FLI filterwheel");
end1 = arg_end(20);
void * argtable1[] = {info1, end1};
argtable[1] = argtable1;
/* SYNTAX 2: [--set-filter] */
setfilter2 = arg_int1(NULL, "set-filter", "N", "Set the filter N");
end2 = arg_end(20);
void * argtable2[] = {setfilter2, end2};
argtable[2] = argtable2;
/* SYNTAX 3: [--home] */
home3 = arg_lit1(NULL, "home", "Homes the filterwheel");
end3 = arg_end(20);
void * argtable3[] = {home3, end3};
argtable[3] = argtable3;
/* SYNTAX 4: [--help]*/
help4 = arg_lit1(NULL, "help", "Print this help");
end4 = arg_end(20);
void * argtable4[] = {help4, end4};
argtable[4] = argtable4;
/* verify all argtable[] entries were allocated successfully */
for (i = 1; i <= NUMBER_OF_DIFFERENT_SYNTAXES; i++) {
if (arg_nullcheck(argtable[i]) != 0) {
printf("%s: insufficient memory\n", progname);
return EXIT_FAILURE;
}
}
/* parse all argument possibilities */
for (i = 1; i <= NUMBER_OF_DIFFERENT_SYNTAXES; i++) {
nerrors[i] = arg_parse(argc, argv, argtable[i]);
}
/* select the right command */
/* --info */
if (nerrors[1] == 0) {
if (info1->count > 0) {
ret = filter_info();
if (ret) return ret;
return 0;
}
/* --set-filter */
} else if (nerrors[2] == 0) {
if (setfilter2->count > 0) {
ret = filter_set_filter(setfilter2->ival[0]);
if (ret) return ret;
return 0;
}
/* --home */
} else if (nerrors[3] == 0) {
if (home3->count > 0) {
ret = filter_home(1);
if (ret) return ret;
return 0;
}
/* --help */
} else if (nerrors[4] == 0) {
if (help4) {
ret = argtable_help(progname, NUMBER_OF_DIFFERENT_SYNTAXES, argtable);
if (ret) return ret;
return 0;
}
/* incorrect or partially incorrect argument syntaxes */
} else {
if (setfilter2->count > 0) {
arg_print_errors(stdout, end2, progname);
printf("usage: %s ", progname);
arg_print_syntax(stdout, argtable2, "\n");
} else {
printf("%s: unable to parse arguments, see syntax below:\n", progname);
ret = argtable_help(progname, NUMBER_OF_DIFFERENT_SYNTAXES, argtable);
if (ret) return ret;
return 0;
}
return EXIT_FAILURE;
}
/* no command line options at all */
printf("Try '%s --help' for more information.\n", progname);
return (EXIT_SUCCESS);
}
int main(int argc, char* argv[]) {
#ifdef BALL
double discountFactor = 0.9;
#else
#ifdef CART_POLE
double discountFactor = 0.95;
#else
#ifdef DOUBLE_CART_POLE
double discountFactor = 0.95;
#else
#ifdef MOUNTAIN_CAR
double discountFactor = 0.95;
#else
#ifdef ACROBOT
double discountFactor = 0.95;
#else
#ifdef BOAT
double discountFactor = 0.95;
#else
#ifdef CART_POLE_BINARY
double discountFactor = 0.95;
#else
#ifdef SWIMMER
double discountFactor = 0.95;
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
FILE* initFileFd = NULL;
state** initialStates = NULL;
unsigned int maxDepth = 0;
FILE* combinedFd = NULL;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int minDepth = 1;
unsigned int crtDepth = 0;
unsigned int n = 0;
unsigned int maxNbIterations = 0;
unsigned int nbSteps = 0;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
optimistic_instance* optimistic = NULL;
random_search_instance* random_search = NULL;
uct_instance* uct = NULL;
uniform_instance* uniform = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state");
struct arg_int* d = arg_int1("d", NULL, "<n>", "Maximum depth of an uniform tree which the number of call per step");
struct arg_int* d2 = arg_int0(NULL, "min", "<n>", "Minimun depth to start from (min > 0)");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(7);
int nerrors = 0;
void* argtable[7];
argtable[0] = initFile;
argtable[1] = d2;
argtable[2] = d;
argtable[3] = s;
argtable[4] = k;
argtable[5] = where;
argtable[6] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
K = k->ival[0];
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &n);
initialStates = (state**)malloc(sizeof(state*) * n);
for(; i < n; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
initialStates[i] = makeState(str);
}
fclose(initFileFd);
if(d2->count)
minDepth = d2->ival[0];
maxDepth = d->ival[0];
maxNbIterations = K;
nbSteps = s->ival[0];
optimistic = optimistic_initInstance(NULL, discountFactor);
random_search = random_search_initInstance(NULL, discountFactor);
uct = uct_initInstance(NULL, discountFactor);
uniform = uniform_initInstance(NULL, discountFactor);
sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps);
results = fopen(str, "w");
for(crtDepth = 1; crtDepth < minDepth; crtDepth++)
maxNbIterations += pow(K, crtDepth+1);
for(crtDepth = minDepth; crtDepth <= maxDepth; crtDepth++) {
double averages[4] = {0.0, 0.0, 0.0, 0.0};
sprintf(str, "%s/%u_combined_%u_%u(%u)_%u.csv", where->filename[0], timestamp, K, crtDepth, maxNbIterations, nbSteps);
combinedFd = fopen(str, "w");
fprintf(combinedFd, "nbIterations,optimistic,optimistic(discounted),optimistic depth,random search,random search(discounted),random search depth,uct,uct(discounted),uct depth,uniform,uniform(discounted),uniform depth\n");
for(i = 0; i < n; i++) {
unsigned int j = 0;
double sumRewards = 0.0;
double discountedSumRewards = 0.0;
unsigned int sumDepths = 0;
state* crt = copyState(initialStates[i]);
optimistic_resetInstance(optimistic, crt);
for(; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
optimistic_keepSubtree(optimistic);
action* optimalAction = optimistic_planning(optimistic, maxNbIterations);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward);
freeState(crt);
crt = nextState;
sumRewards += reward;
sumDepths += optimistic_getMaxDepth(optimistic);
discountedSumRewards += optimistic->gammaPowers[j] * reward;
if(isTerminal < 0)
break;
}
optimistic_resetInstance(optimistic, crt);
freeState(crt);
fprintf(combinedFd, "%u,%.15f,%.15f,%.15f,",maxNbIterations, sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1)));
averages[0] += sumRewards;
printf("Optimistic : %uth initial state processed\n", i + 1);
sumRewards = 0.0;
discountedSumRewards = 0.0;
sumDepths = 0;
crt = copyState(initialStates[i]);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
random_search_resetInstance(random_search, crt);
action* optimalAction = random_search_planning(random_search, maxNbIterations);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward);
freeState(crt);
crt = nextState;
sumRewards += reward;
sumDepths += random_search_getMaxDepth(random_search);
discountedSumRewards += random_search->gammaPowers[j] * reward;
if(isTerminal < 0)
break;
}
random_search_resetInstance(random_search, crt);
freeState(crt);
fprintf(combinedFd, "%.15f,%.15f,%.15f,", sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1)));
averages[1] += sumRewards;
printf("Random search: %uth initial state processed\n", i + 1);
sumRewards = 0.0;
discountedSumRewards = 0.0;
sumDepths = 0;
crt = copyState(initialStates[i]);
uct_resetInstance(uct, crt);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
uct_keepSubtree(uct);
action* optimalAction = uct_planning(uct, maxNbIterations);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward);
freeState(crt);
crt = nextState;
sumRewards += reward;
sumDepths += uct_getMaxDepth(uct);
discountedSumRewards += uct->gammaPowers[j] * reward;
if(isTerminal < 0)
break;
}
uct_resetInstance(uct, crt);
freeState(crt);
fprintf(combinedFd, "%.15f,%.15f,%.15f,", sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1)));
averages[2] += sumRewards;
printf("Uct : %uth initial state processed\n", i + 1);
sumRewards = 0.0;
discountedSumRewards = 0.0;
crt = copyState(initialStates[i]);
uniform_resetInstance(uniform, crt);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
uniform_keepSubtree(uniform);
action* optimalAction = uniform_planning(uniform, maxNbIterations);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward);
freeState(crt);
crt = nextState;
sumRewards += reward;
discountedSumRewards += uniform->gammaPowers[j] * reward;
if(isTerminal < 0)
break;
}
uniform_resetInstance(uniform, crt);
freeState(crt);
fprintf(combinedFd, "%.15f,%.15f,%u\n", sumRewards, discountedSumRewards, crtDepth -1);
fflush(combinedFd);
averages[3] += sumRewards;
printf("Uniform : %uth initial state processed\n", i + 1);
printf(">>>>>>>>>>>>>> %uth initial state processed\n", i + 1);
}
fprintf(results, "%u,%.15f,%.15f,%.15f,%.15f\n", maxNbIterations, averages[0] / (double)n, averages[1] / (double)n, averages[2] / (double)n, averages[3] / (double)n);
fflush(results);
printf(">>>>>>>>>>>>>> %u depth done\n\n", crtDepth);
fclose(combinedFd);
maxNbIterations += pow(K, crtDepth+1);
}
fclose(results);
arg_freetable(argtable, 7);
for(i = 0; i < n; i++)
freeState(initialStates[i]);
free(initialStates);
optimistic_uninitInstance(&optimistic);
random_search_uninitInstance(&random_search);
uct_uninitInstance(&uct);
uniform_uninitInstance(&uniform);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
double discountFactor = 0.9;
unsigned int i = 0;
unsigned int n = 0;
FILE* initFileFd = NULL;
FILE* outputFileFd = NULL;
unsigned int nbIterations = 0;
int readFscanf = -1;
optimistic_instance* optimistic = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state");
struct arg_int* k = arg_int1("k", NULL, "<n>", "The branching factor of the problem");
struct arg_int* it = arg_int1("n", NULL, "<n>", "The number of iterations");
struct arg_file* outputFile = arg_file1("o", NULL, "<file>", "The output file");
struct arg_end* end = arg_end(5);
void* argtable[5];
int nerrors = 0;
argtable[0] = initFile;
argtable[1] = it;
argtable[2] = outputFile;
argtable[3] = k;
argtable[4] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 5);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 5);
return EXIT_FAILURE;
}
nbIterations = it->ival[0];
initGenerativeModelParameters();
K = k->ival[0];
initGenerativeModel();
outputFileFd = fopen(outputFile->filename[0], "w");
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &n);
arg_freetable(argtable, 5);
optimistic = optimistic_initInstance(NULL, discountFactor);
for(; i < n; i++) {
char str[1024];
unsigned int j = 0;
readFscanf = fscanf(initFileFd, "%s\n", str);
state* initial = makeState(str);
double crtOptimalValue = 0.0;
unsigned int crtOptimalAction = 0;
for(; j < K; j++) {
state* nextState = NULL;
double reward = 0.0;
char isTerminal = 0;
isTerminal = nextStateReward(initial, actions[j], &nextState, &reward);
optimistic_resetInstance(optimistic, nextState);
freeState(nextState);
optimistic_planning(optimistic, nbIterations);
if(optimistic->crtOptimalValue > crtOptimalValue) {
crtOptimalValue = optimistic->crtOptimalValue;
crtOptimalAction = j;
}
fprintf(outputFileFd, "%.15f,", optimistic->crtOptimalValue);
printf("%uth action done\n", j+1);
fflush(outputFileFd);
}
fprintf(outputFileFd, "%u\n", crtOptimalAction);
freeState(initial);
printf("%uth initial state processed\n", i+1);
fflush(outputFileFd);
}
fclose(outputFileFd);
fclose(initFileFd);
optimistic_uninitInstance(&optimistic);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
// commandline argument parser options
struct arg_lit *help = arg_lit0("h", "help", "print this help and exit");
struct arg_lit *vers = arg_lit0("v", "version", "print version information and exit");
struct arg_file *file = arg_file1("f", "file", "<file>", "font file");
struct arg_int *fh = arg_int1("g", "height", "<value>", "font height in pixels (6 or 8)");
struct arg_str *text = arg_str1("t", "text", "<value>", "text to show");
struct arg_int *scale = arg_int0("s", "scale", "<value>", "scaling for the window");
struct arg_end *end = arg_end(20);
void* argtable[] = {help,vers,file,fh,text,scale,end};
const char* progname = "fonttool";
// Make sure everything got allocated
if(arg_nullcheck(argtable) != 0) {
printf("%s: insufficient memory\n", progname);
goto exit_0;
}
// Parse arguments
int nerrors = arg_parse(argc, argv, argtable);
// Handle help
if(help->count > 0) {
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
printf("\nArguments:\n");
arg_print_glossary(stdout, argtable, "%-25s %s\n");
goto exit_0;
}
// Handle version
if(vers->count > 0) {
printf("%s v0.1\n", progname);
printf("Command line One Must Fall 2097 Font file editor.\n");
printf("Source code is available at https://github.com/omf2097 under MIT license.\n");
printf("(C) 2013 Tuomas Virtanen\n");
goto exit_0;
}
// Handle errors
if(nerrors > 0) {
arg_print_errors(stdout, end, progname);
printf("Try '%s --help' for more information.\n", progname);
goto exit_0;
}
// Init SDL
SDL_Init(SDL_INIT_VIDEO);
// Scale
int _sc = 1;
if(scale->count > 0) {
_sc = scale->ival[0];
}
if(_sc > 4) _sc = 4;
if(_sc < 1) _sc = 1;
// Font size
int _fs = fh->ival[0];
if(_fs < 6 || _fs > 8 || _fs == 7) {
printf("Only valid values for fontsize are 6 and 8.\n");
goto exit_1;
}
// Load fonts
sd_font *font = sd_font_create();
if(sd_font_load(font, file->filename[0], _fs)) {
printf("Couldn't load small font file!\n");
goto exit_2;
}
// Create surface for font rendering
SDL_Surface *surface = 0;
if((surface = render_text(font, text->sval[0], 320)) == 0) {
printf("Failed to render text!\n");
goto exit_3;
}
// Init window
SDL_Window *window = SDL_CreateWindow(
"Fonttool v0.1",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
320 * _sc,
200 * _sc,
SDL_WINDOW_SHOWN
);
if (!window) {
printf("Could not create window: %s\n", SDL_GetError());
goto exit_3;
}
// Rects
SDL_Rect srcrect, dstrect;
srcrect.x = 0;
srcrect.y = 0;
srcrect.w = surface->w;
srcrect.h = surface->h;
dstrect.x = 0;
dstrect.y = 0;
dstrect.w = surface->w * _sc;
dstrect.h = surface->h * _sc;
// Run until windows closed.
SDL_Surface *window_surface = SDL_GetWindowSurface(window);
Uint32 tcolor = SDL_MapRGBA(window_surface->format, 0, 0, 0, 0);
SDL_Event e;
int run = 1;
while(run) {
if(SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
run = 0;
}
}
SDL_FillRect(window_surface, NULL, tcolor);
if(_sc == 1) {
SDL_BlitSurface(surface, &srcrect, window_surface, &dstrect);
} else {
SDL_SoftStretch(surface, &srcrect, window_surface, &dstrect);
}
SDL_UpdateWindowSurface(window);
SDL_Delay(10);
}
// Quit
SDL_DestroyWindow(window);
exit_3:
if(surface) SDL_FreeSurface(surface);
exit_2:
sd_font_delete(font);
exit_1:
SDL_Quit();
exit_0:
arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0]));
return 0;
}
int main(int argc, char* argv[]) {
#ifdef BALL
double discountFactor = 0.9;
#else
#ifdef CART_POLE
double discountFactor = 0.95;
#else
#ifdef DOUBLE_CART_POLE
double discountFactor = 0.95;
#else
#ifdef MOUNTAIN_CAR
double discountFactor = 0.99;
#else
#ifdef ACROBOT
double discountFactor = 0.95;
#else
#ifdef BOAT
double discountFactor = 0.95;
#else
#ifdef SWIMMER
double discountFactor = 0.95;
#endif
#endif
#endif
#endif
#endif
#endif
#endif
FILE* initFileFd = NULL;
state** initialStates = NULL;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int* ns = NULL;
unsigned int nbN = 0;
unsigned int* hs = NULL;
unsigned int nbH = 0;
unsigned int n = 0;
unsigned int nbSteps = 0;
unsigned int nbIterations = 1;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
random_search_instance* random_search = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state");
struct arg_str* r = arg_str1("n", NULL, "<s>", "List of maximum numbers of evaluations");
struct arg_str* d = arg_str1("h", NULL, "<s>", "List of depth");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_int* it = arg_int1("i", NULL, "<n>", "Number of iteration");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(7);
int nerrors = 0;
void* argtable[7];
argtable[0] = initFile;
argtable[1] = r;
argtable[2] = d;
argtable[3] = s;
argtable[4] = it;
argtable[5] = where;
argtable[6] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &n);
initialStates = (state**)malloc(sizeof(state*) * n);
for(; i < n; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
initialStates[i] = makeState(str);
}
fclose(initFileFd);
nbSteps = s->ival[0];
nbIterations = it->ival[0];
ns = parseUnsignedIntList((char*)r->sval[0], &nbN);
hs = parseUnsignedIntList((char*)d->sval[0], &nbH);
random_search = random_search_initInstance(NULL, discountFactor);
h_max = h_max_crt_depth;
sprintf(str, "%s/%u_results_random_search_%s.csv", where->filename[0], timestamp,(char*)r->sval[0]);
results = fopen(str, "w");
for(i = 0; i < nbIterations; i++) {
unsigned int j = 0;
for(;j < nbH; j++) {
unsigned int k = 0;
crtDepth = hs[j];
for(; k < nbN; k++) {
unsigned int l = 0;
double sumRewards = 0.0;
for(; l < n; l++) {
unsigned int m = 0;
state* crt = copyState(initialStates[l]);
for(; m < nbSteps; m++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
double* optimalAction = NULL;
random_search_resetInstance(random_search, crt);
optimalAction = random_search_planning(random_search, ns[k]);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0;
freeState(crt);
free(optimalAction);
crt = nextState;
sumRewards += reward;
if(isTerminal)
break;
}
random_search_resetInstance(random_search, crt);
freeState(crt);
printf(">>>>>>>>>>>>>> %uth initial state processed with h=%u and n=%u of iteration %u\n", l + 1, hs[j], ns[k], i+1);
fflush(NULL);
}
fprintf(results, "%u,%u,%.15f\n", hs[j],ns[k], sumRewards / (double)n);
printf(">>>>>>>>>>>>>> n = %u done\n\n", ns[k]);
fflush(NULL);
}
printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> h = %u done \n\n", hs[j]);
fflush(NULL);
}
fprintf(results,"\n");
printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ITERATION %u DONE <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n\n\n", i+1);
fflush(NULL);
}
fclose(results);
arg_freetable(argtable, 7);
for(i = 0; i < n; i++)
freeState(initialStates[i]);
free(initialStates);
random_search_uninitInstance(&random_search);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
double discountFactor = 0.9;
FILE* initFileFd = NULL;
double* setPoints = NULL;
unsigned int nbSetPoints = 0;
unsigned int maxDepth = 0;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int minDepth = 1;
unsigned int crtDepth = 0;
unsigned int maxNbIterations = 0;
unsigned int nbSteps = 0;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
optimistic_instance* optimistic = NULL;
random_search_instance* random_search = NULL;
uct_instance* uct = NULL;
uniform_instance* uniform = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the set points");
struct arg_int* d2 = arg_int0(NULL, "min", "<n>", "Minimum depth to start from (min>0)");
struct arg_int* d = arg_int1("d", NULL, "<n>", "Maximum depth of an uniform tree which the number of call per step");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(7);
int nerrors = 0;
void* argtable[7];
argtable[0] = initFile;
argtable[1] = d2;
argtable[2] = d;
argtable[3] = s;
argtable[4] = k;
argtable[5] = where;
argtable[6] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
K = k->ival[0];
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &nbSetPoints);
setPoints = (double*)malloc(sizeof(double) * nbSetPoints);
for(; i < nbSetPoints; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
setPoints[i] = strtod(str, NULL);
}
fclose(initFileFd);
if(d2->count)
minDepth = d2->ival[0];
maxDepth = d->ival[0];
maxNbIterations = K;
nbSteps = s->ival[0];
optimistic = optimistic_initInstance(NULL, discountFactor);
random_search = random_search_initInstance(NULL, discountFactor);
uct = uct_initInstance(NULL, discountFactor);
uniform = uniform_initInstance(NULL, discountFactor);
sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps);
results = fopen(str, "w");
for(crtDepth = 1; crtDepth < minDepth; crtDepth++)
maxNbIterations += pow(K, crtDepth+1);
for(crtDepth = minDepth; crtDepth <= maxDepth; crtDepth++) {
double averages[4] = {0.0, 0.0, 0.0, 0.0};
state* crt1 = initState();
state* crt2 = copyState(crt1);
state* crt3 = copyState(crt1);
state* crt4 = copyState(crt1);
optimistic_resetInstance(optimistic, crt1);
uct_resetInstance(uct, crt3);
uniform_resetInstance(uniform, crt4);
for(i = 0; i < nbSetPoints; i++) {
unsigned int j = 0;
parameters[10] = setPoints[i];
for(; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
optimistic_keepSubtree(optimistic);
action* optimalAction = optimistic_planning(optimistic, maxNbIterations);
isTerminal = nextStateReward(crt1, optimalAction, &nextState, &reward);
freeState(crt1);
crt1 = nextState;
averages[0] += reward;
if(isTerminal < 0)
break;
}
optimistic_resetInstance(optimistic, crt1);
printf("Optimistic : %uth set point processed\n", i + 1);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
random_search_resetInstance(random_search, crt2);
action* optimalAction = random_search_planning(random_search, maxNbIterations);
isTerminal = nextStateReward(crt2, optimalAction, &nextState, &reward);
freeState(crt2);
crt2 = nextState;
averages[1] += reward;
if(isTerminal < 0)
break;
}
random_search_resetInstance(random_search, crt1);
printf("Random search: %uth set point processed\n", i + 1);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
uct_keepSubtree(uct);
action* optimalAction = uct_planning(uct, maxNbIterations);
isTerminal = nextStateReward(crt3, optimalAction, &nextState, &reward);
freeState(crt3);
crt3 = nextState;
averages[2] += reward;
if(isTerminal < 0)
break;
}
uct_resetInstance(uct, crt3);
printf("Uct : %uth set point processed\n", i + 1);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
uniform_keepSubtree(uniform);
action* optimalAction = uniform_planning(uniform, maxNbIterations);
isTerminal = nextStateReward(crt4, optimalAction, &nextState, &reward);
freeState(crt4);
crt4 = nextState;
averages[3] += reward;
if(isTerminal < 0)
break;
}
uniform_resetInstance(uniform, crt4);
printf("Uniform : %uth set point processed\n", i + 1);
printf(">>>>>>>>>>>>>> %uth set point processed\n", i + 1);
}
fprintf(results, "%u,%.15f,%.15f,%.15f,%.15f\n", maxNbIterations, averages[0] / (double)nbSetPoints, averages[1] / (double)nbSetPoints, averages[2] / (double)nbSetPoints, averages[3] / (double)nbSetPoints);
fflush(results);
freeState(crt1);
freeState(crt2);
freeState(crt3);
freeState(crt4);
printf(">>>>>>>>>>>>>> %u depth done\n\n", crtDepth);
maxNbIterations += pow(K, crtDepth+1);
}
fclose(results);
arg_freetable(argtable, 7);
free(setPoints);
optimistic_uninitInstance(&optimistic);
random_search_uninitInstance(&random_search);
uct_uninitInstance(&uct);
uniform_uninitInstance(&uniform);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
#ifdef BALL
double discountFactor = 0.9;
#else
#ifdef CART_POLE
double discountFactor = 0.95;
#else
#ifdef DOUBLE_CART_POLE
double discountFactor = 0.95;
#else
#ifdef MOUNTAIN_CAR
double discountFactor = 0.99;
#else
#ifdef ACROBOT
double discountFactor = 0.95;
#else
#ifdef BOAT
double discountFactor = 0.95;
#else
#ifdef CART_POLE_BINARY
double discountFactor = 0.95;
#else
#ifdef SWIMMER
double discountFactor = 0.95;
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
FILE* initFileFd = NULL;
state** initialStates = NULL;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int h = 0;
unsigned int* ns = NULL;
unsigned int nbN = 0;
unsigned int n = 0;
unsigned int nbSteps = 0;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
optimistic_instance* optimistic = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state");
struct arg_str* r = arg_str1("n", NULL, "<s>", "List of maximum numbers of evaluations");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(6);
int nerrors = 0;
void* argtable[6];
argtable[0] = initFile;
argtable[1] = r;
argtable[2] = s;
argtable[3] = k;
argtable[4] = where;
argtable[5] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 6);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 6);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
K = k->ival[0];
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &n);
initialStates = (state**)malloc(sizeof(state*) * n);
for(; i < n; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
initialStates[i] = makeState(str);
}
fclose(initFileFd);
nbSteps = s->ival[0];
ns = parseUnsignedIntList((char*)r->sval[0], &nbN);
optimistic = optimistic_initInstance(NULL, discountFactor);
sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps);
results = fopen(str, "w");
for(h = 0; h < nbN; h++) {
double sumRewards = 0.0;
for(i = 0; i < n; i++) {
unsigned int j = 0;
state* crt = copyState(initialStates[i]);
optimistic_resetInstance(optimistic, crt);
for(; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
optimistic_keepSubtree(optimistic);
action* optimalAction = optimistic_planning(optimistic, ns[h]);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0;
freeState(crt);
crt = nextState;
sumRewards += reward;
if(isTerminal)
break;
}
optimistic_resetInstance(optimistic, crt);
freeState(crt);
printf(">>>>>>>>>>>>>> %uth initial state processed\n", i + 1);
fflush(NULL);
}
fprintf(results, "%u,%.15f\n", ns[h], sumRewards / (double)n);
printf(">>>>>>>>>>>>>> n = %u done\n\n", ns[h]);
fflush(NULL);
}
fclose(results);
arg_freetable(argtable, 6);
for(i = 0; i < n; i++)
freeState(initialStates[i]);
free(initialStates);
optimistic_uninitInstance(&optimistic);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
double discountFactor = 0.9;
FILE* initFileFd = NULL;
double* setPoints = NULL;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int nbSetPoints = 0;
unsigned int* ns = NULL;
unsigned int nbN = 0;
unsigned int* hs = NULL;
unsigned int nbH = 0;
unsigned int nbSteps = 0;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the set points");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_str* r = arg_str1("n", NULL, "<s>", "List of ressources");
struct arg_str* z = arg_str1("h", NULL, "<s>", "List of length for the sequences");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(6);
int nerrors = 0;
void* argtable[6];
argtable[0] = initFile;
argtable[1] = r;
argtable[2] = s;
argtable[3] = z;
argtable[4] = where;
argtable[5] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 6);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 6);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &nbSetPoints);
setPoints = (double*)malloc(sizeof(double) * nbSetPoints);
for(; i < nbSetPoints; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
setPoints[i] = strtod(str, NULL);
}
fclose(initFileFd);
nbSteps = s->ival[0];
hs = parseUnsignedIntList((char*)z->sval[0], &nbH);
ns = parseUnsignedIntList((char*)r->sval[0], &nbN);
sprintf(str, "%s/%u_results_%s_%s.csv", where->filename[0], timestamp, z->sval[0], r->sval[0]);
results = fopen(str, "w");
for(i = 0; i < nbN; i++) { /* Loop on the computational ressources */
printf("Starting with %u computational ressources\n", ns[i]);
fprintf(results, "%u", ns[i]);
fflush(NULL);
unsigned int j = 0;
for(; j < nbH; j++) { /* Loop on the length of the sequences */
unsigned int k = 0;
state* crt1 = initState();
state* crt2 = copyState(crt1);
double averages[2] = {0.0,0.0};
for(; k < nbSetPoints; k++) { /* Loop on the initial states */
unsigned int l = 0;
parameters[10] = setPoints[k];
for(; l < nbSteps; l++) { /* Loop on the step */
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
sequential_direct_instance* sequential_direct = sequential_direct_initInstance(crt1, discountFactor, hs[j],1);
double* optimalAction = sequential_direct_planning(sequential_direct, ns[i]);
isTerminal = nextStateReward(crt1, optimalAction, &nextState, &reward) < 0 ? 1 : 0;
freeState(crt1);
crt1 = nextState;
averages[0] += reward;
sequential_direct_uninitInstance(&sequential_direct);
if(isTerminal)
break;
}
printf("direct: %u set point done for h=%u\n", k, hs[j]);
fflush(NULL);
for(l = 0; l < nbSteps; l++) { /* Loop on the step */
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
sequential_soo_instance* sequential_soo = sequential_soo_initInstance(crt2, discountFactor, hs[j],1);
double* optimalAction = sequential_soo_planning(sequential_soo, ns[i]);
isTerminal = nextStateReward(crt2, optimalAction, &nextState, &reward);
freeState(crt2);
crt2 = nextState;
averages[1] += reward;
sequential_soo_uninitInstance(&sequential_soo);
if(isTerminal)
break;
}
printf("soo: %u set point done for h=%u\n", k, hs[j]);
fflush(NULL);
}
freeState(crt1);
freeState(crt2);
averages[0] = averages[0] /(double)nbSetPoints;
averages[1] = averages[1] /(double)nbSetPoints;
printf("Computation with h=%u and n=%u done\n", hs[j], ns[i]);
fprintf(results, ",%.15f,%.15f", averages[0],averages[1]);
fflush(NULL);
}
printf("Computation with %u computational ressources done\n\n", ns[i]);
fprintf(results, "\n");
fflush(NULL);
}
fclose(results);
arg_freetable(argtable, 6);
free(setPoints);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
// commandline argument parser options
struct arg_lit *help = arg_lit0("h", "help", "print this help and exit");
struct arg_lit *vers = arg_lit0("v", "version", "print version information and exit");
struct arg_file *file = arg_file1("f", "file", "<file>", "font file");
struct arg_int *fh = arg_int1("g", "height", "<value>", "font height in pixels (6 or 8)");
struct arg_str *text = arg_str0("t", "text", "<value>", "text to show");
struct arg_int *scale = arg_int0("s", "scale", "<value>", "scaling for the window");
struct arg_file *export = arg_file0("e", "export", "<file>", "Export the full font to a PNG file");
struct arg_lit *split = arg_lit0(NULL, "split", "Split to separate PNG files (set path in -e).");
struct arg_end *end = arg_end(20);
void* argtable[] = {help,vers,file,fh,text,scale,export,split,end};
const char* progname = "fonttool";
// Make sure everything got allocated
if(arg_nullcheck(argtable) != 0) {
printf("%s: insufficient memory\n", progname);
goto exit_0;
}
// Parse arguments
int nerrors = arg_parse(argc, argv, argtable);
// Handle help
if(help->count > 0) {
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
printf("\nArguments:\n");
arg_print_glossary(stdout, argtable, "%-25s %s\n");
goto exit_0;
}
// Handle version
if(vers->count > 0) {
printf("%s v0.1\n", progname);
printf("Command line One Must Fall 2097 Font file editor.\n");
printf("Source code is available at https://github.com/omf2097 under MIT license.\n");
printf("(C) 2013 Tuomas Virtanen\n");
goto exit_0;
}
// Handle errors
if(nerrors > 0) {
arg_print_errors(stdout, end, progname);
printf("Try '%s --help' for more information.\n", progname);
goto exit_0;
}
// Requite either export or text
if(export->count <= 0 && text->count <= 0) {
printf("Use either --export or --text arguments!\n");
goto exit_0;
}
// Font size
int _fs = fh->ival[0];
if(_fs < 6 || _fs > 8 || _fs == 7) {
printf("Only valid values for fontsize are 6 and 8.\n");
goto exit_0;
}
// Load fonts
sd_font font;
sd_font_create(&font);
int ret = sd_font_load(&font, file->filename[0], _fs);
if(ret != SD_SUCCESS) {
printf("Couldn't load small font file! Error [%d] %s.\n", ret, sd_get_error(ret));
goto exit_1;
}
// Export or display
if(export->count > 0) {
export_to(&font, export->filename[0], (split->count > 0));
} else {
int main(int argc, char** argv) {
int ret, i;
int nerrors[NUMBER_OF_DIFFERENT_SYNTAXES + 1];
/* argtable setup */
/* SYNTAX 1: [--info] */
info1 = arg_lit1(NULL, "info", "Show information about the FLI camera");
end1 = arg_end(20);
void * argtable1[] = {info1, end1};
argtable[1] = argtable1;
/* SYNTAX 2: [--get-temperature] */
gettemp2 = arg_lit1(NULL, "get-temperature", "Print the temperature of the CCD, base and cooling power");
end2 = arg_end(20);
void * argtable2[] = {gettemp2, end2};
argtable[2] = argtable2;
/* SYNTAX 3: [--set-temperature] */
settemp3 = arg_int1(NULL, "set-temperature", "N", "Set the temperature of the CCD (in Celsius)");
end3 = arg_end(20);
void * argtable3[] = {settemp3, end3};
argtable[3] = argtable3;
/* SYNTAX 4: [--fan] */
fan4 = arg_str1(NULL, "fan", "(on|off)", "Turn on or off the fan");
end4 = arg_end(20);
void * argtable4[] = {fan4, end4};
argtable[4] = argtable4;
/* SYNTAX 5: [--shutter] */
shutter5 = arg_str1(NULL, "shutter", "(open|close)", "Open or close the shutter");
end5 = arg_end(20);
void * argtable5[] = {shutter5, end5};
argtable[5] = argtable5;
/* SYNTAX 6: --acquire <time/sec> --shutter {open|close} --output xyz.fits
[--bin <bx>,<by>] [--offset <x0>,<y0>] [--size <sx>,<sy>]
[--mode <mode>...] [--verbose]
*/
acquire6 = arg_str1(NULL, "acquire", "<time>", "Exposure time in sec");
shutter6 = arg_str1(NULL, "shutter", "(open|close)", "Whether to open or close the shutter");
output6 = arg_file1(NULL, "output", "xyz.fits", "Output filename for the FITS file");
bin6 = arg_str0(NULL, "bin", "<bx,by>", "Binning options in X,Y format");
offset6 = arg_str0(NULL, "offset", "<x0,y0>", "Offset options in X,Y format");
size6 = arg_str0(NULL, "size", "<sx,sy>", "Sizes in X,Y format");
mode6 = arg_str0(NULL, "mode", "(1mhz|8mhz)", "Download speed");
verbose6 = arg_lit0(NULL, "verbose", "Show verbose output");
end6 = arg_end(20);
void * argtable6[] = {acquire6, shutter6, output6, bin6, offset6, size6, mode6, verbose6, end6};
argtable[6] = argtable6;
/* SYNTAX 7: [--help]*/
help7 = arg_lit1(NULL, "help", "Print this help");
end7 = arg_end(20);
void * argtable7[] = {help7, end7};
argtable[7] = argtable7;
/* verify all argtable[] entries were allocated successfully */
for (i = 1; i <= NUMBER_OF_DIFFERENT_SYNTAXES; i++) {
if (arg_nullcheck(argtable[i]) != 0) {
printf("%s: insufficient memory\n", progname);
return EXIT_FAILURE;
}
}
/* set defaults for the optional arguments */
bin6->sval[0] = "1,1";
offset6->sval[0] = "0,0";
size6->sval[0] = "4096,4096";
mode6->sval[0] = "8mhz";
/* parse all argument possibilities */
for (i = 1; i <= NUMBER_OF_DIFFERENT_SYNTAXES; i++) {
nerrors[i] = arg_parse(argc, argv, argtable[i]);
}
/* select the right command */
/* --info */
if (nerrors[1] == 0) {
if (info1->count > 0) {
ret = camera_info();
if (ret) return ret;
return 0;
}
/* --get-temperature */
} else if (nerrors[2] == 0) {
if (gettemp2->count > 0) {
ret = camera_get_temp();
if (ret) return ret;
return 0;
}
/* --set-temperature */
} else if (nerrors[3] == 0) {
if (settemp3->count > 0) {
ret = camera_set_temp(settemp3->ival[0]);
if (ret) return ret;
return 0;
}
/* --fan */
} else if (nerrors[4] == 0) {
int fan;
if (strcmp("on", fan4->sval[0]) == 0) {
fan = 1;
} else if (strcmp("off", fan4->sval[0]) == 0) {
fan = 0;
} else {
fprintf(stderr, "Cannot parse the option for --fan, see --help.\n");
return -1;
}
ret = camera_set_fan(fan);
if (ret) return ret;
return 0;
/* --shutter */
} else if (nerrors[5] == 0) {
int open_shutter;
if (strcmp("open", shutter5->sval[0]) == 0) {
open_shutter = 1;
} else if (strcmp("close", shutter5->sval[0]) == 0) {
open_shutter = 0;
} else {
fprintf(stderr, "Cannot parse the option for --shutter, see --help.\n");
return -1;
}
ret = camera_control_shutter(open_shutter);
if (ret) return ret;
return 0;
/* --acquire */
} else if (nerrors[6] == 0) {
if (acquire6->count > 0) {
/* local variables to store the arguments */
float exposure_time;
int is_dark;
char * output_filename;
char * bin_options;
char * offset_options;
char * size_options;
int bx, by;
int x0, y0;
int sx, sy;
int one_mhz_speed;
int is_verbose = 0;
/* copy const char arrays to char arrays to suppress warnings */
output_filename = (char*) malloc((strlen(output6->filename[0])) * sizeof (char));
bin_options = (char*) malloc((strlen(bin6->sval[0])) * sizeof (char));
offset_options = (char*) malloc((strlen(offset6->sval[0])) * sizeof (char));
size_options = (char*) malloc((strlen(size6->sval[0])) * sizeof (char));
strcpy(output_filename, output6->filename[0]);
strcpy(bin_options, bin6->sval[0]);
strcpy(offset_options, offset6->sval[0]);
strcpy(size_options, size6->sval[0]);
/* process arguments */
/* exposure time */
exposure_time = atof(acquire6->sval[0]);
if (exposure_time < 0) {
fprintf(stderr, "Exposure time cannot be below zero (given %f).\n", exposure_time);
return -1;
}
/* shutter */
if (strcmp("open", shutter6->sval[0]) == 0) {
is_dark = 0;
} else if (strcmp("close", shutter6->sval[0]) == 0) {
is_dark = 1;
} else {
fprintf(stderr, "Cannot parse the option for --shutter, see --help.\n");
return -1;
}
/* bin, size and offset */
ret = parse_comma_separated_values(bin_options, &bx, &by, "bin");
if (ret) return ret;
ret = parse_comma_separated_values(offset_options, &x0, &y0, "offset");
if (ret) return ret;
ret = parse_comma_separated_values(size_options, &sx, &sy, "size");
if (ret) return ret;
/* mode */
if (strcmp("1mhz", mode6->sval[0]) == 0) {
one_mhz_speed = 1;
} else if (strcmp("8mhz", mode6->sval[0]) == 0) {
one_mhz_speed = 0;
} else {
fprintf(stderr, "Cannot parse the option for --mode, see --help.\n");
return -1;
}
/* verbose */
if (verbose6->count > 0) is_verbose = 1;
ret = camera_acquire(exposure_time, is_dark, output_filename,
bx, by, x0, y0, sx, sy, one_mhz_speed, is_verbose);
if (ret) return ret;
return 0;
}
/* --help */
} else if (nerrors[7] == 0) {
if (help7) {
ret = camera_help();
if (ret) return ret;
return 0;
}
/* incorrect or partially incorrect argument syntaxes */
} else {
if (settemp3->count > 0) {
arg_print_errors(stdout, end3, progname);
printf("usage: %s ", progname);
arg_print_syntax(stdout, argtable3, "\n");
} else if (fan4->count > 0) {
arg_print_errors(stdout, end4, progname);
printf("usage: %s ", progname);
arg_print_syntax(stdout, argtable4, "\n");
} else if (acquire6->count > 0) {
arg_print_errors(stdout, end5, progname);
printf("usage: %s ", progname);
arg_print_syntax(stdout, argtable5, "\n");
} else {
printf("%s: unable to parse arguments, see syntax below:\n", progname);
ret = 0;
ret = camera_help();
return ret;
}
return EXIT_FAILURE;
}
/* no command line options at all */
printf("Try '%s --help' for more information.\n", progname);
return (EXIT_SUCCESS);
}
int main(int argc, char* argv[]) {
unsigned int i = 0;
unsigned int nbIntervals = 0;
double* intervals = NULL;
FILE* outputFileFd = NULL;
gsl_rng* rng = NULL;
unsigned int nbStates = 0;
struct arg_file* outputFile = arg_file1("o", NULL, "<file>", "The output file for the generated initial state");
struct arg_int* n = arg_int1("n", NULL, "<n>", "The number of initial states to generate");
struct arg_str* s = arg_str1(NULL, "intervals", "<s>", "The intervals for the initial states generation");
struct arg_end* end = arg_end(4);
void* argtable[4];
int nerrors = 0;
argtable[0] = outputFile;
argtable[1] = n;
argtable[2] = s;
argtable[3] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 4);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 4);
return EXIT_FAILURE;
}
nbStates = n->ival[0];
intervals = parseIntervals(s->sval[0], &nbIntervals);
rng = gsl_rng_alloc(gsl_rng_mt19937);
gsl_rng_set(rng, time(NULL));
outputFileFd = fopen(outputFile->filename[0], "w");
fprintf(outputFileFd, "%u\n", n->ival[0]);
for(; i < nbStates; i++) {
unsigned int j = 0;
for(; j < (nbIntervals - 1); j++)
fprintf(outputFileFd, "%.15f,", (fabs(intervals[(j * 2) + 1] - intervals[j * 2]) * gsl_rng_uniform(rng)) + intervals[j * 2]);
fprintf(outputFileFd, "%.15f\n", (fabs(intervals[(j * 2) + 1] - intervals[j * 2]) * gsl_rng_uniform(rng)) + intervals[j * 2]);
}
fclose(outputFileFd);
gsl_rng_free(rng);
free(intervals);
arg_freetable(argtable, 4);
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
double discountFactor = 0.9;
FILE* initFileFd = NULL;
double* setPoints = NULL;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int nbSetPoints = 0;
unsigned int* ns = NULL;
unsigned int nbN = 0;
unsigned int* hs = NULL;
unsigned int nbH = 0;
unsigned int nbSteps = 0;
unsigned int nbIterations = 0;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
random_search_instance* random_search = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the set points");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_int* it = arg_int1("i", NULL, "<n>", "Number of iterations");
struct arg_str* r = arg_str1("n", NULL, "<s>", "List of ressources");
struct arg_str* d = arg_str1("h", NULL, "<s>", "List of depth");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(7);
int nerrors = 0;
void* argtable[7];
argtable[0] = initFile;
argtable[1] = r;
argtable[2] = d;
argtable[3] = s;
argtable[4] = it;
argtable[5] = where;
argtable[6] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &nbSetPoints);
setPoints = (double*)malloc(sizeof(double) * nbSetPoints);
for(; i < nbSetPoints; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
setPoints[i] = strtod(str, NULL);
}
fclose(initFileFd);
nbSteps = s->ival[0];
nbIterations = it->ival[0];
ns = parseUnsignedIntList((char*)r->sval[0], &nbN);
hs = parseUnsignedIntList((char*)d->sval[0], &nbH);
sprintf(str, "%s/%u_results_random_search_%s.csv", where->filename[0], timestamp, r->sval[0]);
results = fopen(str, "w");
random_search = random_search_initInstance(NULL, discountFactor);
h_max = h_max_crt_depth;
for(i = 0; i < nbIterations; i++) {
unsigned int j = 0;
for(;j < nbH; j++) {
unsigned int k = 0;
crtDepth = hs[j];
for(; k < nbN; k++) { /* Loop on the computational ressources */
state* crt = initState();
double average = 0.0;
unsigned int l = 0;
printf("Starting with %u computational ressources\n", ns[k]);
fprintf(results, "%u,%u", hs[j], ns[k]);
fflush(NULL);
for(; l < nbSetPoints; l++) { /* Loop on the initial states */
unsigned int m = 0;
parameters[10] = setPoints[l];
for(; m < nbSteps; m++) { /* Loop on the step */
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
random_search_resetInstance(random_search, crt);
double* optimalAction = random_search_planning(random_search, ns[k]);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0;
freeState(crt);
crt = nextState;
average += reward;
if(isTerminal)
break;
}
random_search_resetInstance(random_search, crt);
printf("random search: %u set point done\n", l);
fflush(NULL);
}
freeState(crt);
average = average /(double)nbSetPoints;
printf("Computation with %u computational ressources done\n\n", ns[k]);
fprintf(results, ",%.15f\n", average);
fflush(NULL);
}
printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>Depth %u done\n", hs[j]);
fflush(NULL);
}
printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>ITERATION %u DONE<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n",i+1);
fprintf(results,"\n");
fflush(NULL);
}
fclose(results);
arg_freetable(argtable, 7);
free(setPoints);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
// commandline argument parser options
struct arg_lit *help = arg_lit0("h", "help", "print this help and exit");
struct arg_lit *vers = arg_lit0("v", "version", "print version information and exit");
struct arg_file *file = arg_file1("f", "file", "<file>", "Input altpals file");
struct arg_int *pal = arg_int1("p", "palette", "<number>", "Select a palette");
struct arg_file *export = arg_file0("e", "export", "<file>", "Export selected palette to GPL file");
struct arg_file *import = arg_file0("i", "import", "<file>", "Import selected palette from GPL file");
struct arg_file *output = arg_file0("o", "output", "<file>", "Output altpals file");
struct arg_end *end = arg_end(20);
void* argtable[] = {help,vers,file,pal,output,import,export,end};
const char* progname = "altpaltool";
// Make sure everything got allocated
if(arg_nullcheck(argtable) != 0) {
printf("%s: insufficient memory\n", progname);
goto exit_0;
}
// Parse arguments
int nerrors = arg_parse(argc, argv, argtable);
// Handle help
if(help->count > 0) {
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
printf("\nArguments:\n");
arg_print_glossary(stdout, argtable, "%-25s %s\n");
goto exit_0;
}
// Handle version
if(vers->count > 0) {
printf("%s v0.1\n", progname);
printf("Command line One Must Fall 2097 Altpals file editor.\n");
printf("Source code is available at https://github.com/omf2097 under MIT license.\n");
printf("(C) 2014 Tuomas Virtanen\n");
goto exit_0;
}
// Handle errors
if(nerrors > 0) {
arg_print_errors(stdout, end, progname);
printf("Try '%s --help' for more information.\n", progname);
goto exit_0;
}
// Need import or export ...
if(pal->count > 0 && import->count == 0 && export->count == 0) {
printf("Define either --import or --export with --palette!\n");
goto exit_0;
}
// Make sure output is set
if(import->count > 0 && output->count <= 0) {
printf("Define --output with --import.\n");
goto exit_0;
}
// Load file
sd_altpal_file alt;
sd_altpal_create(&alt);
int ret = sd_altpals_load(&alt, file->filename[0]);
if(ret != SD_SUCCESS) {
printf("Unable to load altpals file %s: %s.\n",
file->filename[0],
sd_get_error(ret));
goto exit_1;
}
// Check ID
int pal_id = pal->ival[0];
if(pal_id < 0 || pal_id > SD_ALTPALS_PALETTES) {
printf("Palette index %d does not exist!\n", pal_id);
goto exit_1;
}
// Check what to do
if(export->count > 0) {
ret = sd_palette_to_gimp_palette(&alt.palettes[pal_id], export->filename[0]);
if(ret == SD_SUCCESS) {
printf("Palette %d exported to file %s succesfully.\n",
pal_id,
export->filename[0]);
} else {
int main(int argc, char *argv[]) {
// commandline argument parser options
struct arg_lit *help = arg_lit0("h", "help", "print this help and exit");
struct arg_lit *vers = arg_lit0("v", "version", "print version information and exit");
struct arg_file *file = arg_file1("f", "file", "<file>", "language file");
struct arg_int *str = arg_int1("s", "string", "<value>", "print language string # (-1 for all).");
struct arg_end *end = arg_end(20);
void* argtable[] = {help,vers,file,str,end};
const char* progname = "languagetool";
// Make sure everything got allocated
if(arg_nullcheck(argtable) != 0) {
printf("%s: insufficient memory\n", progname);
goto exit_0;
}
// Parse arguments
int nerrors = arg_parse(argc, argv, argtable);
// Handle help
if(help->count > 0) {
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
printf("\nArguments:\n");
arg_print_glossary(stdout, argtable, "%-25s %s\n");
goto exit_0;
}
// Handle version
if(vers->count > 0) {
printf("%s v0.1\n", progname);
printf("Command line One Must Fall 2097 Language file editor.\n");
printf("Source code is available at https://github.com/omf2097 under MIT license.\n");
printf("(C) 2013 Tuomas Virtanen\n");
goto exit_0;
}
// Handle errors
if(nerrors > 0) {
arg_print_errors(stdout, end, progname);
printf("Try '%s --help' for more information.\n", progname);
goto exit_0;
}
// Get strings
sd_language *language = sd_language_create();
if(sd_language_load(language, file->filename[0])) {
printf("Language file could not be loaded!\n");
goto exit_0;
}
// Print
int id = str->ival[0];
if(id < 0) {
for(int i = 0; i < language->count; i++) {
printf("Title: %s\n", language->strings[i].description);
printf("Data: %s\n", language->strings[i].data);
}
} else if(id >= 0 && id < language->count) {
printf("Title: %s\n", language->strings[id].description);
printf("Data: %s\n", language->strings[id].data);
} else {
printf("String not found!\n");
}
sd_language_delete(language);
exit_0:
arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0]));
return 0;
}
int main(int argc, char* argv[]) {
double discountFactor;
unsigned int maxNbEvaluations;
char isTerminal = 0;
char keepingTree = 0;
int nbTimestep = -1;
unsigned int branchingFactor = 0;
#ifdef USE_SDL
char isDisplayed = 1;
char isFullscreen = 1;
char verbose = 0;
char resolution[255] = "640x480";
#else
char verbose = 1;
#endif
uniform_instance* instance = NULL;
state* crtState = NULL;
state* nextState = NULL;
double reward = 0.0;
action* optimalAction = NULL;
struct arg_dbl* g = arg_dbl1("g", "discountFactor", "<d>", "The discount factor for the problem");
struct arg_int* n = arg_int1("n", "nbEvaluations", "<n>", "The number of evaluations");
struct arg_int* s = arg_int0("s", "nbtimestep", "<n>", "The number of timestep");
struct arg_int* b = arg_int0("b", "branchingFactor", "<n>", "The branching factor of the problem");
struct arg_lit* k = arg_lit0("k", NULL, "Keep the subtree");
struct arg_str* i = arg_str0(NULL, "state", "<s>", "The initial state to use");
#ifdef USE_SDL
struct arg_lit* d = arg_lit0("d", NULL, "Display the viewer");
struct arg_lit* f = arg_lit0("f", NULL, "Fullscreen");
struct arg_lit* v = arg_lit0("v", NULL, "Verbose");
struct arg_str* r = arg_str0(NULL, "resolution", "<s>", "The resolution of the display window");
void* argtable[11];
int nbArgs = 10;
#else
void* argtable[7];
int nbArgs = 6;
#endif
struct arg_end* end = arg_end(nbArgs+1);
int nerrors = 0;
s->ival[0] = -1;
b->ival[0] = 0;
argtable[0] = g; argtable[1] = n; argtable[2] = s; argtable[3] = k; argtable[4] = b; argtable[5] = i;
#ifdef USE_SDL
argtable[6] = d;
argtable[7] = f;
argtable[8] = v;
argtable[9] = r;
#endif
argtable[nbArgs] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, nbArgs+1);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, nbArgs+1);
return EXIT_FAILURE;
}
discountFactor = g->dval[0];
maxNbEvaluations = n->ival[0];
branchingFactor = b->ival[0];
initGenerativeModelParameters();
if(branchingFactor)
K = branchingFactor;
initGenerativeModel();
if(i->count)
crtState = makeState(i->sval[0]);
else
crtState = initState();
#if USE_SDL
isDisplayed = d->count;
isFullscreen = f->count;
verbose = v->count;
if(r->count)
strcpy(resolution, r->sval[0]);
#endif
nbTimestep = s->ival[0];
keepingTree = k->count;
arg_freetable(argtable, nbArgs+1);
instance = uniform_initInstance(crtState, discountFactor);
#ifdef USE_SDL
if(isDisplayed) {
if(initViewer(resolution, uniform_drawingProcedure, isFullscreen) == -1)
return EXIT_FAILURE;
viewer(crtState, NULL, 0.0, instance);
}
#endif
do {
if(keepingTree)
uniform_keepSubtree(instance);
else
uniform_resetInstance(instance, crtState);
optimalAction = uniform_planning(instance, maxNbEvaluations);
isTerminal = nextStateReward(crtState, optimalAction, &nextState, &reward);
freeState(crtState);
crtState = nextState;
if(verbose) {
printState(crtState);
printAction(optimalAction);
printf("reward: %f depth: %u\n", reward, uniform_getMaxDepth(instance));
}
#ifdef USE_SDL
} while(!isTerminal && (nbTimestep < 0 || --nbTimestep) && !viewer(crtState, optimalAction, reward, instance));
#else
} while(!isTerminal && (nbTimestep < 0 || --nbTimestep));
/** Processes command line arguments using argtable library
<p>To add a smafeopt class backed command line argument,
perform the following steps:
<ol>
<li>Add public member in smafeopt.h (smafe)
<li>Assign default value in smafeopt.cpp (smafe)
<li>Define a new struct (arg_lit, arg_int etc) in this method
(processCommandLineArguments()) and add details (shortopts, longopts)
according to appropriate constructor
<li>Add this struct to void* argtable[] array
<li>Transfer the value from the struct to the smafeopt instance
(<i>if (nerrors == 0)</i> block)
</ol>
* @param argc number of command line arguments (from main())
* @param argv array of c-strings (from main())
* @param so initialized, empty smafeopt instance that is to be filled
*/
void processCommandLineArguments(int argc, char* argv[]) {
/* Define the allowable command line options, collecting them in argtable[] */
/* Syntax 1: command line arguments and file or dir */
// daemon options
struct arg_str
*arg_daemonID =
arg_str0(
NULL,
"id",
"IDENTIFIER",
"Identifier for daemon instance. IDENTIFIER must not contain whitespace or special chars.");
struct arg_int *arg_interval = arg_int0(NULL, "interval", "MINUTES",
"Polling interval in minutes. Default is 10");
struct arg_lit
*arg_no_daemon =
arg_lit0(NULL, "no-daemon",
"Runs program as normal forground process (no forking). No logfile allowed");
struct arg_str *arg_log = arg_str0(NULL, "log", "FILENAME",
"Name of logfile. If not specified, a random name is chosen.");
struct arg_lit *arg_stats = arg_lit0(NULL, "stats",
"Print number of open tasks and exit");
//struct arg_str *arg_passphrase = arg_str0("p", "passphrase", "PASSPHRASE", "Passphrase for database encryption (max 63 characters)");
struct arg_int
*arg_verbose =
arg_int0(
"v",
"verbosity",
"0-6",
"Set verbosity level (=log level). The lower the value the more verbose the program behaves. Default is 3");
struct arg_int *arg_lFvtId = arg_int1("f", "featurevectorype_id",
"FEATUREVECTORTYPE_ID",
"Featurevectortype_id to use. Must be contained in the database.");
struct arg_str *arg_dbconf = arg_str0(NULL, "dbconf", "DATABASE-CONFIGURATION-FILE",
"Specify file that contains database connection details");
struct arg_lit *help = arg_lit0(NULL, "help", "print this help and exit");
struct arg_end *end = arg_end(20);
void* argtable[] = { arg_daemonID, arg_lFvtId,
arg_no_daemon, arg_interval, arg_dbconf, arg_verbose, arg_log,
arg_stats, help, end };
int nerrors;
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0) {
/* NULL entries were detected, some allocations must have failed */
std::cerr << PROGNAME << ": insufficient memory" << std::endl;
exit(2);
}
// if no parameter is given: show help
if (argc > 1) {
// Parse the command line as defined by argtable[]
nerrors = arg_parse(argc, argv, argtable);
} else {
// no argument given
help->count = 1;
}
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0) {
std::cout << "Usage: " << PROGNAME;
arg_print_syntax(stdout, argtable, "\n");
std::cout << std::endl;
arg_print_glossary(stdout, argtable, " %-27s %s\n");
std::cout << "" << std::endl;
#if defined(SMAFEDISTD_REAL_DAEMON)
std::cout
<< "This program works as a daemon, i.e., it is executed in the background and not attached to a shell."
<< std::endl;
std::cout << std::endl;
std::cout
<< "Currently, the preferred way to stop a running daemon is sending a SIGTERM signal to it. Then, the program will exit after finishing the current job (if any)."
<< std::endl;
std::cout << std::endl;
std::cout << "How to send a SIGTERM signal to a running instance:"
<< std::endl;
std::cout << " 1) ps aux | grep " << PROGNAME
<< " (this gives you the <PID>)" << std::endl;
std::cout << " 2) kill <PID>" << std::endl;
#else
std::cout << "This program works NOT as a daemon because this platform does not support forking (or, there has been a problem at compiling the application)." << std::endl;
#endif
exit(1);
}
if (nerrors == 0) {
// verbosity level
// must be on top
if (arg_verbose->count > 0) {
loglevel_requested = arg_verbose->ival[0];
// change loglevel
SmafeLogger::smlog->setLoglevel(loglevel_requested);
} else
loglevel_requested = SmafeLogger::DEFAULT_LOGLEVEL;
// identifier
if (arg_daemonID->count > 0) {
daemonId = std::string(arg_daemonID->sval[0]);
if (daemonId == SmafeStoreDB::STATUSOK || (0 == daemonId.find(SmafeStoreDB::STATUSFAILED))) {
SMAFELOG_FUNC(SMAFELOG_FATAL, "Identifier " + daemonId + " is illegal. It must not be '"+SmafeStoreDB::STATUSOK+"' and must not start with '"+SmafeStoreDB::STATUSFAILED+"'");
exit(2);
}
} else {
if (arg_stats->count == 0) {
// is actually mandatory, only for --stats and --list it is not.
SMAFELOG_FUNC(SMAFELOG_FATAL, "Please specify an identifier for this daemon (--id).");
exit(2);
}
}
// logfile
// uses daemonId
if (arg_log->count > 0) {
sLogfilename = std::string(arg_log->sval[0]);
} else {
sLogfilename = std::string(PROGNAME) + "." + stringify(my_getpid())
+ ".log";
}
// no-daemon
if (arg_no_daemon->count > 0) {
#if defined(SMAFEDISTD_REAL_DAEMON)
if (arg_log->count > 0) {
SMAFELOG_FUNC(SMAFELOG_FATAL, "--no-daemon and --log cannot be combined. If program runs as forground process output is written to stdout and stderr.");
exit(1);
} else {
// no daemon
SMAFELOG_FUNC(SMAFELOG_INFO, "Running in 'normal mode' (ie, not as daemon)");
bNoDaemon = true;
}
#else
SMAFELOG_FUNC(SMAFELOG_INFO, "Parameter --no-daemon is implied since this executable is compiled without daemon mode support.");
#endif
}
// stats
if (arg_stats->count > 0) {
bPrintStatsOnly = true;
#if defined(SMAFEDISTD_REAL_DAEMON)
SMAFELOG_FUNC(SMAFELOG_INFO, "Stats mode, so running in 'normal mode' (ie, not as daemon)");
bNoDaemon = true;
#endif
} else
bPrintStatsOnly = false;
// polling interval
if (arg_interval->count > 0)
pollInterval = arg_interval->ival[0];
if (pollInterval == 0) {
SMAFELOG_FUNC(SMAFELOG_WARNING, "Polling interval set to 0 which means that the daemon will perform busy waiting.");
}
if (pollInterval < 0) {
SMAFELOG_FUNC(SMAFELOG_INFO, "Daemon will stop after last finished task (since pollInterval < 0)");
} else {
SMAFELOG_FUNC(SMAFELOG_INFO, "polling interval=" + stringify(pollInterval));
}
// fvtid
if (arg_lFvtId->count > 0)
lFvtId = arg_lFvtId->ival[0];
else {
SMAFELOG_FUNC(SMAFELOG_FATAL, "Specify fvtype_id");
exit(2);
}
if (lFvtId < 0) {
SMAFELOG_FUNC(SMAFELOG_FATAL, "Featurevectortype_id cannot be < 0");
exit(2);
}
// ---- db stuff
// db options file
if (arg_dbconf->count > 0) {
SMAFELOG_FUNC(SMAFELOG_DEBUG, "Parsing db configuration file");
so->parseDbOpts(std::string(arg_dbconf->sval[0]));
}
/*
// Passphrase
if (arg_passphrase->count > 0) {
if (strlen(arg_passphrase->sval[0]) <= 63) {
strcpy(verysecretpassphrase, arg_passphrase->sval[0]);
SMAFELOG_FUNC(SMAFELOG_INFO, "Data encryption / decryption is enabled.");
} else {
SMAFELOG_FUNC(SMAFELOG_FATAL, "Passphrase too long. Max 63 characters.");
exit(2);
}
} else {
SMAFELOG_FUNC(SMAFELOG_INFO, "Data encryption / decryption is DISABLED!");
}
*/
// switch to logfile was here
} else {
arg_print_errors(stdout, end, PROGNAME);
std::cout << "--help gives usage information" << std::endl;
exit(1);
}
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
}
int main(int argc, char* argv[]) {
#ifdef BALL
double discountFactor = 0.9;
#else
#ifdef CART_POLE
double discountFactor = 0.95;
#else
#ifdef DOUBLE_CART_POLE
double discountFactor = 0.95;
#else
#ifdef MOUNTAIN_CAR
double discountFactor = 0.99;
#else
#ifdef ACROBOT
double discountFactor = 0.95;
#else
#ifdef BOAT
double discountFactor = 0.95;
#else
#ifdef SWIMMER
double discountFactor = 0.95;
#endif
#endif
#endif
#endif
#endif
#endif
#endif
FILE* initFileFd = NULL;
state** initialStates = NULL;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int nbInitialStates = 0;
unsigned int* ns = NULL;
unsigned int nbN = 0;
double* Ls = NULL;
unsigned int nbL = 0;
unsigned int nbSteps = 0;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
lipschitzian_instance* lipschitzian = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_str* r = arg_str1("n", NULL, "<s>", "List of ressources");
struct arg_str* z = arg_str1("L", NULL, "<s>", "List of Lipschitz coefficients to try");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(6);
int nerrors = 0;
void* argtable[6];
argtable[0] = initFile;
argtable[1] = r;
argtable[2] = s;
argtable[3] = z;
argtable[4] = where;
argtable[5] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 6);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 6);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &nbInitialStates);
initialStates = (state**)malloc(sizeof(state*) * nbInitialStates);
for(; i < nbInitialStates; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
initialStates[i] = makeState(str);
}
fclose(initFileFd);
nbSteps = s->ival[0];
Ls = parseDoubleList((char*)z->sval[0], &nbL);
ns = parseUnsignedIntList((char*)r->sval[0], &nbN);
sprintf(str, "%s/%u_results_%s_%s.csv", where->filename[0], timestamp, z->sval[0], r->sval[0]);
results = fopen(str, "w");
lipschitzian = lipschitzian_initInstance(NULL, discountFactor, 0.0);
for(i = 0; i < nbN; i++) { /* Loop on the computational ressources */
fprintf(results, "%u", ns[i]);
printf("Starting with %u computational ressources\n", ns[i]);
fflush(NULL);
unsigned int j = 0;
for(; j < nbL; j++) { /* Loop on the Lispchitz constant */
unsigned int k = 0;
double average = 0.0;
lipschitzian->L = Ls[j];
for(; k < nbInitialStates; k++) { /* Loop on the initial states */
unsigned int l = 0;
double sumRewards = 0.0;
state* crt = copyState(initialStates[k]);
lipschitzian_resetInstance(lipschitzian, crt);
for(; l < nbSteps; l++) { /* Loop on the step */
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
double* optimalAction = lipschitzian_planning(lipschitzian, ns[i]);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0;
free(optimalAction);
freeState(crt);
crt = nextState;
sumRewards += reward;
lipschitzian_resetInstance(lipschitzian,crt);
if(isTerminal)
break;
}
average += sumRewards;
freeState(crt);
printf("Computation of the %u initial state done with L=%f\n", k, Ls[j]);
fflush(NULL);
}
average = average /(double)nbInitialStates;
fprintf(results, ",%.15f", average);
printf("Computation with L=%f and n=%u done\n", Ls[j], ns[i]);
fflush(NULL);
}
fprintf(results,"\n");
printf("Computation with %u computational ressources done\n\n", ns[i]);
fflush(NULL);
}
fclose(results);
arg_freetable(argtable, 6);
for(i = 0; i < nbInitialStates; i++)
freeState(initialStates[i]);
free(initialStates);
lipschitzian_uninitInstance(&lipschitzian);
free(ns);
free(Ls);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
struct arg_int *a = arg_int1(NULL,NULL,"a","a is <int>");
struct arg_int *b = arg_int0(NULL,NULL,"b","b is <int>");
struct arg_int *c = arg_int0(NULL,NULL,"c","c is <int>");
struct arg_int *d = arg_intn("dD","delta","<int>",0,3,"d can occur 0..3 times");
struct arg_int *e = arg_int0(NULL,"eps,eqn","<int>","eps is optional");
struct arg_int *f = arg_intn("fF","filler","<int>",0,3,"f can occur 0..3 times");
struct arg_lit *help = arg_lit0(NULL,"help","print this help and exit");
struct arg_end *end = arg_end(20);
void* argtable[] = {a,b,c,d,e,f,help,end};
int nerrors;
int exitcode=0;
int i;
long sum=0;
/*
printf("a=%p\n",a);
printf("b=%p\n",b);
printf("c=%p\n",c);
printf("d=%p\n",d);
printf("e=%p\n",e);
printf("f=%p\n",f);
printf("help=%p\n",help);
printf("end=%p\n",end);
printf("argtable=%p\n",argtable);
*/
/* print the command line */
for (i=0; i<argc; i++)
printf("%s ",argv[i]);
printf("\n");
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0)
{
/* NULL entries were detected, some allocations must have failed */
printf("%s: insufficient memory\n",argv[0]);
exitcode=1;
goto exit;
}
/* allow missing argument values for the f argument, and set defaults to -1 */
f->hdr.flag |= ARG_HASOPTVALUE;
for (i=0; i<f->hdr.maxcount; i++)
f->ival[i] = -1;
/* Parse the command line as defined by argtable[] */
nerrors = arg_parse(argc,argv,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("Usage: %s ", argv[0]);
arg_print_syntax(stdout,argtable,"\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
exitcode=0;
goto exit;
}
/* If the parser returned any errors then display them and exit */
if (nerrors > 0)
{
/* Display the error details contained in the arg_end struct.*/
arg_print_errors(stdout,end,argv[0]);
exitcode=1;
goto exit;
}
/* parsing complete, verify all args sum to zero */
for (i=0; i<a->count; i++)
{
printf("a[%d]=%d\n",i,a->ival[i]);
sum += a->ival[i];
}
for (i=0; i<b->count; i++)
{
printf("b[%d]=%d\n",i,b->ival[i]);
sum += b->ival[i];
}
for (i=0; i<c->count; i++)
{
printf("c[%d]=%d\n",i,c->ival[i]);
sum += c->ival[i];
}
for (i=0; i<d->count; i++)
{
printf("d[%d]=%d\n",i,d->ival[i]);
sum += d->ival[i];
}
for (i=0; i<e->count; i++)
{
printf("e[%d]=%d\n",i,e->ival[i]);
sum += e->ival[i];
}
for (i=0; i<f->count; i++)
{
printf("f[%d]=%d\n",i,f->ival[i]);
sum += f->ival[i];
}
printf("sum=%ld\n",sum);
if (sum!=0)
{
printf("%s: error - sum=%ld is non-zero\n",argv[0],sum);
exitcode=1;
goto exit;
}
exit:
/* deallocate each non-null entry in argtable[] */
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
printf("%s: exitcode=%d\n\n",argv[0],exitcode);
/* close stdin and stdout to stop memcheck whining about their memory not being freed */
fclose(stdin);
fclose(stdout);
return exitcode;
}