/**
* Initializes the *params struct with the parameters provided.
*
* @param n_neighbors The number of nearest neighbors to be found
* @param tree_depth The tree depth of the tree to be built
* @param num_threads The number of threads that should be used
* @param num_nXtrain_chunks The number of chunks the training data should be split into
* @param platform_id The OpenCL platform that should be used
* @param device_id The id of the OpenCL device that should be used
* @param allowed_train_mem_percent_chunk The amount of memory (percentage) that the training data may occupy
* @param allowed_test_mem_percent The amount of memory (percentage) that the test data may occupy
* @param splitting_type The splitting type that can be used during the construction of the tree
* @param *kernels_source_directory Pointer to string that contains the path to the OpenCL kernels
* @param verbosity_level The verbosity level (0==no output, 1==more output, 2==...)
* @param *params Pointer to struct that is used to store all parameters
*
*/
void init_extern(int n_neighbors,
int tree_depth,
int num_threads,
int num_nXtrain_chunks,
int platform_id,
int device_id,
double allowed_train_mem_percent_chunk,
double allowed_test_mem_percent,
int splitting_type,
char *kernels_source_directory,
int verbosity_level,
TREE_PARAMETERS *params) {
set_default_parameters(params);
params->n_neighbors = n_neighbors;
params->tree_depth = tree_depth;
params->num_threads = num_threads;
params->n_train_chunks = num_nXtrain_chunks;
params->splitting_type = splitting_type;
params->kernels_source_directory = (char*) malloc((strlen(kernels_source_directory) + 10) * sizeof(char));
strcpy(params->kernels_source_directory, kernels_source_directory);
params->verbosity_level = verbosity_level;
params->platform_id = platform_id;
params->device_id = device_id;
params->allowed_train_mem_percent_chunk = allowed_train_mem_percent_chunk;
params->allowed_test_mem_percent = allowed_test_mem_percent;
check_parameters(params);
omp_set_num_threads(params->num_threads);
}
ILPSolverSCIP::ILPSolverSCIP()
{
call_scip(SCIPcreate, &d_scip);
call_scip(SCIPincludeDefaultPlugins, d_scip);
// All the nullptr's are possible User-data.
call_scip(SCIPcreateProb, d_scip, "problem", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
call_scip(SCIPsetObjsense, d_scip, SCIP_OBJSENSE_MINIMIZE); // Needs a start objective sense.
set_default_parameters(this);
}
static void
initialize()
{
constants_init();
set_default_parameters();
parse_input();
parameter_setup();
sim_init();
simple_tank_fill();
}
int carmen_hokuyo_start(int argc, char **argv)
{
/* initialize laser messages */
ipc_initialize_messages();
/* get laser parameters */
set_default_parameters(&hokuyo);
read_parameters(argc, argv);
printf("starting device\n");
hokuyo_start(&hokuyo);
return 0;
}
One_Class_SVM::One_Class_SVM(){
_parameters = new svm_parameter();
_training_samples = 0;
_class_labels = new std::vector<double>();
_support_vectors = new std::vector<struct svm_node*>();
set_default_parameters();
trained = false;
}
ILPSolverCbc::ILPSolverCbc()
{
// CbcModel assumes ownership over solver and deletes it in its destructor.
OsiSolverInterface* solver = new OsiClpSolverInterface();
// Output should come from CBC, not from CBCs solver.
solver->messageHandler()->setLogLevel(0);
solver->setHintParam(OsiDoReducePrint, 1);
d_model.assignSolver(solver, true);
set_default_parameters(this);
}
int carmen_laser_start(int argc, char **argv)
{
/* initialize laser messages */
ipc_initialize_messages();
/* get laser parameters */
set_default_parameters(&laser1, CARMEN_FRONT_LASER_NUM);
set_default_parameters(&laser2, CARMEN_REAR_LASER_NUM);
set_default_parameters(&laser3, CARMEN_LASER3_NUM);
set_default_parameters(&laser4, CARMEN_LASER4_NUM);
set_default_parameters(&laser5, CARMEN_LASER5_NUM);
read_parameters(argc, argv);
/* start lasers, and start publishing scans */
if(use_laser1) {
set_laser_config_structure(&laser1, &laser1_config);
sick_start_laser(&laser1);
}
if(use_laser2) {
set_laser_config_structure(&laser2, &laser2_config);
sick_start_laser(&laser2);
}
if(use_laser3) {
set_laser_config_structure(&laser3, &laser3_config);
sick_start_laser(&laser3);
}
if(use_laser4) {
set_laser_config_structure(&laser4, &laser4_config);
sick_start_laser(&laser4);
}
if(use_laser5) {
set_laser_config_structure(&laser5, &laser5_config);
sick_start_laser(&laser5);
}
return 0;
}
/* --------------------------------------------------------------------------------
* Interface (extern): Initialize all components
* --------------------------------------------------------------------------------
*/
void init_extern(int n_neighbors, int tree_depth, int num_threads, int splitting_type,
int verbosity_level, KD_TREE_PARAMETERS *params) {
set_default_parameters(params);
params->n_neighbors = n_neighbors;
params->tree_depth = tree_depth;
params->num_threads = num_threads;
params->verbosity_level = verbosity_level;
params->splitting_type = splitting_type;
check_parameters(params);
omp_set_num_threads(params->num_threads);
}
/* -------------------------------------------------------------------------- */
int main(int argc, char **argv)
{
opj_decompress_parameters parameters; /* decompression parameters */
opj_image_t* image = NULL;
opj_stream_t *l_stream = NULL; /* Stream */
opj_codec_t* l_codec = NULL; /* Handle to a decompressor */
opj_codestream_index_t* cstr_index = NULL;
char indexfilename[OPJ_PATH_LEN]; /* index file name */
OPJ_INT32 num_images, imageno;
img_fol_t img_fol;
dircnt_t *dirptr = NULL;
int failed = 0;
OPJ_FLOAT64 t, tCumulative = 0;
OPJ_UINT32 numDecompressedImages = 0;
/* set decoding parameters to default values */
set_default_parameters(¶meters);
/* FIXME Initialize indexfilename and img_fol */
*indexfilename = 0;
/* Initialize img_fol */
memset(&img_fol,0,sizeof(img_fol_t));
/* parse input and get user encoding parameters */
if(parse_cmdline_decoder(argc, argv, ¶meters,&img_fol, indexfilename) == 1) {
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
/* Initialize reading of directory */
if(img_fol.set_imgdir==1){
int it_image;
num_images=get_num_images(img_fol.imgdirpath);
dirptr=(dircnt_t*)malloc(sizeof(dircnt_t));
if(dirptr){
dirptr->filename_buf = (char*)malloc((size_t)num_images*OPJ_PATH_LEN*sizeof(char)); /* Stores at max 10 image file names*/
dirptr->filename = (char**) malloc((size_t)num_images*sizeof(char*));
if(!dirptr->filename_buf){
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
for(it_image=0;it_image<num_images;it_image++){
dirptr->filename[it_image] = dirptr->filename_buf + it_image*OPJ_PATH_LEN;
}
}
if(load_images(dirptr,img_fol.imgdirpath)==1){
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
if (num_images==0){
fprintf(stdout,"Folder is empty\n");
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
}else{
num_images=1;
}
/*Decoding image one by one*/
for(imageno = 0; imageno < num_images ; imageno++) {
fprintf(stderr,"\n");
if(img_fol.set_imgdir==1){
if (get_next_file(imageno, dirptr,&img_fol, ¶meters)) {
fprintf(stderr,"skipping file...\n");
destroy_parameters(¶meters);
continue;
}
}
/* read the input file and put it in memory */
/* ---------------------------------------- */
l_stream = opj_stream_create_default_file_stream(parameters.infile,1);
if (!l_stream){
fprintf(stderr, "ERROR -> failed to create the stream from the file %s\n", parameters.infile);
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
/* decode the JPEG2000 stream */
/* ---------------------- */
switch(parameters.decod_format) {
case J2K_CFMT: /* JPEG-2000 codestream */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_J2K);
break;
}
case JP2_CFMT: /* JPEG 2000 compressed image data */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_JP2);
break;
}
case JPT_CFMT: /* JPEG 2000, JPIP */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_JPT);
break;
}
default:
fprintf(stderr, "skipping file..\n");
destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
continue;
}
/* catch events using our callbacks and give a local context */
opj_set_info_handler(l_codec, info_callback,00);
opj_set_warning_handler(l_codec, warning_callback,00);
opj_set_error_handler(l_codec, error_callback,00);
t = opj_clock();
/* Setup the decoder decoding parameters using user parameters */
if ( !opj_setup_decoder(l_codec, &(parameters.core)) ){
fprintf(stderr, "ERROR -> opj_decompress: failed to setup the decoder\n");
destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
return EXIT_FAILURE;
}
/* Read the main header of the codestream and if necessary the JP2 boxes*/
if(! opj_read_header(l_stream, l_codec, &image)){
fprintf(stderr, "ERROR -> opj_decompress: failed to read the header\n");
destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return EXIT_FAILURE;
}
if (!parameters.nb_tile_to_decode) {
/* Optional if you want decode the entire image */
if (!opj_set_decode_area(l_codec, image, (OPJ_INT32)parameters.DA_x0,
(OPJ_INT32)parameters.DA_y0, (OPJ_INT32)parameters.DA_x1, (OPJ_INT32)parameters.DA_y1)){
fprintf(stderr, "ERROR -> opj_decompress: failed to set the decoded area\n");
destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return EXIT_FAILURE;
}
/* Get the decoded image */
if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec, l_stream))) {
fprintf(stderr,"ERROR -> opj_decompress: failed to decode image!\n");
destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}
}
else {
/* It is just here to illustrate how to use the resolution after set parameters */
/*if (!opj_set_decoded_resolution_factor(l_codec, 5)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to set the resolution factor tile!\n");
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}*/
if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to decode tile!\n");
destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}
fprintf(stdout, "tile %d is decoded!\n\n", parameters.tile_index);
}
tCumulative += opj_clock() - t;
numDecompressedImages++;
/* Close the byte stream */
opj_stream_destroy(l_stream);
if( image->color_space != OPJ_CLRSPC_SYCC
&& image->numcomps == 3 && image->comps[0].dx == image->comps[0].dy
&& image->comps[1].dx != 1 )
image->color_space = OPJ_CLRSPC_SYCC;
else if (image->numcomps <= 2)
image->color_space = OPJ_CLRSPC_GRAY;
if(image->color_space == OPJ_CLRSPC_SYCC){
color_sycc_to_rgb(image);
}
else if((image->color_space == OPJ_CLRSPC_CMYK) && (parameters.cod_format != TIF_DFMT)){
color_cmyk_to_rgb(image);
}
else if(image->color_space == OPJ_CLRSPC_EYCC){
color_esycc_to_rgb(image);
}
if(image->icc_profile_buf) {
#if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
if(image->icc_profile_len)
color_apply_icc_profile(image);
else
color_cielab_to_rgb(image);
#endif
free(image->icc_profile_buf);
image->icc_profile_buf = NULL; image->icc_profile_len = 0;
}
/* Force output precision */
/* ---------------------- */
if (parameters.precision != NULL)
{
OPJ_UINT32 compno;
for (compno = 0; compno < image->numcomps; ++compno)
{
OPJ_UINT32 precno = compno;
OPJ_UINT32 prec;
if (precno >= parameters.nb_precision) {
precno = parameters.nb_precision - 1U;
}
prec = parameters.precision[precno].prec;
if (prec == 0) {
prec = image->comps[compno].prec;
}
switch (parameters.precision[precno].mode) {
case OPJ_PREC_MODE_CLIP:
clip_component(&(image->comps[compno]), prec);
break;
case OPJ_PREC_MODE_SCALE:
scale_component(&(image->comps[compno]), prec);
break;
default:
break;
}
}
}
/* Upsample components */
/* ------------------- */
if (parameters.upsample)
{
image = upsample_image_components(image);
if (image == NULL) {
fprintf(stderr, "ERROR -> opj_decompress: failed to upsample image components!\n");
destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
return EXIT_FAILURE;
}
}
/* Force RGB output */
/* ---------------- */
if (parameters.force_rgb)
{
switch (image->color_space) {
case OPJ_CLRSPC_SRGB:
break;
case OPJ_CLRSPC_GRAY:
image = convert_gray_to_rgb(image);
break;
default:
fprintf(stderr, "ERROR -> opj_decompress: don't know how to convert image to RGB colorspace!\n");
opj_image_destroy(image);
image = NULL;
break;
}
if (image == NULL) {
fprintf(stderr, "ERROR -> opj_decompress: failed to convert to RGB image!\n");
destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
return EXIT_FAILURE;
}
}
/* create output image */
/* ------------------- */
switch (parameters.cod_format) {
case PXM_DFMT: /* PNM PGM PPM */
if (imagetopnm(image, parameters.outfile, parameters.split_pnm)) {
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
case PGX_DFMT: /* PGX */
if(imagetopgx(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
case BMP_DFMT: /* BMP */
if(imagetobmp(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
#ifdef OPJ_HAVE_LIBTIFF
case TIF_DFMT: /* TIFF */
if(imagetotif(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
#endif /* OPJ_HAVE_LIBTIFF */
case RAW_DFMT: /* RAW */
if(imagetoraw(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Error generating raw file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
case RAWL_DFMT: /* RAWL */
if(imagetorawl(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Error generating rawl file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
case TGA_DFMT: /* TGA */
if(imagetotga(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Error generating tga file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
#ifdef OPJ_HAVE_LIBPNG
case PNG_DFMT: /* PNG */
if(imagetopng(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Error generating png file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
#endif /* OPJ_HAVE_LIBPNG */
/* Can happen if output file is TIFF or PNG
* and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined
*/
default:
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
/* free remaining structures */
if (l_codec) {
opj_destroy_codec(l_codec);
}
/* free image data structure */
opj_image_destroy(image);
/* destroy the codestream index */
opj_destroy_cstr_index(&cstr_index);
if(failed) remove(parameters.outfile);
}
destroy_parameters(¶meters);
if (numDecompressedImages) {
fprintf(stdout, "decode time: %d ms\n", (int)( (tCumulative * 1000.0) / (OPJ_FLOAT64)numDecompressedImages));
}
return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
void try_one_parameter(int method, char seq_name[], float sparse_penalty, float lambda_min, float lambda_max, int normalization_method, float lambda_in_normalization, bool save_intermediate_results)
{
int i, j, k;
COpt *opt;
char simple_result_filename[200];
char result_filename[200];
char intermediate_result_filename[200];
char input_data_filename[200];
int tmp_pop_size = 100;
float para[4];
for (k=1; k<=20; k++){
// STEP 1: create new COpt
opt = create_new_copt(method);
// STEP 2: set up FCM
opt->fcm = new CFcm();
sprintf(input_data_filename, "%s.txt", seq_name);
opt->fcm->lambda_in_normalization = lambda_in_normalization;
opt->fcm->read_problem_from_file(input_data_filename);
opt->fcm->normalize_data_seq(normalization_method);
// STEP 3: set parameters
set_default_parameters(method, para);
opt->set_parameters(para);
opt->pop_size = tmp_pop_size;
opt->max_iter = 0;//15000*100/(opt->pop_size);
opt->seed = k*100;
if (sparse_penalty != 0)
opt->use_sparse = true;
else
opt->use_sparse = false;
opt->sparse_penalty = sparse_penalty;
sprintf(simple_result_filename, "result-s-%s-para1-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f-%1.2f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max, lambda_in_normalization);
sprintf(result_filename, "result-%s-para1-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f-%1.2f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max, lambda_in_normalization);
// STEP 4: allocate memory
opt->allocate_memory();
opt->save_intermediate_results=save_intermediate_results;
if (save_intermediate_results==true)
opt->init_intermediate_result();
// STEP 5: modify settings
opt->solution_lowerbound[ opt->fcm->n_nodes ] = lambda_min;
opt->solution_upperbound[ opt->fcm->n_nodes ] = lambda_max;
opt->solution_range[ opt->fcm->n_nodes ] = lambda_max - lambda_min;
// STEP 6: run the algorithm
opt->run_decomposed();
// STEP 7: write the results and release the memory
opt->write_result(result_filename);
opt->write_simple_result(simple_result_filename, false);
if (save_intermediate_results==true){
sprintf(intermediate_result_filename, "result-intermediate-%s-para1-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f-%1.2f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max, lambda_in_normalization);
opt->write_intermediate_result_to_file(intermediate_result_filename);
opt->free_intermediate_result();
}
delete opt->fcm;
opt->release_memory();
delete opt;
}
opt->write_simple_result(simple_result_filename, true);
}
void try_diff_parameters(int method, char seq_name[])
{
int i, j, k;
COpt *opt;
char simple_result_filename[200];
char result_filename[200];
char input_data_filename[200];
float tmp_sparse_penalty = 0.0;
int tmp_pop_size = 100;
float para[4];
set_default_parameters(method, para);
for (i=1; i<=9; i++){
for (j=1; j<=9; j++){
para[0] = (float)i/10.0;
para[1] = (float)j/10.0;
for (k=1; k<=10; k++){
// STEP 1: create new COpt
opt = create_new_copt(method);
// STEP 2: set up FCM
// srand(k);
// opt->fcm = new CFcm(n_nodes, density, lambda, n_seq, n_seq*n_len_per_seq, tmp_noise_level);
opt->fcm = new CFcm();
sprintf(input_data_filename, "%s.txt", seq_name);
opt->fcm->read_problem_from_file(input_data_filename);
// STEP 3: set parameters
// set_default_parameters(method, para);
opt->set_parameters(para);
opt->pop_size = tmp_pop_size;
opt->max_iter = 15000*100/(opt->pop_size);
opt->seed = k*100;
opt->use_sparse = false;
opt->sparse_penalty = tmp_sparse_penalty;
sprintf(simple_result_filename, "result-s-%s-diffpara-np%d-sp%0.2f-%s.txt", opt->method_name, tmp_pop_size, tmp_sparse_penalty, seq_name);
sprintf(result_filename, "result-%s-diffpara-np%d-sp%0.2f-%s.txt", opt->method_name, tmp_pop_size, tmp_sparse_penalty, seq_name);
// STEP 4: allocate memory
opt->allocate_memory();
// STEP 5: modify settings
opt->solution_lowerbound[ opt->fcm->n_nodes ] = 5.0;
opt->solution_upperbound[ opt->fcm->n_nodes ] = 5.0;
opt->solution_range[ opt->fcm->n_nodes ] = 0.0;
// STEP 6: run the algorithm
opt->run_decomposed();
// STEP 7: write the results and release the memory
opt->write_result(result_filename);
opt->write_simple_result(simple_result_filename, false);
delete opt->fcm;
opt->release_memory();
delete opt;
}
opt->write_simple_result(simple_result_filename, true);
}
}
}
void try_diff_parameters(int method, char seq_name[], float sparse_penalty, float lambda_min, float lambda_max, int normalization_method)
{
int i, j, k;
COpt *opt;
char simple_result_filename[200];
char result_filename[200];
char input_data_filename[200];
int tmp_pop_size = 100;
float para[4];
set_default_parameters(method, para);
for (i=1; i<=9; i++){
for (j=1; j<=9; j++){
para[0] = (float)i/10.0; //////////////////////////// Set parameters
para[1] = (float)j/10.0;
for (k=1; k<=20; k++){
// STEP 1: create new COpt
opt = create_new_copt(method);
// STEP 2: set up FCM
opt->fcm = new CFcm();
sprintf(input_data_filename, "%s.txt", seq_name);
opt->fcm->read_problem_from_file(input_data_filename);
opt->fcm->normalize_data_seq(normalization_method);
// STEP 3: set parameters
opt->set_parameters(para);
opt->pop_size = tmp_pop_size;
opt->max_iter = 15000*100/(opt->pop_size);
opt->seed = k*100;
if (sparse_penalty != 0)
opt->use_sparse = true;
else
opt->use_sparse = false;
opt->sparse_penalty = sparse_penalty;
sprintf(simple_result_filename, "result-s-%s-diffpara-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max);
sprintf(result_filename, "result-%s-diffpara-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max);
// STEP 4: allocate memory
opt->allocate_memory();
// STEP 5: modify settings
opt->solution_lowerbound[ opt->fcm->n_nodes ] = lambda_min;
opt->solution_upperbound[ opt->fcm->n_nodes ] = lambda_max;
opt->solution_range[ opt->fcm->n_nodes ] = lambda_max - lambda_min;
// STEP 6: run the algorithm
opt->run_decomposed();
// STEP 7: write the results and release the memory
opt->write_result(result_filename);
opt->write_simple_result(simple_result_filename, false);
delete opt->fcm;
opt->release_memory();
delete opt;
}
opt->write_simple_result(simple_result_filename, true);
}
}
}
