DirectorDistance.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.
 *
 * Copyright (C) 2012 Evgeniy Andreev (gsomix)
 */

#ifndef _DIRECTORDISTANCE_H___
#define _DIRECTORDISTANCE_H___

#ifdef USE_SWIG_DIRECTORS
#include <shogun/lib/common.h>
#include <shogun/lib/DataType.h>
#include <shogun/distance/Distance.h>

namespace shogun
{

#define IGNORE_IN_CLASSLIST
IGNORE_IN_CLASSLIST class CDirectorDistance : public CDistance
{
    public:
        /* default constructor */
        CDirectorDistance(bool is_external_features) 
        : CDistance(), external_features(is_external_features)
        {

        }   

        virtual ~CDirectorDistance()
        {
            cleanup();
        }

        virtual float64_t distance_function(int32_t x, int32_t y)
        {
            SG_ERROR("Distance function of Director Distance needs to be overridden.\n");
            return 0;
        }

        virtual float64_t distance(int32_t idx_a, int32_t idx_b)
        {
            if (idx_a < 0 || idx_b <0)
                return 0;

            if (!external_features)
                CDistance::distance(idx_a, idx_b);
            else
                return compute(idx_a, idx_b);
        }

        virtual float64_t distance_upper_bounded(int32_t idx_a, int32_t idx_b, float64_t upper_bound)
        {
            return CDistance::distance(idx_a, idx_b);
        }

        virtual float64_t* get_distance_matrix_real(int32_t &m, int32_t &n, float64_t* target)
        {
            return CDistance::get_distance_matrix_real(m, n, target);
        }

        virtual float32_t* get_distance_matrix_shortreal(int32_t &m, int32_t &n, float32_t* target)
        {
            return CDistance::get_distance_matrix_shortreal(m, n, target);
        }

        virtual bool init(CFeatures* lhs, CFeatures* rhs)
        {
            if (this->parallel->get_num_threads()!=1)
            {
                SG_WARNING("Enforcing to use only one thread due to restrictions of directors\n");
                this->parallel->set_num_threads(1);
            }
            return CDistance::init(lhs, rhs);
        }

        virtual void cleanup()
        {
            
        }

        virtual int32_t get_num_vec_lhs()
        {
            return CDistance::get_num_vec_lhs();
        }

        virtual int32_t get_num_vec_rhs()
        {
            return CDistance::get_num_vec_rhs();
        }

        virtual void set_num_vec_lhs(int32_t num)
        {
            num_lhs=num;
        }

        virtual void set_num_vec_rhs(int32_t num)
        {
            num_rhs=num;
        }

        virtual bool has_features()
        {
            if (!external_features)
                return CDistance::has_features();
            else
                return true;
        }

        virtual void remove_lhs_and_rhs()
        {
            CDistance::remove_lhs_and_rhs();
        }

        virtual void remove_lhs()
        {
            CDistance::remove_lhs();
        }

        virtual void remove_rhs()
        {
            CDistance::remove_rhs();
        }

        virtual EDistanceType get_distance_type() { return D_DIRECTOR; }

        virtual EFeatureType get_feature_type() { return F_ANY; }

        virtual EFeatureClass get_feature_class() { return C_ANY; }

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

        virtual void set_precompute_matrix(bool flag)
        {
            CDistance::set_precompute_matrix(flag);
        }

    protected:
        virtual float64_t compute(int32_t x, int32_t y)
        {
            return distance_function(x, y);
        }

    protected:
        /* */
        bool external_features;
};

}

#endif /* USE_SWIG_DIRECTORS */
#endif /* _DIRECTORDISTANCE_H___ */