ModelSelectionParameters.h

Go to the documentation of this file.

/*
 * This program 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.
 *
 * Written (W) 2011 Heiko Strathmann
 * Copyright (C) 2011 Berlin Institute of Technology and Max-Planck-Society
 */

#ifndef __MODELSELECTIONPARAMETERS_H_
#define __MODELSELECTIONPARAMETERS_H_

#include <shogun/base/SGObject.h>
#include <shogun/lib/DynamicObjectArray.h>

namespace shogun
{

class CParameterCombination;

enum ERangeType
{
    R_LINEAR, R_EXP, R_LOG
};

enum EMSParamType
{
    MSPT_NONE=0,

    /* float64_t */
    MSPT_FLOAT64,

    /* int32_t */
    MSPT_INT32,
};

class CModelSelectionParameters: public CSGObject
{
public:
    CModelSelectionParameters();

    CModelSelectionParameters(const char* node_name);

    CModelSelectionParameters(const char* node_name, CSGObject* sgobject);

    ~CModelSelectionParameters();

    void append_child(CModelSelectionParameters* child);

    template <class T>
    void set_values(SGVector<T> values);

    void print_tree(int prefix_num=0);

    CDynamicObjectArray<CParameterCombination>* get_combinations();

    void build_values(float64_t min, float64_t max, ERangeType type,
            float64_t step=1.0, float64_t type_base=2.0);

    void build_values(int32_t min, int32_t max, ERangeType type, int32_t step=1,
            int32_t type_base=2);

    inline virtual const char* get_name() const
    {
        return "ModelSelectionParameters";
    }

private:
    void init();

    void delete_values();

    void build_values(EMSParamType param_type, void* min, void* max,
            ERangeType type, void* step, void* type_base);

protected:
    bool has_children() const
    {
        return m_child_nodes->get_num_elements()>0;
    }

private:
    CSGObject* m_sgobject;
    const char* m_node_name;
    SGVector<char> m_values; // dummy void type char
    CDynamicObjectArray<CModelSelectionParameters>* m_child_nodes;
    EMSParamType m_value_type;
};

template <class T> SGVector<T> create_range_array(T min, T max,
        ERangeType type, T step, T type_base)
{
    if (max<min)
        SG_SERROR("unable build values: max=%f < min=%f\n", max, min);

    /* create value vector */
    index_t num_values=CMath::round(max-min)/step+1;
    SGVector<T> result(num_values);

    /* fill array */
    for (index_t i=0; i<num_values; ++i)
    {
        T current=min+i*step;

        switch (type)
        {
        case R_LINEAR:
            result.vector[i]=current;
            break;
        case R_EXP:
            result.vector[i]=CMath::pow((float64_t)type_base, current);
            break;
        case R_LOG:
            if (current<=0)
                SG_SERROR("log(x) with x=%f\n", current);

            /* custom base b: log_b(i*step)=log_2(i*step)/log_2(b) */
            result.vector[i]=CMath::log2(current)/CMath::log2(type_base);
            break;
        default:
            SG_SERROR("unknown range type!\n");
            break;
        }
    }

    return result;
}

}
#endif /* __MODELSELECTIONPARAMETERS_H_ */