Plif.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) 1999-2008 Gunnar Raetsch
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef __PLIF_H__
#define __PLIF_H__

#include <shogun/lib/common.h>
#include <shogun/mathematics/Math.h>
#include <shogun/structure/PlifBase.h>

namespace shogun
{

enum ETransformType
{
    T_LINEAR,
    T_LOG,
    T_LOG_PLUS1,
    T_LOG_PLUS3,
    T_LINEAR_PLUS3
};

class CPlif: public CPlifBase
{
    public:
        CPlif(int32_t len=0);
        virtual ~CPlif();

        void init_penalty_struct_cache();

        float64_t lookup_penalty_svm(
            float64_t p_value, float64_t *d_values) const;

        float64_t lookup_penalty(
            float64_t p_value, float64_t* svm_values) const;

        float64_t lookup_penalty(int32_t p_value, float64_t* svm_values) const;

        inline float64_t lookup(float64_t p_value)
        {
            ASSERT(use_svm == 0);
            return lookup_penalty(p_value, NULL);
        }

        void penalty_clear_derivative();

        void penalty_add_derivative_svm(
            float64_t p_value, float64_t* svm_values, float64_t factor) ;

        void penalty_add_derivative(float64_t p_value, float64_t* svm_values, float64_t factor);

        const float64_t * get_cum_derivative(int32_t & p_len) const
        {
            p_len = len;
            return cum_derivatives.vector;
        }

        bool set_transform_type(const char *type_str);

        const char* get_transform_type()
        {
            if (transform== T_LINEAR)
                return "linear";
            else if (transform== T_LOG)
                return "log";
            else if (transform== T_LOG_PLUS1)
                return "log(+1)";
            else if (transform== T_LOG_PLUS3)
                return "log(+3)";
            else if (transform== T_LINEAR_PLUS3)
                return "(+3)";
            else
                SG_ERROR("wrong type");
            return "";
        }


        void set_id(int32_t p_id)
        {
            id=p_id;
        }

        int32_t get_id() const
        {
            return id;
        }

        int32_t get_max_id() const
        {
            return get_id();
        }

        void set_use_svm(int32_t p_use_svm)
        {
            invalidate_cache();
            use_svm=p_use_svm;
        }

        int32_t get_use_svm() const
        {
            return use_svm;
        }

        virtual bool uses_svm_values() const
        {
            return (get_use_svm()!=0);
        }

        void set_use_cache(int32_t p_use_cache)
        {
            invalidate_cache();
            use_cache=p_use_cache;
        }

        void invalidate_cache()
        {
            SG_FREE(cache);
            cache=NULL;
        }

        int32_t get_use_cache()
        {
            return use_cache;
        }

        void set_plif(
            int32_t p_len, float64_t *p_limits, float64_t* p_penalties)
        {
            ASSERT(len==p_len);

            for (int32_t i=0; i<len; i++)
            {
                limits[i]=p_limits[i];
                penalties[i]=p_penalties[i];
            }

            invalidate_cache();
            penalty_clear_derivative();
        }

        void set_plif_limits(SGVector<float64_t> p_limits)
        {
            ASSERT(len==p_limits.vlen);

            limits = p_limits;

            invalidate_cache();
            penalty_clear_derivative();
        }


        void set_plif_penalty(SGVector<float64_t> p_penalties)
        {
            ASSERT(len==p_penalties.vlen);

            penalties = p_penalties;

            invalidate_cache();
            penalty_clear_derivative();
        }

        void set_plif_length(int32_t p_len)
        {
            if (len!=p_len)
            {
                len=p_len;

                SG_DEBUG( "set_plif len=%i\n", p_len);
                limits = SGVector<float64_t>(len);
                penalties = SGVector<float64_t>(len);
                cum_derivatives = SGVector<float64_t>(len);
            }

            for (int32_t i=0; i<len; i++)
            {
                limits[i]=0.0;
                penalties[i]=0.0;
                cum_derivatives[i]=0.0;
            }

            invalidate_cache();
            penalty_clear_derivative();
        }

        float64_t* get_plif_limits()
        {
            return limits.vector;
        }

        float64_t* get_plif_penalties()
        {
            return penalties.vector;
        }

        inline void set_max_value(float64_t p_max_value)
        {
            max_value=p_max_value;
            invalidate_cache();
        }

        virtual float64_t get_max_value() const
        {
            return max_value;
        }

        inline void set_min_value(float64_t p_min_value)
        {
            min_value=p_min_value;
            invalidate_cache();
        }

        virtual float64_t get_min_value() const
        {
            return min_value;
        }

        void set_plif_name(char *p_name);

        inline char* get_plif_name() const
        {
            if (name)
                return name;
            else
            {
                char buf[20];
                sprintf(buf, "plif%i", id);
                //name = strdup(buf);
                return strdup(buf);
            }
        }

        bool get_do_calc();

        void set_do_calc(bool b);

        void get_used_svms(int32_t* num_svms, int32_t* svm_ids);

        inline int32_t get_plif_len()
        {
            return len;
        }

        virtual void list_plif() const
        {
            SG_PRINT("CPlif(min_value=%1.2f, max_value=%1.2f, use_svm=%i)\n", min_value, max_value, use_svm) ;
        }

        static void delete_penalty_struct(CPlif** PEN, int32_t P);

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

    protected:
        int32_t len;
        SGVector<float64_t> limits;
        SGVector<float64_t> penalties;
        SGVector<float64_t> cum_derivatives;
        float64_t max_value;
        float64_t min_value;
        float64_t *cache;
        enum ETransformType transform;
        int32_t id;
        char * name;
        int32_t use_svm;
        bool use_cache;
        bool do_calc;
};
}
#endif