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

#ifndef __PARAMETERCOMBINATION_H__
#define __PARAMETERCOMBINATION_H__

#include <shogun/lib/DynamicObjectArray.h>
#include <shogun/lib/Map.h>

namespace shogun
{
class CModelSelectionParameters;
class CMachine;
class Parameter;

class CParameterCombination : public CSGObject
{
friend class CModelSelectionParameters;

public:
    CParameterCombination();

    CParameterCombination(Parameter* param);

    CParameterCombination(CSGObject* obj);

    virtual ~CParameterCombination();

    void print_tree(int prefix_num=0) const;

    void apply_to_modsel_parameter(Parameter* parameter) const;

    void apply_to_machine(CMachine* machine) const;

    void append_child(CParameterCombination* child);

    void merge_with(CParameterCombination* node);

    CParameterCombination* copy_tree() const;

    static CDynamicObjectArray* leaf_sets_multiplication(
            const CDynamicObjectArray& sets,
            const CParameterCombination* new_root);

    template <typename T>
    bool set_parameter(const char* name,
            T value, CSGObject* parent, index_t index = -1)
    {
        bool match = false;

        if (m_param)
        {
            for (index_t i = 0; i < m_param->get_num_parameters(); ++i)
            {
                    void* param = m_param->get_parameter(i)->m_parameter;

                    if (m_param->get_parameter(i)->m_datatype.m_ptype
                            ==PT_SGOBJECT)
                    {
                        if (parent == (*((CSGObject**)param)))
                            match = true;
                    }

            }

        }

        bool result = false;

        for (index_t i = 0; i < m_child_nodes->get_num_elements(); ++i)
        {
            CParameterCombination* child = (CParameterCombination*)
                    m_child_nodes->get_element(i);

            if (!match)
                 result |= child->set_parameter(name, value, parent, index);

            else
                 result |= child->set_parameter_helper(name, value, index);

            SG_UNREF(child);

        }

        return result;
    }

    TParameter* get_parameter(const char* name, CSGObject* parent);

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

    static DynArray<Parameter*>* parameter_set_multiplication(
            const DynArray<Parameter*>& set_1,
            const DynArray<Parameter*>& set_2);

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

    virtual uint32_t get_parameters_length() { return m_parameters_length; }

    virtual void build_parameter_values_map(
            CMap<TParameter*, SGVector<float64_t> >* values_map);

    virtual void build_parameter_parent_map(
            CMap<TParameter*, CSGObject*>* parent_map);

protected:
    static CDynamicObjectArray* non_value_tree_multiplication(
                const CDynamicObjectArray* sets,
                const CParameterCombination* new_root);

    static CDynamicObjectArray* extract_trees_with_name(
            const CDynamicObjectArray* sets, const char* desired_name);

    TParameter* get_parameter_helper(const char* name);

    bool set_parameter_helper(const char* name, bool value, index_t index);

    bool set_parameter_helper(const char* name, int32_t value, index_t index);

    bool set_parameter_helper(const char* name, float64_t value, index_t index);

private:
    void init();

protected:
    Parameter* m_param;

    CDynamicObjectArray* m_child_nodes;

    uint32_t m_parameters_length;
};
}
#endif /* __PARAMETERCOMBINATION_H__ */