PlifMatrix.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) 2009 Soeren Sonnenburg
 * Copyright (C) 2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _PLIFMATRIX_H_
#define _PLIFMATRIX_H_

#include <shogun/lib/config.h>

#include <shogun/lib/DataType.h>
#include <shogun/lib/SGNDArray.h>
#include <shogun/lib/SGMatrix.h>
#include <shogun/base/SGObject.h>
#include <shogun/structure/Plif.h>
#include <shogun/structure/PlifBase.h>
#include <shogun/features/StringFeatures.h>
#include <shogun/lib/DynamicArray.h>

namespace shogun
{
template <class T> class SGString;

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

        ~CPlifMatrix();

        inline CPlif** get_PEN() { return m_PEN; }

        inline CPlifBase** get_plif_matrix() { return m_plif_matrix; }

        inline int32_t get_num_states() { return m_num_states; }


        inline CPlifBase** get_state_signals() { return m_state_signals; }

        inline int32_t get_num_plifs() { return m_num_plifs; }

        inline int32_t get_num_limits() { return m_num_limits; }

        void create_plifs(int32_t num_plifs, int32_t num_limits);

        void set_plif_ids(SGVector<int32_t> ids);

        void set_plif_min_values(SGVector<float64_t> min_values);

        void set_plif_max_values(SGVector<float64_t> max_values);

        void set_plif_use_cache(SGVector<bool> use_cache);

        void set_plif_use_svm(SGVector<int32_t> use_svm);

        void set_plif_limits(SGMatrix<float64_t> limits);

        void set_plif_penalties(SGMatrix<float64_t> penalties);

        void set_plif_names(SGString<char>* names, int32_t num_values, int32_t maxlen=0);

        void set_plif_transform_type(SGString<char>* transform_type, int32_t num_values, int32_t maxlen=0);

        inline int32_t get_plif_id(int32_t idx)
        {
            int32_t id = m_ids[idx];
            if (id>=m_num_plifs)
                SG_ERROR("plif id (%i)  exceeds array length (%i)\n",id,m_num_plifs)
            return id;
        }

        bool compute_plif_matrix(SGNDArray<float64_t> penalties_array);

        bool compute_signal_plifs(SGMatrix<int32_t> state_signals);

        void set_plif_state_signal_matrix(int32_t *plif_id_matrix, int32_t m, int32_t n);


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

    protected:

        CPlif** m_PEN;

        int32_t m_num_plifs;

        int32_t m_num_limits;

        int32_t m_num_states;

        int m_feat_dim3;

        CDynamicArray<int32_t> m_ids;

        CPlifBase** m_plif_matrix;

        CPlifBase** m_state_signals;
};
}
#endif /* _PLIFMATRIX_H_ */