src/crown-composite-annealing.cpp

Go to the documentation of this file.

/*
 Copyright 2015 Nicolas Melot

 This file is part of Crown.

 Crown is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 Crown is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with Crown. If not, see <http://www.gnu.org/licenses/>.

*/


#include <fstream>

#include <pelib/argument_parsing.hpp>
#include <pelib/dl.h>
#include <pelib/Scalar.hpp>

#include <crown/CrownModular.hpp>
#include <crown/CrownCompositeAnnealing.hpp>

#ifdef debug
#undef debug
#endif

#define debug(var) cout << "[" << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "] " << #var << " = \"" << (var) << "\"" << endl;

using namespace std;
using namespace pelib;
using namespace crown;

#ifdef __cplusplus
extern "C" {
#endif

struct args
{
        double alpha, eta, zeta, kappa;
        pelib_argument_stream mapping, scaling;
        vector<pelib_argument_stream> composite;
        bool showError, showOutput;
        float init_temp, cooling, temp_final, max_trans, max_new, distance;
};
typedef struct args args_t;

static args_t
parse(char **args)
{
        args_t out;
        out.showError = false;
        out.showOutput = false;
        out.alpha = 3;
        out.zeta = 0.649;
        out.eta = 0.018611;
        out.kappa = 52.639161335;

        out.init_temp = 8;
        out.cooling = 0.6;
        out.temp_final = 0.9;
        out.max_trans = 2;
        out.max_new = 2;
        out.distance = 0.5;

        pelib_argument_stream_init(&out.mapping);
        pelib_argument_stream_init(&out.scaling);

        for(; args[0] != NULL; args++)
        {
                if(strcmp(args[0], "--show-stdout") == 0)
                {
                        out.showOutput = true;
                        continue;
                }
                if(strcmp(args[0], "--show-stderr") == 0)
                {
                        out.showError = true;
                        continue;
                }
                if(strcmp(args[0], "--alpha") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.alpha;
                        continue;
                }
                if(strcmp(args[0], "--eta") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.eta;
                        continue;
                }
                if(strcmp(args[0], "--zeta") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.zeta;
                        continue;
                }
                if(strcmp(args[0], "--kappa") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.kappa;
                        continue;
                }
                if(strcmp(args[0], "--init-temperature") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.init_temp;
                        continue;
                }
                if(strcmp(args[0], "--cooling-factor") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.cooling;
                        continue;
                }
                if(strcmp(args[0], "--final-temperature") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.temp_final;
                        continue;
                }
                if(strcmp(args[0], "--max-transformations") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.max_trans;
                        continue;
                }
                if(strcmp(args[0], "--max-new-state") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.max_new;
                        continue;
                }
                if(strcmp(args[0], "--distance") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.distance;
                        continue;
                }
                if(strcmp(args[0], "--mapping") == 0)
                {
                        args++;
                        args += pelib_argument_stream_parse(args, &out.mapping) - 1;
                        continue;
                }
                if(strcmp(args[0], "--scaling") == 0)
                {
                        args++;
                        args += pelib_argument_stream_parse(args, &out.scaling) - 1;
                        continue;
                }
                if(strcmp(args[0], "--composite") == 0)
                {
                        args++;
                        pelib_argument_stream compo;
                        pelib_argument_stream_init(&compo);
                        args += pelib_argument_stream_parse(args, &compo) - 1;
                        out.composite.push_back(compo);
                        continue;
                }
        }

        return out;
}

const CrownScheduler*
crown_scheduler(size_t argc, char **argv, const CrownScheduler *composite)
{
        args_t args = parse(argv);
        Algebra param;
        param.insert(new Scalar<float>("alpha", args.alpha));
        param.insert(new Scalar<float>("eta", args.eta));
        param.insert(new Scalar<float>("zeta", args.zeta));
        param.insert(new Scalar<float>("kappa", args.kappa));

        void *libMapping = load_lib(args.mapping.library);
        void *libScaling = load_lib(args.scaling.library);
        CrownMapping* (*map)(size_t argc, char **argv);
        CrownScaling* (*scal)(size_t argc, char **argv);
        CrownMapping* mapping = NULL;
        CrownScaling* scaling = NULL;

        // Load crown mapping
        if(args.mapping.library != NULL)
        {
                void *libConfig = load_lib(args.mapping.library);
                map = (CrownMapping* (*)(size_t argc, char **argv))load_function(libConfig, "crown_mapping");
                mapping = map(args.mapping.argc, args.mapping.argv);
        }

        // Load crown scaling
        if(args.scaling.library != NULL)
        {
                void *libConfig = load_lib(args.scaling.library);
                scal = (CrownScaling* (*)(size_t argc, char **argv))load_function(libConfig, "crown_scaling");
                scaling = scal(args.scaling.argc, args.scaling.argv);
        }

        const CrownScheduler *scheduler = composite;
        for(vector<pelib_argument_stream>::iterator i = args.composite.begin(); i != args.composite.end(); i++)
        {
                pelib_argument_stream compo = *i;
                void *libCompo = load_lib(compo.library);
                const CrownScheduler* (*sched)(size_t argc, char **argv, const CrownScheduler*) = (const CrownScheduler* (*)(size_t argc, char **argv, const CrownScheduler*))load_function(libCompo, "crown_scheduler");
                const CrownScheduler *new_scheduler = sched(compo.argc, compo.argv, scheduler);
                if(scheduler != NULL)
                {
                        delete scheduler;
                }
                scheduler = new_scheduler->clone();
                void (*del)(const CrownScheduler*) = (void (*)(const CrownScheduler*))load_function(libCompo, "crown_delete_scheduler");
                del(new_scheduler);
                destroy_lib(libCompo);
        }

        // Final scheduler
        CrownScheduler *final = new CrownCompositeAnnealing(param, args.init_temp, args.cooling, args.temp_final, args.max_trans, args.max_new, args.distance, scheduler, mapping, scaling, args.showOutput, args.showError);
        
        // Destroy object instances by libraries
        if(args.mapping.library != NULL)
        {
                void (*del)(CrownMapping *) = (void (*)(CrownMapping*))load_function(libMapping, "crown_delete_algebra");
                del(mapping);
                destroy_lib(libMapping);
        }

        // Destroy object instances by libraries
        if(args.scaling.library != NULL)
        {
                void (*del)(CrownScaling *) = (void (*)(CrownScaling*))load_function(libScaling, "crown_delete_algebra");
                del(scaling);
                destroy_lib(libScaling);
        }

        return final;
}

#ifdef __cplusplus
}
#endif