Distance.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) 2006-2009 Christian Gehl
 * Written (W) 2006-2009 Soeren Sonnenburg
 * Copyright (C) 2006-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _DISTANCE_H___
#define _DISTANCE_H___

#include <stdio.h>

#include <shogun/lib/common.h>
#include <shogun/io/File.h>
#include <shogun/mathematics/Math.h>
#include <shogun/base/SGObject.h>
#include <shogun/features/FeatureTypes.h>
#include <shogun/features/Features.h>

namespace shogun
{
class CFile;
class CMath;
class CFeatures;

enum EDistanceType
{
    D_UNKNOWN = 0,
    D_MINKOWSKI = 10,
    D_MANHATTAN = 20,
    D_CANBERRA = 30,
    D_CHEBYSHEW = 40,
    D_GEODESIC = 50,
    D_JENSEN = 60,
    D_MANHATTANWORD = 70,
    D_HAMMINGWORD = 80 ,
    D_CANBERRAWORD = 90,
    D_SPARSEEUCLIDIAN = 100,
    D_EUCLIDIAN = 110,
    D_CHISQUARE = 120,
    D_TANIMOTO = 130,
    D_COSINE = 140,
    D_BRAYCURTIS = 150,
    D_CUSTOM = 160,
    D_ATTENUATEDEUCLIDIAN = 170
};


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

        CDistance(CFeatures* lhs, CFeatures* rhs);
        virtual ~CDistance();

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

            ASSERT(lhs);
            ASSERT(rhs);

            if (lhs==rhs)
            {
                int32_t num_vectors = lhs->get_num_vectors();

                if (idx_a>=num_vectors)
                    idx_a=2*num_vectors-1-idx_a;

                if (idx_b>=num_vectors)
                    idx_b=2*num_vectors-1-idx_b;
            }

            ASSERT(idx_a<lhs->get_num_vectors());
            ASSERT(idx_b<rhs->get_num_vectors());

            if (precompute_matrix && (precomputed_matrix==NULL) && (lhs==rhs))
                do_precompute_matrix() ;

            if (precompute_matrix && (precomputed_matrix!=NULL))
            {
                if (idx_a>=idx_b)
                    return precomputed_matrix[idx_a*(idx_a+1)/2+idx_b] ;
                else
                    return precomputed_matrix[idx_b*(idx_b+1)/2+idx_a] ;
            }

            return compute(idx_a, idx_b);
        }

        SGMatrix<float64_t> get_distance_matrix();

        virtual float64_t* get_distance_matrix_real(
            int32_t &m,int32_t &n, float64_t* target);

        virtual float32_t* get_distance_matrix_shortreal(
            int32_t &m,int32_t &n,float32_t* target);

        virtual bool init(CFeatures* lhs, CFeatures* rhs);

        virtual void cleanup()=0;

        void load(CFile* loader);

        void save(CFile* writer);

        inline CFeatures* get_lhs() { SG_REF(lhs); return lhs; };

        inline CFeatures* get_rhs() { SG_REF(rhs); return rhs; };
    
        CFeatures* replace_rhs(CFeatures* rhs);
            
        virtual void remove_lhs_and_rhs();

        virtual void remove_lhs();

        virtual void remove_rhs();
        
        virtual EDistanceType get_distance_type()=0 ;

        virtual EFeatureType get_feature_type()=0;

        virtual EFeatureClass get_feature_class()=0;

        inline bool get_precompute_matrix() { return precompute_matrix ;  }

        inline virtual void set_precompute_matrix(bool flag)
        { 
            precompute_matrix=flag;
        
            if (!precompute_matrix)
            {
                SG_FREE(precomputed_matrix);
                precomputed_matrix=NULL;
            }
        }

        inline int32_t get_num_vec_lhs()
        {
            if (!lhs)
                return 0;
            else
                return lhs->get_num_vectors();
        }

        inline int32_t get_num_vec_rhs()
        {
            if (!rhs)
                return 0;
            else
                return rhs->get_num_vectors();
        }

        inline bool has_features()
        {
            return lhs && rhs;
        }

        inline bool lhs_equals_rhs()
        {
            return lhs==rhs;
        }

    protected:

        static void* run_distance_thread(void* p);      

        virtual float64_t compute(int32_t x, int32_t y)=0;

        void do_precompute_matrix();

    private:
        void init();

    protected:
        float32_t * precomputed_matrix;

        bool precompute_matrix;

        CFeatures* lhs;
        CFeatures* rhs;

};
} // namespace shogun
#endif