svmdataset.c

Go to the documentation of this file.

/*
Copyright (C) 2012 Daniele Perrone.
Copyright (C) 2013 Andrea Vedaldi.
All rights reserved.

This file is part of the VLFeat library and is made available under
the terms of the BSD license (see the COPYING file).
*/

/* ---------------------------------------------------------------- */
#ifndef VL_SVMDATASET_INSTANTIATING
/* ---------------------------------------------------------------- */

#include "svmdataset.h"
#include <string.h>
#include <math.h>

struct VlSvmDataset_ {
  vl_type dataType ;                
  void * data ;                     
  vl_size numData ;                 
  vl_size dimension ;               
  VlHomogeneousKernelMap * hom ;    
  void * homBuffer ;                
  vl_size homDimension ;            
} ;

/* templetized parts of the implementation */
#define FLT VL_TYPE_FLOAT
#define VL_SVMDATASET_INSTANTIATING
#include "svmdataset.c"

#define FLT VL_TYPE_DOUBLE
#define VL_SVMDATASET_INSTANTIATING
#include "svmdataset.c"

VlSvmDataset*
vl_svmdataset_new (vl_type dataType, void *data, vl_size dimension, vl_size numData)
{
  VlSvmDataset * self ;
  assert(dataType == VL_TYPE_DOUBLE || dataType == VL_TYPE_FLOAT) ;
  assert(data) ;

  self = vl_calloc(1, sizeof(VlSvmDataset)) ;
  if (self == NULL) return NULL ;

  self->dataType = dataType ;
  self->data = data ;
  self->dimension = dimension ;
  self->numData = numData ;
  self->hom = NULL ;
  self->homBuffer = NULL ;
  return self ;
}

void vl_svmdataset_delete (VlSvmDataset *self)
{
  if (self->homBuffer) {
    vl_free(self->homBuffer) ;
    self->homBuffer = 0 ;
  }
  vl_free (self) ;
}

void*
vl_svmdataset_get_data (VlSvmDataset const *self)
{
  return self->data ;
}

vl_size
vl_svmdataset_get_num_data (VlSvmDataset const *self)
{
  return self->numData ;
}

vl_size
vl_svmdataset_get_dimension (VlSvmDataset const *self)
{
  if (self->hom) {
    return self->dimension * vl_homogeneouskernelmap_get_dimension(self->hom) ;
  }
  return self->dimension ;
}

VlHomogeneousKernelMap *
vl_svmdataset_get_homogeneous_kernel_map (VlSvmDataset const *self)
{
  assert(self) ;
  return self->hom ;
}

void
vl_svmdataset_set_homogeneous_kernel_map (VlSvmDataset * self,
                                          VlHomogeneousKernelMap * hom)
{
  assert(self) ;
  self->hom = hom ;
  self->homDimension = 0 ;
  if (self->homBuffer) {
    vl_free (self->homBuffer) ;
    self->homBuffer = 0 ;
  }
  if (self->hom) {
    self->homDimension = vl_homogeneouskernelmap_get_dimension(self->hom) ;
    self->homBuffer = vl_calloc(self->homDimension, vl_get_type_size(self->dataType)) ;
  }
}

VlSvmAccumulateFunction
vl_svmdataset_get_accumulate_function(VlSvmDataset const *self)
{
  if (self->hom == NULL) {
    switch (self->dataType) {
      case VL_TYPE_FLOAT:
        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_f ;
        break ;
      case VL_TYPE_DOUBLE:
        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_d ;
        break ;
    }
  } else {
    switch (self->dataType) {
      case VL_TYPE_FLOAT:
        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_hom_f ;
        break ;
      case VL_TYPE_DOUBLE:
        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_hom_d ;
        break ;
    }
  }
  assert(0) ;
  return NULL ;
}

VlSvmInnerProductFunction
vl_svmdataset_get_inner_product_function (VlSvmDataset const *self)
{
  if (self->hom == NULL) {
    switch (self->dataType) {
      case VL_TYPE_FLOAT:
        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_f ;
        break ;
      case VL_TYPE_DOUBLE:
        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_d ;
        break ;
      default:
        assert(0) ;
    }
  } else {
    switch (self->dataType) {
      case VL_TYPE_FLOAT:
        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_hom_f ;
        break ;
      case VL_TYPE_DOUBLE:
        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_hom_d ;
        break ;
      default:
        assert(0) ;
    }
  }

  return NULL;
}

/* VL_SVMDATASET_INSTANTIATING */
#endif

/* ---------------------------------------------------------------- */
#ifdef VL_SVMDATASET_INSTANTIATING
/* ---------------------------------------------------------------- */

#include "float.th"

double
VL_XCAT(_vl_svmdataset_inner_product_,SFX) (VlSvmDataset const *self,
                                            vl_uindex element,
                                            double const *model)
{
  double product = 0 ;
  T* data = ((T*)self->data) + self->dimension * element ;
  T* end = data + self->dimension ;
  while (data != end) {
    product += (*data++) * (*model++) ;
  }
  return product ;
}

void
VL_XCAT(vl_svmdataset_accumulate_,SFX)(VlSvmDataset const *self,
                                       vl_uindex element,
                                       double *model,
                                       const double multiplier)
{
  T* data = ((T*)self->data) + self->dimension * element ;
  T* end = data + self->dimension ;
  while (data != end) {
    *model += (*data++) * multiplier ;
    model++ ;
  }
}

double
VL_XCAT(_vl_svmdataset_inner_product_hom_,SFX) (VlSvmDataset const *self,
                                                vl_uindex element,
                                                double const *model)
{
  double product = 0 ;
  T* data = ((T*)self->data) + self->dimension * element ;
  T* end = data + self->dimension ;
  T* bufEnd = ((T*)self->homBuffer)+ self->homDimension ;
  while (data != end) {
    /* TODO: zeros in data could be optimized by skipping over them */
    T* buf = self->homBuffer ;
    VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)(self->hom,
                                                   self->homBuffer,
                                                   1,
                                                   (*data++)) ;
    while (buf != bufEnd) {
      product += (*buf++) * (*model++) ;
    }
  }
  return product ;
}

void
VL_XCAT(vl_svmdataset_accumulate_hom_,SFX)(VlSvmDataset const *self,
                                           vl_uindex element,
                                           double *model,
                                           const double multiplier)
{
  T* data = ((T*)self->data) + self->dimension * element ;
  T* end = data + self->dimension ;
  T* bufEnd = ((T*)self->homBuffer)+ self->homDimension ;
  while (data != end) {
    /* TODO: zeros in data could be optimized by skipping over them */
    T* buf = self->homBuffer ;
    VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)(self->hom,
                                                   self->homBuffer,
                                                   1,
                                                   (*data++)) ;
    while (buf != bufEnd) {
      *model += (*buf++) * multiplier ;
      model++ ;
    }
  }
}

#undef FLT
#undef VL_SVMDATASET_INSTANTIATING

/* VL_SVMDATASET_INSTANTIATING */
#endif