int main(int argc, char** argv)
{
cc_config_t config;
dataset_t* data;
clique_list_t* cl;
matrix_t* matrix;
group_list_t* groups;
#ifdef WITH_LIMITS
struct rlimit cpu_limit = { 900, 900 };
struct rlimit mem_limit = { 419430400, 419430400};
setrlimit(RLIMIT_CPU, &cpu_limit );
setrlimit(RLIMIT_AS, &mem_limit );
#endif
configure(&config, argc, argv);
data = dataset_load(config.datfile);
cl = clique_list_load(config.clfile);
printf("Generate matrix...\n");
matrix = matrix_create(data, cl, sizeof(int), NULL, boolean_connection);
/* matrix_print_int(matrix); */
printf("Generate group list...\n");
groups = group_list_from_clique_list(cl);
/* group_list_print(groups); */
printf("Merging groups...\n");
group_list_merge(groups, boolean_strength, NULL, matrix);
group_list_save(groups, config.grpfile);
group_list_destroy(groups);
matrix_destroy(matrix);
clique_list_destroy(cl);
dataset_destroy(&data);
return 0;
}
int main(int argc, char** argv)
{
map_config_t config;
dataset_t* dataset;
map_t* map;
configure(&config, argc, argv);
if(config.ot == OT_CREATE)
{
dataset = dataset_load(config.infile);
if(dataset)
{
map = map_create(dataset, &config.level);
if(config.print)
map_print(map);
map_save(config.outfile, map);
map_destroy(map);
}
dataset_destroy(&dataset);
}
else if(config.ot == OT_READ)
{
map = map_load(config.infile);
if(config.print)
map_print(map);
map_destroy(map);
}
return 0;
}
int main(int argc, char** argv)
{
wc_config_t config;
dataset_t* data;
clique_list_t* cl;
matrix_t* matrix;
group_list_t* groups;
wc_data_t wc_data;
#ifdef WITH_LIMITS
struct rlimit cpu_limit = { 900, 900 };
struct rlimit mem_limit = { 419430400, 419430400};
setrlimit(RLIMIT_CPU, &cpu_limit );
setrlimit(RLIMIT_AS, &mem_limit );
#endif
configure(&config, argc, argv);
data = dataset_load(config.datfile);
cl = clique_list_load(config.clfile);
wc_data.emap = enumerated_map_load(config.empfile);
wc_data.fi = frequent_itemset_list_load(config.fifile, 0);
printf("Generate matrix...\n");
wc_data.threshold = config.threshold;
matrix = matrix_create(data, cl, sizeof(double), &wc_data, alignment_amount);
/* matrix_print_int(matrix); */
printf("Generate group list...\n");
groups = group_list_from_clique_list(cl);
/* group_list_print(groups); */
printf("Merging groups...\n");
wc_data.matrix = matrix;
group_list_merge(groups, wc_strength, NULL, &wc_data);
group_list_save(groups, config.grpfile);
group_list_destroy(groups);
matrix_destroy(matrix);
enumerated_map_destroy(wc_data.emap);
frequent_itemset_list_destroy(wc_data.fi);
clique_list_destroy(cl);
dataset_destroy(&data);
return 0;
}
int main(int argc, char** argv)
{
/* configuration for the visualization program */
visualize_config_t config;
/* reference to the loaded dataset */
dataset_t* dataset;
group_list_t* groups = NULL;
configure(&config, argc, argv);
/* load dataset from input file */
dataset = dataset_load(config.input);
if(dataset)
{
/* if a group list is defined, load that one too */
if(config.have_groups)
groups = group_list_load(config.grpfile);
/* if the dataset is supposed to be printed to stdout in text format,
* then do so */
if(config.print)
dataset_print(dataset);
/* now draw the dataset */
dataset_draw(&config, dataset, groups);
/* release group list from memory if there is one */
if(groups)
group_list_destroy(groups);
/* release dataset from memory */
dataset_destroy(&dataset);
}
return 0;
}
int main(int argc, char **argv)
{
/* These variables are for command-line options.
*/
double mag = 1.0, etol = 10e-3, detol = 10e-8, rate = 0.1;
int seed = 0, minepochs = 10, maxepochs = 100;
char *afunc = "tanh", *alg = "cgpr", *srch = "cubic";
/* The OPTION array is used to easily parse command-line options.
*/
OPTION opts[] = {
{ "-seed", OPT_INT, &seed, "random number seed" },
{ "-minepochs", OPT_INT, &minepochs, "minimum # of training steps" },
{ "-maxepochs", OPT_INT, &maxepochs, "maximum # of training steps" },
{ "-afunc", OPT_STRING, &afunc, "act. function for hidden node"},
{ "-mag", OPT_DOUBLE, &mag, "max size of initial weights" },
{ "-etol", OPT_DOUBLE, &etol, "error tolerance" },
{ "-detol", OPT_DOUBLE, &detol, "delta error tolerance" },
{ "-rate", OPT_DOUBLE, &rate, "learning rate" },
{ "-alg", OPT_STRING, &alg, "training algorithm" },
{ "-srch", OPT_STRING, &srch, "line search" },
{ NULL, OPT_NULL, NULL, NULL }
};
/* The DATASET and the NN that we will use.
*/
DATASET *data;
NN *nn;
/* Get the command-line options.
*/
get_options(argc, argv, opts, help_string, NULL, 0);
/* Set the random seed.
*/
srandom(seed);
nn = nn_create("4 2 4"); /* 2-2-1 architecture. */
nn_link(nn, "0 -l-> 1"); /* Inputs to hidden link. */
nn_link(nn, "1 -l-> 2"); /* Hidden to output link. */
/* Set the Activation functions of the hidden and output layers and
* initialize the weights to uniform random values between -/+mag.
*/
nn_set_actfunc(nn, 1, 0, afunc);
nn_set_actfunc(nn, 2, 0, "logistic");
nn_init(nn, mag);
/* Convert the C matrix into a DATASET. There are two inputs, one
* output, and four patterns total.
*/
data = dataset_create(&dsm_matrix_method,
dsm_c_matrix(&rawdata[0][0], 4, 4, 4));
/* Tell the NN how to train itself.
*/
nn->info.train_set = data;
nn->info.opt.min_epochs = minepochs;
nn->info.opt.max_epochs = maxepochs;
nn->info.opt.error_tol = etol;
nn->info.opt.delta_error_tol = detol;
nn->info.opt.hook = training_hook;
nn->info.opt.rate = rate;
if(strcmp(srch, "hybrid") == 0)
nn->info.opt.stepf = opt_lnsrch_hybrid;
else if(strcmp(srch, "golden") == 0)
nn->info.opt.stepf = opt_lnsrch_golden;
else if(strcmp(srch, "cubic") == 0)
nn->info.opt.stepf = opt_lnsrch_cubic;
else if(strcmp(srch, "none") == 0)
nn->info.opt.stepf = NULL;
if(strcmp(alg, "cgpr") == 0)
nn->info.opt.engine = opt_conjgrad_pr;
else if(strcmp(alg, "cgfr") == 0)
nn->info.opt.engine = opt_conjgrad_fr;
else if(strcmp(alg, "qndfp") == 0)
nn->info.opt.engine = opt_quasinewton_dfp;
else if(strcmp(alg, "qnbfgs") == 0)
nn->info.opt.engine = opt_quasinewton_bfgs;
else if(strcmp(alg, "lm") == 0)
nn->info.opt.engine = opt_levenberg_marquardt;
else if(strcmp(alg, "bp") == 0) {
nn->info.opt.engine = opt_gradient_descent;
nn->info.opt.stepf = NULL;
nn->info.subsample = 1;
nn->info.opt.stepf = nn_lnsrch_search_then_converge;
nn->info.opt.momentum = 0.9;
nn->info.stc_eta_0 = 1;
nn->info.stc_tau = 100;
}
/* Do the training. This will print out the epoch number and
* The error level until trianing halts via one of the stopping
* criterion.
*/
nn_train(nn);
/* Print out each input training pattern and the respective
* NN output.
*/
printf("--------------------\n");
nn_offline_test(nn, data, testing_hook);
#if 1
{
const double dw = 0.000001;
double jj1, jj2, *Rg, Rin[4], Rdout[4], dedy[4], err;
int j, k, l, n = nn->numweights;
Rg = allocate_array(1, sizeof(double), nn->numweights);
nn->need_all_grads = 1;
for(k = 0; k < 4; k++) {
nn_forward(nn, &rawdata[k][0]);
for(l = 0; l < nn->numout; l++)
dedy[l] = nn->y[l] - rawdata[k][l];
nn_backward(nn, dedy);
for(l = 0; l < nn->numout; l++)
/* Fixed */
Rin[l] = nn->dx[l] - dedy[l];
nn_Rforward(nn, Rin, NULL);
for(l = 0; l < nn->numout; l++)
/* Fixed */
Rdout[l] = nn->Ry[l] - nn->Rx[l];
nn_Rbackward(nn, Rdout);
nn_get_Rgrads(nn, Rg);
for(j = 0; j < n; j++) {
nn_forward(nn, &rawdata[k][0]);
for(l = 0; l < nn->numout; l++)
dedy[l] = nn->y[l] - rawdata[k][l];
nn_backward(nn, dedy);
jj1 = 0;
for(l = 0; l < nn->numout; l++)
jj1 += 0.5 * (dedy[l] - nn->dx[l]) * (dedy[l] - nn->dx[l]);
*nn->weights[j] += dw;
nn_forward(nn, &rawdata[k][0]);
for(l = 0; l < nn->numout; l++)
dedy[l] = nn->y[l] - rawdata[k][l];
nn_backward(nn, dedy);
jj2 = 0;
for(l = 0; l < nn->numout; l++)
jj2 += 0.5 * (dedy[l] - nn->dx[l]) * (dedy[l] - nn->dx[l]);
err = fabs(Rg[j] - (jj2 - jj1) / dw) / fabs(Rg[j]);
printf("(%d, %2d) ja = % .5e jn = % .5e error = % .2e %s\n",
k, j, Rg[j], (jj2 - jj1) / dw,
err, (err > 10e-4) ? "BAD" : "GOOD");
*nn->weights[j] -= dw;
}
}
}
#endif
/* Free up everything.
*/
nn_destroy(nn);
dsm_destroy_matrix(dataset_destroy(data));
nn_shutdown();
/* Bye.
*/
exit(0);
}
int main(int argc, char **argv)
{
/* These variables are for command-line options.
*/
double var = 0.0;
int seed = 0, nbasis = 4, norm = 0;
/* The OPTION array is used to easily parse command-line options.
*/
OPTION opts[] = {
{ "-var", OPT_DOUBLE, &var, "variance of basis functions" },
{ "-seed", OPT_INT, &seed, "random number seed" },
{ "-nbasis", OPT_INT, &nbasis, "number of basis functions" },
{ "-norm", OPT_SWITCH, &norm, "normalized basis functions?" },
{ NULL, OPT_NULL, NULL, NULL }
};
/* The DATASET and the NN that we will use.
*/
SERIES *trainser, *testser;
DATASET *trainds, *testds;
NN *nn;
/* Get the command-line options.
*/
get_options(argc, argv, opts, help_string, NULL, 0);
/* Set the random seed.
*/
srandom(seed);
testser = series_read_ascii("hp41.dat");
testser->x_width = 2;
testser->y_width = testser->offset = testser->x_delta = testser->y_delta = 1;
testser->step = testser->x_width + testser->y_width;
testds = dataset_create(&dsm_series_method, testser);
trainser = series_read_ascii("hp21.dat");
trainser->x_width = 2;
trainser->y_width = trainser->offset = trainser->x_delta = trainser->y_delta = 1;
trainser->step = trainser->x_width + trainser->y_width;
trainds = dataset_create(&dsm_series_method, trainser);
nn_rbf_basis_normalized = norm;
nn = nn_create_rbf(nbasis, var, trainds);
nn->links[0]->need_grads = 1;
nn->info.train_set = trainds;
nn->info.opt.min_epochs = 20;
nn->info.opt.max_epochs = 200;
nn->info.opt.error_tol = 1e-3;
nn->info.opt.delta_error_tol = 1e-8;
nn->info.opt.hook = training_hook;
nn->info.opt.stepf = opt_lnsrch_cubic;
nn->info.opt.engine = opt_quasinewton_bfgs;
nn_train(nn);
/* Now, let's see how well the RBF performs.
*/
nn_offline_test(nn, testds, testing_hook);
/* Free up everything.
*/
nn_destroy(nn);
series_destroy(dataset_destroy(testds));
series_destroy(dataset_destroy(trainds));
nn_shutdown();
/* Bye.
*/
exit(0);
}
int main(int argc, char **argv)
{
/* These variables are for command-line options.
*/
double mag = 0.1, etol = 10e-3, detol = 10e-8;
int seed = 0, minepochs = 10, maxepochs = 100;
char *afunc = "tanh";
/* The OPTION array is used to easily parse command-line options.
*/
OPTION opts[] = {
{ "-seed", OPT_INT, &seed, "random number seed" },
{ "-minepochs", OPT_INT, &minepochs, "minimum # of training steps" },
{ "-maxepochs", OPT_INT, &maxepochs, "maximum # of training steps" },
{ "-afunc", OPT_STRING, &afunc, "act. function for hidden node"},
{ "-mag", OPT_DOUBLE, &mag, "max size of initial weights" },
{ "-etol", OPT_DOUBLE, &etol, "error tolerance" },
{ "-detol", OPT_DOUBLE, &detol, "delta error tolerance" },
{ NULL, OPT_NULL, NULL, NULL }
};
/* The DATASET and the NN that we will use.
*/
DATASET *data;
NN *nn;
/* Set it so that xalloc_report() will print to the screen.
*/
ulog_threshold = ULOG_DEBUG;
/* Get the command-line options.
*/
get_options(argc, argv, opts, "Train a NN on XOR data.\n");
/* Set the random seed.
*/
srandom(seed);
/* Create the neural network. This one has two inputs, one hidden node,
* and a single output. The input are connected to the hidden node
* and the outputs, while the hidden node is just connected to the
* outputs.
*/
nn = nn_create("2 1 1"); /* 2-1-1 architecture. */
nn_link(nn, "0 -l-> 1"); /* Inputs to hidden link. */
nn_link(nn, "1 -l-> 2"); /* Hidden to output link. */
nn_link(nn, "0 -l-> 2"); /* Input to output short-circuit link. */
/* Set the Activation functions of the hidden and output layers and
* initialize the weights to uniform random values between -/+mag.
*/
nn_set_actfunc(nn, 1, 0, afunc);
nn_set_actfunc(nn, 2, 0, "logistic");
nn_init(nn, mag);
/* Convert the C matrix into a DATASET. There are two inputs, one
* output, and four patterns total.
*/
data = dataset_create(&dsm_matrix_method,
dsm_c_matrix(&xor_data[0][0], 2, 1, 4));
/* Tell the NN how to train itself.
*/
nn->info.train_set = data;
nn->info.opt.min_epochs = minepochs;
nn->info.opt.max_epochs = maxepochs;
nn->info.opt.error_tol = etol;
nn->info.opt.delta_error_tol = detol;
nn_train(nn);
nn_offline_test(nn, data, NULL);
nn_write(nn, "xor.net");
nn_destroy(nn);
nn = nn_read("xor.net");
nn_destroy(nn);
unlink("xor.net");
dsm_destroy_matrix(dataset_destroy(data));
nn_shutdown();
xalloc_report();
/* Bye.
*/
exit(0);
}
int main(int argc, char **argv)
{
/* These variables are for command-line options. */
double noise = 0.0;
int seed = 0, nbasis = 4, points = 100;
/* The OPTION array is used to easily parse command-line options. */
OPTION opts[] = {
{ "-noise", OPT_DOUBLE, &noise, "variance of Gaussian noise" },
{ "-seed", OPT_INT, &seed, "random number seed" },
{ "-nbasis", OPT_INT, &nbasis, "number of basis functions" },
{ "-points", OPT_INT, &points, "number of data points" },
{ NULL, OPT_NULL, NULL, NULL }
};
/* The DATASET and the NN that we will use. */
DATASET *data;
NN *nn;
/* Get the command-line options. */
get_options(argc, argv, opts, help_string, NULL, 0);
srandom(seed);
/* Make the data, and build a CNLS net. */
data = make_data(points, noise);
nn = nn_create("2 (%d %d) %d 1", nbasis, nbasis, nbasis);
nn_set_actfunc(nn, 1, 0, "linear");
nn_set_actfunc(nn, 1, 1, "exp(-x)");
nn_set_actfunc(nn, 2, 0, "linear");
nn_set_actfunc(nn, 3, 0, "linear");
nn_link(nn, "0 -l-> (1 0)");
nn_link(nn, "0 -e-> (1 1)");
nn_link(nn, "(1 1) -l-> 3");
nn_link(nn, "(1 0) (1 1) -p-> 2");
nn_link(nn, "2 -l-> 3");
nn_init(nn, 1);
nn->info.train_set = data;
nn->info.opt.min_epochs = 10;
nn->info.opt.max_epochs = 100;
nn->info.opt.error_tol = 1e-5;
nn->info.opt.delta_error_tol = 1e-7;
nn->info.opt.hook = training_hook;
nn_train(nn);
/* Now, let's see how well the NN performs.
*/
nn_offline_test(nn, data, testing_hook);
/* Free up everything.
*/
nn_destroy(nn);
series_destroy(dataset_destroy(data));
nn_shutdown();
/* Bye.
*/
exit(0);
}
int main(int argc, char **argv)
{
/* These variables are for command-line options.
*/
double mag = 1.0, etol = 10e-3, detol = 10e-8;
double rate = 0.1, moment = 0.9, subsamp = 0, decay = 0.9;
int seed = 0, minepochs = 10, maxepochs = 100;
char *afunc = "tanh";
void *linealg = opt_lnsrch_golden, *optalg = opt_conjgrad_pr;
OPTION_SET_MEMBER optsetm[] = {
{ "cgpr", opt_conjgrad_pr },
{ "cgfr", opt_conjgrad_fr },
{ "qndfp", opt_quasinewton_dfp },
{ "qnbfgs", opt_quasinewton_bfgs },
{ "lm", opt_levenberg_marquardt },
{ "gd", opt_gradient_descent },
{ NULL, NULL }
};
OPTION_SET_MEMBER linesetm[] = {
{ "golden", opt_lnsrch_golden },
{ "hybrid", opt_lnsrch_hybrid },
{ "cubic", opt_lnsrch_cubic },
{ "stc", nn_lnsrch_search_then_converge },
{ "none", NULL },
{ NULL, NULL }
};
OPTION_SET lineset = { &linealg, linesetm };
OPTION_SET optset = { &optalg, optsetm };
/* The OPTION array is used to easily parse command-line options.
*/
OPTION opts[] = {
{ "-seed", OPT_INT, &seed, "random number seed" },
{ "-minepochs", OPT_INT, &minepochs, "minimum # of training steps" },
{ "-maxepochs", OPT_INT, &maxepochs, "maximum # of training steps" },
{ "-afunc", OPT_STRING, &afunc, "act. function for hidden node"},
{ "-mag", OPT_DOUBLE, &mag, "max size of initial weights" },
{ "-etol", OPT_DOUBLE, &etol, "error tolerance" },
{ "-detol", OPT_DOUBLE, &detol, "delta error tolerance" },
{ "-rate", OPT_DOUBLE, &rate, "learning rate" },
{ "-moment", OPT_DOUBLE, &moment, "momentum rate" },
{ "-alg", OPT_SET, &optset, "training algorithm" },
{ "-subsamp", OPT_DOUBLE, &subsamp, "subsample value" },
{ "-decay", OPT_DOUBLE, &decay, "stochastic decay" },
{ "-srch", OPT_SET, &lineset, "line search" },
{ NULL, OPT_NULL, NULL, NULL }
};
/* The DATASET and the NN that we will use.
*/
DATASET *data;
NN *nn;
/* Get the command-line options.
*/
get_options(argc, argv, opts, help_string, NULL, 0);
/* Set the random seed.
*/
srandom(seed);
/* Create the neural network. This one has two inputs, one hidden node,
* and a single output. The input are connected to the hidden node
* and the outputs, while the hidden node is just connected to the
* outputs.
*/
nn = nn_create("2 1 1"); /* 2-1-1 architecture. */
nn_link(nn, "0 -l-> 1"); /* Inputs to hidden link. */
nn_link(nn, "1 -l-> 2"); /* Hidden to output link. */
nn_link(nn, "0 -l-> 2"); /* Input to output short-circuit link. */
/* Set the Activation functions of the hidden and output layers and
* initialize the weights to uniform random values between -/+mag.
*/
nn_set_actfunc(nn, 1, 0, afunc);
nn_set_actfunc(nn, 2, 0, "logistic");
nn_init(nn, mag);
/* Convert the C matrix into a DATASET. There are two inputs, one
* output, and four patterns total.
*/
data = dataset_create(&dsm_matrix_method,
dsm_c_matrix(&xor_data[0][0], 2, 1, 4));
/* Tell the NN how to train itself.
*/
nn->info.train_set = data;
nn->info.opt.min_epochs = minepochs;
nn->info.opt.max_epochs = maxepochs;
nn->info.opt.error_tol = etol;
nn->info.opt.delta_error_tol = detol;
nn->info.opt.hook = training_hook;
nn->info.opt.rate = rate;
nn->info.opt.momentum = moment;
nn->info.opt.decay = decay;
nn->info.subsample = subsamp;
if(subsamp != 0) {
nn->info.subsample = subsamp;
nn->info.opt.stochastic = 1;
}
nn->info.opt.stepf = linealg;
nn->info.opt.engine = optalg;
nn->info.stc_eta_0 = 1;
nn->info.stc_tau = 100;
/* Do the training. This will print out the epoch number and
* The error level until trianing halts via one of the stopping
* criterion.
*/
nn_train(nn);
nn->info.subsample = 0;
/* Print out each input training pattern and the respective
* NN output.
*/
printf("--------------------\n");
nn_offline_test(nn, data, testing_hook);
/* Free up everything.
*/
nn_destroy(nn);
dsm_destroy_matrix(dataset_destroy(data));
nn_shutdown();
/* Bye.
*/
exit(0);
}
int main(int argc, char **argv)
{
/* These variables are for command-line options. */
double var = 0.25, *x, **J, err;
int seed = 0, nbasis = 12, points = 200, i;
/* The OPTION array is used to easily parse command-line options. */
OPTION opts[] = {
{ "-var", OPT_DOUBLE, &var, "variance of basis functions" },
{ "-seed", OPT_INT, &seed, "random number seed" },
{ "-nbasis", OPT_INT, &nbasis, "number of basis functions" },
{ "-points", OPT_INT, &points, "number of data points" },
{ NULL, OPT_NULL, NULL, NULL }
};
/* The DATASET and the NN that we will use. */
DATASET *data;
NN *nn;
/* Get the command-line options. */
get_options(argc, argv, opts, help_string, NULL, 0);
srandom(seed);
/* Make the data, and build an rbf from it. */
data = make_data(points);
nn = nn_create("2 2");
nn_link(nn, "0 -q-> 1");
nn_set_actfunc(nn, 1, 0, "linear");
nn->info.train_set = data;
nn->info.opt.min_epochs = 10;
nn->info.opt.max_epochs = 25;
nn->info.opt.error_tol = 10e-5;
nn->info.opt.delta_error_tol = 10e-6;
nn->info.opt.hook = training_hook;
nn->info.opt.engine = opt_quasinewton_bfgs;
nn_train(nn);
J = allocate_array(2, sizeof(double), 2, 2);
/* Now test to see of nn_jacobian() works. */
for(i = 0; i < points; i++) {
x = dataset_x(data, i);
nn_jacobian(nn, x, &J[0][0]);
#if 0
printf("% 2.2f\t% 2.2f\t% 2.2f\t% 2.2f\n", nn->x[0], nn->x[1],
nn->y[0], nn->y[1]);
printf("% 2.2f\t% 2.2f\t% 2.2f\t% 2.2f\n", J[0][0], J[0][1],
J[1][0], J[1][1]);
printf("% 2.2f\t% 2.2f\t% 2.2f\t% 2.2f\n", df1dx1(x[0], x[1]),
df1dx2(x[0], x[1]), df2dx1(x[0], x[1]), df2dx2(x[0], x[1]));
printf("--\n");
#endif
#if 1
err = J[0][0] - df1dx1(x[0], x[1]);
err = err * err;
printf("% 2.2f\t", err);
err = J[0][1] - df1dx2(x[0], x[1]);
err = err * err;
printf("% 2.2f\t", err);
err = J[1][0] - df2dx1(x[0], x[1]);
err = err * err;
printf("% 2.2f\t", err);
err = J[1][1] - df2dx2(x[0], x[1]);
err = err * err;
printf("% 2.2f\n", err);
#endif
}
/* Free up everything. */
deallocate_array(J);
nn_destroy(nn);
series_destroy(dataset_destroy(data));
nn_shutdown();
exit(0);
}
int main(int argc, char** argv)
{
FILE* f;
metadata_t* meta;
fp_context_t* context;
struct sort_config sc;
dataset_t* ds;
char target[256];
stream_t* stream;
config_t conf;
external_dataset_t* ext;
int i;
if(argc < 2)
{
printf("Barf!\n");
exit(-1);
}
if((f = fopen(argv[1], "r")) == NULL)
{
printf("Cannot open dataset file %s.\n", argv[1]);
return -1;
}
meta = metadata_read(f);
sc.verbose = 1;
sc.normalize = 0;
sc.denormalize = 0;
sc.benchmark = 1;
sc.find_order = ITERATIVE;
sc.index = KEEP;
sc.cmp = HILBERT;
sc.print = stdout;
context = fp_create_context(&sc, meta->dimz, meta->dimf, meta->start_order);
ds = dataset_read(f, meta, context);
fclose(f);
dataset_print(ds, FALSE);
strcpy(target, argv[1]);
strcat(target, ".stream");
printf("Number of records: %d\n", ds->n_records);
printf("Record size: %d\n", context->record_size);
conf.memory_size = 1000;
conf.block_size = 0x100;
conf.record_size = context->record_size;
stream = stream_create(&conf, target);
stream_open(stream, O_CREAT | O_TRUNC | O_SYNC | O_WRONLY);
dataset_convert(ds, stream);
stream_close(stream);
stream_open(stream, O_SYNC | O_RDONLY);
ext = external_dataset_create(stream, meta, ds->n_records);
for(i = 0; i < ds->n_records / MEMORY_RECORDS(stream); i++)
{
memory_read(stream, ext->mem->records, MEMORY_RECORDS(stream));
ext->mem->n_records = MEMORY_RECORDS(stream);
dataset_print(ext->mem, FALSE);
}
if(ds->n_records % MEMORY_RECORDS(stream))
{
memory_read(stream, ext->mem->records, ds->n_records % MEMORY_RECORDS(stream));
ext->mem->n_records = ds->n_records % MEMORY_RECORDS(stream);
dataset_print(ext->mem, FALSE);
}
printf("Stream position: %ld vs. %ld\n", stream->pos, stream_tell(stream));
external_dataset_sort(ext);
external_dataset_destroy(ext);
stream_destroy(stream);
stats_print();
dataset_destroy(ds);
fp_destroy_context(context);
metadata_destroy(meta);
return 0;
}
dataset_t* dataset_load(const char* filename)
{
dataset_t* dataset;
int fd;
int i;
if((fd = open(filename, O_RDONLY)) == -1)
{
printf("Cannot open input file '%s'\n", filename);
return NULL;
}
/* allocate memory for dataset structure */
dataset = malloc(sizeof(dataset_t));
if(dataset == NULL)
{
printf("Cannot allocate memory for dataset structure.\n");
return NULL;
}
memset(dataset, 0, sizeof(dataset_t));
read(fd, &dataset->grid_size, sizeof(int));
read(fd, &dataset->max_t, sizeof(int));
read(fd, &dataset->n_trajectories, sizeof(int));
dataset->trajectories =
malloc(dataset->n_trajectories * sizeof(trajectory_t));
if(dataset->trajectories == NULL)
{
printf("Cannot allocate memory for trajectories.\n");
dataset_destroy(&dataset);
return NULL;
}
memset(dataset->trajectories, 0, dataset->n_trajectories * sizeof(trajectory_t));
for(i = 0; i < dataset->n_trajectories; i++)
{
read(fd, &dataset->trajectories[i].trajectory_id, sizeof(trajectory_id_t));
read(fd, &dataset->trajectories[i].n_samples, sizeof(int));
dataset->trajectories[i].samples =
malloc(dataset->trajectories[i].n_samples * sizeof(sample_t));
if(dataset->trajectories[i].samples == NULL)
{
printf("Cannot allocate memory for samples of trajectory: %d\n",
dataset->trajectories[i].trajectory_id);
dataset_destroy(&dataset);
return NULL;
}
read(fd, dataset->trajectories[i].samples,
sizeof(sample_t) * dataset->trajectories[i].n_samples);
}
/* load all known groups */
read(fd, &dataset->n_groups, sizeof(int));
dataset->groups = malloc(sizeof(group_t) * dataset->n_groups);
if(dataset->groups == NULL)
{
printf("Cannot allocate memory for group structures.\n");
dataset_destroy(&dataset);
return NULL;
}
memset(dataset->groups, 0, sizeof(group_t) * dataset->n_groups);
for(i = 0; i < dataset->n_groups; i++)
{
read(fd, &dataset->groups[i].group_id, sizeof(group_id_t));
read(fd, &dataset->groups[i].n_trajectories, sizeof(int));
dataset->groups[i].trajectories =
malloc(sizeof(trajectory_id_t) * dataset->groups[i].n_trajectories);
if(dataset->groups[i].trajectories == NULL)
{
printf("Cannot allocate memory for trajectory ID list for "\
"group: %d\n", dataset->groups[i].group_id);
dataset_destroy(&dataset);
return NULL;
}
read(fd, dataset->groups[i].trajectories,
sizeof(trajectory_id_t) * dataset->groups[i].n_trajectories);
}
return dataset;
}
