add log,diag

src/shogun/kernel/DiagKernel.cpp

@@ -17,36 +17,26 @@ using namespace shogun;
 DiagKernel::DiagKernel()
 : Kernel()
 {
- init();
+ m_diag=1.0;
+ SG_ADD(&m_diag, "diag", "Value on kernel diagonal.", ParameterProperties::HYPER);
 }
 
 DiagKernel::DiagKernel(int32_t size, float64_t d)
-: Kernel(size)
+: DiagKernel()
 {
- init();
- diag=d;
+ set_cache_size(size);
+ m_diag = d;
 }
 
 DiagKernel::DiagKernel(std::shared_ptr<Features> l, std::shared_ptr<Features> r, float64_t d)
-: Kernel()
+: DiagKernel()
 {
- init();
- diag=d;
- init(std::move(l), std::move(r));
+ m_diag=d;
+ ASSERT(Kernel::init(std::move(l), std::move(r)));
+ init_normalizer();
 }
 
 DiagKernel::~DiagKernel()
 {
 }
 
-bool DiagKernel::init(std::shared_ptr<Features> l, std::shared_ptr<Features> r)
-{
- Kernel::init(l, r);
- return init_normalizer();
-}
-
-void DiagKernel::init()
-{
- diag=1.0;
- SG_ADD(&diag, "diag", "Value on kernel diagonal.", ParameterProperties::HYPER);
-}

src/shogun/kernel/DiagKernel.h

@@ -24,7 +24,7 @@ namespace shogun
 class DiagKernel: public Kernel
 {
  public:
- /** default constructor */
+
  DiagKernel();
 
  /** constructor
@@ -44,66 +44,22 @@ class DiagKernel: public Kernel
 
  virtual ~DiagKernel();
 
- /** initialize kernel
- *
- * @param l features of left-hand side
- * @param r features of right-hand side
- * @return if initializing was successful
- */
- virtual bool init(std::shared_ptr<Features> l, std::shared_ptr<Features> r);
-
- /** return feature type the kernel can deal with
- *
- * @return feature type ANY
- */
- virtual EFeatureType get_feature_type()
- {
- return F_ANY;
- }
+ inline virtual EFeatureType get_feature_type(){ return F_ANY; }
 
- /** return feature class the kernel can deal with
- *
- * @return feature class ANY
- */
- virtual EFeatureClass get_feature_class()
- {
- return C_ANY;
- }
+ inline virtual EFeatureClass get_feature_class(){ return C_ANY; }
 
- /** return what type of kernel we are
- *
- * @return kernel type CUSTOM
- */
- virtual EKernelType get_kernel_type() { return K_DIAG; }
+ inline virtual EKernelType get_kernel_type() { return K_DIAG; }
 
- /** return the kernel's name
- *
- * @return name Custom
- */
- virtual const char* get_name() const { return "DiagKernel"; }
+ inline virtual const char* get_name() const { return "DiagKernel"; }
 
  protected:
- /** compute kernel function for features a and b
- * idx_{a,b} denote the index of the feature vectors
- * in the corresponding feature object
- *
- * @param idx_a index a
- * @param idx_b index b
- * @return computed kernel function at indices a,b
- */
- virtual float64_t compute(int32_t idx_a, int32_t idx_b)
+ inline virtual float64_t compute(int32_t idx_a, int32_t idx_b)
  {
- if (idx_a==idx_b)
- return diag;
- else
- return 0;
+ return idx_a == idx_b ? m_diag : 0;
  }
- private:
- void init();
 
  protected:
- /** diagonal */
- float64_t diag;
+ float64_t m_diag;
 };
 }
 #endif /* _DIAGKERNEL_H__ */

src/shogun/kernel/LogKernel.cpp

@@ -11,46 +11,32 @@
 
 using namespace shogun;
 
-LogKernel::LogKernel(): Kernel(0), m_distance(NULL), m_degree(1.8)
+LogKernel::LogKernel(): Kernel(0)
 {
- init();
+ SG_ADD(&m_degree, "degree", "Degree kernel parameter.", ParameterProperties::HYPER);
+ SG_ADD(&m_distance, "distance", "Distance to be used.", ParameterProperties::HYPER);
 }
 
 LogKernel::LogKernel(int32_t cache, float64_t degree, std::shared_ptr<Distance> dist)
-: Kernel(cache), m_distance(std::move(dist)), m_degree(degree)
+: LogKernel()
 {
- init();
- ASSERT(m_distance)
-
+ set_cache_size(cache);
+ m_degree = degree;
+ m_distance = std::move(dist);
+ ASSERT(m_distance); 
 }
 
 LogKernel::LogKernel(std::shared_ptr<Features >l, std::shared_ptr<Features >r, float64_t degree, std::shared_ptr<Distance> dist)
-: Kernel(10), m_distance(std::move(dist)), m_degree(degree)
-{
- init();
- ASSERT(m_distance)
-
- init(std::move(l), std::move(r));
+: LogKernel(10, degree, std::move(dist))
+{ 
+ Kernel::init(l,r);
+ ASSERT(m_distance->init(l,r));
+ init_normalizer();
 }
 
 LogKernel::~LogKernel()
 {
  cleanup();
-
-}
-
-bool LogKernel::init(std::shared_ptr<Features> l, std::shared_ptr<Features> r)
-{
- ASSERT(m_distance)
- Kernel::init(l,r);
- m_distance->init(l,r);
- return init_normalizer();
-}
-
-void LogKernel::init()
-{
- SG_ADD(&m_degree, "degree", "Degree kernel parameter.", ParameterProperties::HYPER);
- SG_ADD(&m_distance, "distance", "Distance to be used.", ParameterProperties::HYPER);
 }
 
 float64_t LogKernel::compute(int32_t idx_a, int32_t idx_b)

src/shogun/kernel/LogKernel.h

@@ -31,7 +31,7 @@ class Distance;
 class LogKernel: public Kernel
 {
 public:
- /** default constructor */
+
  LogKernel();
 
  /** constructor
@@ -56,47 +56,23 @@ class LogKernel: public Kernel
  */
  virtual bool init(std::shared_ptr<Features> l, std::shared_ptr<Features> r);
 
- /**
- * @return kernel type
- */
  virtual EKernelType get_kernel_type() { return K_POWER; }
 
- /**
- * @return type of features
- */
  virtual EFeatureType get_feature_type() { return m_distance->get_feature_type(); }
 
- /**
- * @return class of features
- */
  virtual EFeatureClass get_feature_class() { return m_distance->get_feature_class(); }
 
- /**
- * @return name of kernel
- */
  virtual const char* get_name() const { return "LogKernel"; }
 
  virtual ~LogKernel();
 
 protected:
- /**
- * compute kernel for specific feature vectors
- * corresponding to [idx_a] of left-side and [idx_b] of right-side
- * @param idx_a left-side index
- * @param idx_b right-side index
- * @return kernel value
- */
  virtual float64_t compute(int32_t idx_a, int32_t idx_b);
 
-private:
- void init();
-
 protected:
- /// distance to be used
- std::shared_ptr<Distance> m_distance;
+ std::shared_ptr<Distance> m_distance = NULL;
 
- /// degree parameter of kernel
- float64_t m_degree;
+ float64_t m_degree = 1.8;
 };
 }