CommWordStringKernel.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
 * Written (W) 1999-2008 Gunnar Raetsch
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _COMMWORDSTRINGKERNEL_H___
#define _COMMWORDSTRINGKERNEL_H___

#include <shogun/lib/common.h>
#include <shogun/mathematics/Math.h>
#include <shogun/kernel/string/StringKernel.h>

namespace shogun
{
class CCommWordStringKernel : public CStringKernel<uint16_t>
{
    friend class CVarianceKernelNormalizer;
    friend class CSqrtDiagKernelNormalizer;
    friend class CAvgDiagKernelNormalizer;
    friend class CRidgeKernelNormalizer;
    friend class CFirstElementKernelNormalizer;
    friend class CTanimotoKernelNormalizer;
    friend class CDiceKernelNormalizer;

    public:
        CCommWordStringKernel();

        CCommWordStringKernel(int32_t size, bool use_sign);

        CCommWordStringKernel(
            CStringFeatures<uint16_t>* l, CStringFeatures<uint16_t>* r,
            bool use_sign=false, int32_t size=10);

        virtual ~CCommWordStringKernel();

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

        virtual void cleanup();

        virtual EKernelType get_kernel_type() { return K_COMMWORDSTRING; }

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

        virtual bool init_dictionary(int32_t size);

        virtual bool init_optimization(
            int32_t count, int32_t *IDX, float64_t* weights);

        virtual bool delete_optimization();

        virtual float64_t compute_optimized(int32_t idx);

        virtual void add_to_normal(int32_t idx, float64_t weight);

        virtual void clear_normal();

        virtual EFeatureType get_feature_type() { return F_WORD; }

        void get_dictionary(int32_t& dsize, float64_t*& dweights)
        {
            dsize=dictionary_size;
            dweights = dictionary_weights;
        }

        virtual float64_t* compute_scoring(
            int32_t max_degree, int32_t& num_feat, int32_t& num_sym,
            float64_t* target, int32_t num_suppvec, int32_t* IDX,
            float64_t* alphas, bool do_init=true);

        char* compute_consensus(
            int32_t &num_feat, int32_t num_suppvec, int32_t* IDX,
            float64_t* alphas);

        void set_use_dict_diagonal_optimization(bool flag)
        {
            use_dict_diagonal_optimization=flag;
        }

        bool get_use_dict_diagonal_optimization()
        {
            return use_dict_diagonal_optimization;
        }

    protected:
        virtual float64_t compute(int32_t idx_a, int32_t idx_b)
        {
            return compute_helper(idx_a, idx_b, false);
        }

        virtual float64_t compute_helper(
            int32_t idx_a, int32_t idx_b, bool do_sort);

        virtual float64_t compute_diag(int32_t idx_a);

    private:
        void init();

    protected:
        int32_t dictionary_size;
        float64_t* dictionary_weights;

        bool use_sign;

        bool use_dict_diagonal_optimization;
        int32_t* dict_diagonal_optimization;
};
}
#endif /* _COMMWORDSTRINGKERNEL_H__ */