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

#ifndef _CUSTOMDISTANCE_H___
#define _CUSTOMDISTANCE_H___

#include <shogun/mathematics/Math.h>
#include <shogun/lib/common.h>
#include <shogun/distance/Distance.h>
#include <shogun/features/Features.h>

namespace shogun
{
class CCustomDistance: public CDistance
{
    public:
        CCustomDistance();

        CCustomDistance(CDistance* d);

        CCustomDistance(const SGMatrix<float64_t> distance_matrix);

        CCustomDistance(
            const float64_t* dm, int32_t rows, int32_t cols);

        CCustomDistance(
            const float32_t* dm, int32_t rows, int32_t cols);

        virtual ~CCustomDistance();

        virtual bool dummy_init(int32_t rows, int32_t cols);

        virtual bool init(CFeatures* l, CFeatures* r);

        virtual void cleanup();

        inline virtual EDistanceType get_distance_type() { return D_CUSTOM; }

        inline virtual EFeatureType get_feature_type() { return F_ANY; }

        inline virtual EFeatureClass get_feature_class() { return C_ANY; }

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

        bool set_triangle_distance_matrix_from_triangle(
            const float64_t* dm, int32_t len)
        {
            return set_triangle_distance_matrix_from_triangle_generic(dm, len);
        }

        bool set_triangle_distance_matrix_from_triangle(
            const float32_t* dm, int32_t len)
        {
            return set_triangle_distance_matrix_from_triangle_generic(dm, len);
        }

        template <class T>
        bool set_triangle_distance_matrix_from_triangle_generic(
            const T* dm, int64_t len)
        {
            ASSERT(dm);
            ASSERT(len>0);

            int64_t cols = (int64_t) floor(-0.5 + CMath::sqrt(0.25+2*len));

            int64_t int32_max=2147483647;

            if (cols> int32_max)
                SG_ERROR("Matrix larger than %d x %d\n", int32_max);

            if (cols*(cols+1)/2 != len)
            {
                SG_ERROR("dm should be a vector containing a lower triangle matrix, with len=cols*(cols+1)/2 elements\n");
                return false;
            }

            cleanup_custom();
            SG_DEBUG( "using custom distance of size %dx%d\n", cols,cols);

            dmatrix= SG_MALLOC(float32_t, len);

            upper_diagonal=true;
            num_rows=cols;
            num_cols=cols;

            for (int64_t i=0; i<len; i++)
                dmatrix[i]=dm[i];

            dummy_init(num_rows, num_cols);
            return true;
        }

        inline bool set_triangle_distance_matrix_from_full(
            const float64_t* dm, int32_t rows, int32_t cols)
        {
            return set_triangle_distance_matrix_from_full_generic(dm, rows, cols);
        }

        inline bool set_triangle_distance_matrix_from_full(
            const float32_t* dm, int32_t rows, int32_t cols)
        {
            return set_triangle_distance_matrix_from_full_generic(dm, rows, cols);
        }

        template <class T>
        bool set_triangle_distance_matrix_from_full_generic(
            const T* dm, int32_t rows, int32_t cols)
        {
            ASSERT(rows==cols);

            cleanup_custom();
            SG_DEBUG( "using custom distance of size %dx%d\n", cols,cols);

            dmatrix= SG_MALLOC(float32_t, int64_t(cols)*(cols+1)/2);

            upper_diagonal=true;
            num_rows=cols;
            num_cols=cols;

            for (int64_t row=0; row<num_rows; row++)
            {
                for (int64_t col=row; col<num_cols; col++)
                {
                    int64_t idx=row * num_cols - row*(row+1)/2 + col;
                    dmatrix[idx]= (float32_t) dm[col*num_rows+row];
                }
            }
            dummy_init(rows, cols);
            return true;
        }

        bool set_full_distance_matrix_from_full(
            const float64_t* dm, int32_t rows, int32_t cols)
        {
            return set_full_distance_matrix_from_full_generic(dm, rows, cols);
        }

        bool set_full_distance_matrix_from_full(
            const float32_t* dm, int32_t rows, int32_t cols)
        {
            return set_full_distance_matrix_from_full_generic(dm, rows, cols);
        }

        template <class T>
        bool set_full_distance_matrix_from_full_generic(
            const T* dm, int32_t rows, int32_t cols)
        {
            cleanup_custom();
            SG_DEBUG( "using custom distance of size %dx%d\n", rows,cols);

            dmatrix= SG_MALLOC(float32_t, rows*cols);

            upper_diagonal=false;
            num_rows=rows;
            num_cols=cols;

            for (int32_t row=0; row<num_rows; row++)
            {
                for (int32_t col=0; col<num_cols; col++)
                {
                    dmatrix[row * num_cols + col]=dm[col*num_rows+row];
                }
            }

            dummy_init(rows, cols);
            return true;
        }

        virtual inline int32_t get_num_vec_lhs()
        {
            return num_rows;
        }

        virtual inline int32_t get_num_vec_rhs()
        {
            return num_cols;
        }

        virtual inline bool has_features()
        {
            return (num_rows>0) && (num_cols>0);
        }

    protected:
        inline virtual float64_t compute(int32_t row, int32_t col)
        {
            ASSERT(dmatrix);

            if (upper_diagonal)
            {
                if (row <= col)
                {
                    int64_t r=row;
                    return dmatrix[r*num_cols - r*(r+1)/2 + col];
                }
                else
                {
                    int64_t c=col;
                    return dmatrix[c*num_cols - c*(c+1)/2 + row];
                }
            }
            else
            {
                int64_t r=row;
                return dmatrix[r*num_cols+col];
            }
        }

    private:
        void init();

        void cleanup_custom();

    protected:
        float32_t* dmatrix;
        int32_t num_rows;
        int32_t num_cols;
        bool upper_diagonal;
};

}
#endif /* _CUSTOMKERNEL_H__ */