QDA.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) 2012 Fernando José Iglesias García
 * Copyright (C) 2012 Fernando José Iglesias García
 */

#ifndef _QDA_H__
#define _QDA_H__

#include <shogun/lib/config.h>


#include <shogun/features/DotFeatures.h>
#include <shogun/features/DenseFeatures.h>
#include <shogun/machine/NativeMulticlassMachine.h>
#include <shogun/lib/SGNDArray.h>

namespace shogun
{

//#define DEBUG_QDA

class CQDA : public CNativeMulticlassMachine
{
    public:
        MACHINE_PROBLEM_TYPE(PT_MULTICLASS)

        
        CQDA();

        CQDA(float64_t tolerance, bool store_covs);

        CQDA(CDenseFeatures<float64_t>* traindat, CLabels* trainlab);

        CQDA(CDenseFeatures<float64_t>* traindat, CLabels* trainlab, float64_t tolerance);

        CQDA(CDenseFeatures<float64_t>* traindat, CLabels* trainlab, bool store_covs);

        CQDA(CDenseFeatures<float64_t>* traindat, CLabels* trainlab, float64_t tolerance, bool store_covs);

        virtual ~CQDA();

        virtual CMulticlassLabels* apply_multiclass(CFeatures* data=NULL);

        inline void set_store_covs(bool store_covs) { m_store_covs = store_covs; }

        inline bool get_store_covs() { return m_store_covs; }

        inline void set_tolerance(float64_t tolerance) { m_tolerance = tolerance; }

        inline bool get_tolerance() { return m_tolerance; }

        virtual EMachineType get_classifier_type() { return CT_QDA; }

        virtual void set_features(CDotFeatures* feat)
        {
            if (feat->get_feature_class() != C_DENSE ||
                feat->get_feature_type() != F_DREAL)
                SG_ERROR("QDA requires SIMPLE REAL valued features\n")

            SG_REF(feat);
            SG_UNREF(m_features);
            m_features = feat;
        }

        virtual CDotFeatures* get_features() { SG_REF(m_features); return m_features; }

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

        inline SGVector< float64_t > get_mean(int32_t c) const
        {
            return SGVector< float64_t >(m_means.get_column_vector(c), m_dim, false);
        }

        inline SGMatrix< float64_t > get_cov(int32_t c) const
        {
            REQUIRE(m_store_covs, "Covariance matrices were not stored. "
                    "Please activate to access them subsequently.\n");
            return SGMatrix< float64_t >(m_covs.get_matrix(c), m_dim, m_dim, false);
        }

    protected:
        virtual bool train_machine(CFeatures* data = NULL);

    private:
        void init();

        void cleanup();

    private:
        CDotFeatures* m_features;

        float64_t m_tolerance;

        bool m_store_covs;

        int32_t m_num_classes;

        int32_t m_dim;

        SGNDArray< float64_t > m_covs;

        SGMatrix< float64_t > m_means;

        SGNDArray< float64_t > m_M;

        SGVector< float32_t > m_slog;

}; /* class QDA */
}  /* namespace shogun */

#endif /* _QDA_H__ */