CommUlongStringKernel.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 _COMMULONGSTRINGKERNEL_H___
#define _COMMULONGSTRINGKERNEL_H___

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

namespace shogun
{
template <class T> class CDynamicArray;
template <class ST> class CStringFeatures;

class CCommUlongStringKernel: public CStringKernel<uint64_t>
{
    public:
        CCommUlongStringKernel(int32_t size=10, bool use_sign=false);

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

        virtual ~CCommUlongStringKernel();

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

        virtual void cleanup();

        virtual EKernelType get_kernel_type() { return K_COMMULONGSTRING; }

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

        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);

        inline void merge_dictionaries(
            int32_t& t, int32_t j, int32_t& k, uint64_t* vec, uint64_t* dic,
            float64_t* dic_weights, float64_t weight, int32_t vec_idx)
        {
            while (k<dictionary.get_num_elements() && dictionary[k] < vec[j-1])
            {
                dic[t]=dictionary[k];
                dic_weights[t]=dictionary_weights[k];
                t++;
                k++;
            }

            if (k<dictionary.get_num_elements() && dictionary[k]==vec[j-1])
            {
                dic[t]=vec[j-1];
                dic_weights[t]=dictionary_weights[k]+normalizer->normalize_lhs(weight, vec_idx);
                k++;
            }
            else
            {
                dic[t]=vec[j-1];
                dic_weights[t]=normalizer->normalize_lhs(weight, vec_idx);
            }
            t++;
        }

        virtual void add_to_normal(int32_t idx, float64_t weight);

        virtual void clear_normal();

        virtual void remove_lhs();

        virtual void remove_rhs();

        inline virtual EFeatureType get_feature_type() { return F_ULONG; }

        void get_dictionary(
            int32_t &dsize, uint64_t*& dict, float64_t*& dweights)
        {
            dsize=dictionary.get_num_elements();
            dict=dictionary.get_array();
            dweights = dictionary_weights.get_array();
        }

    protected:
        float64_t compute(int32_t idx_a, int32_t idx_b);

    protected:
        CDynamicArray<uint64_t> dictionary;
        CDynamicArray<float64_t> dictionary_weights;

        bool use_sign;
};
}
#endif /* _COMMULONGFSTRINGKERNEL_H__ */