source: trunk/yat/classifier/Kernel.cc @ 2223

// $Id$

/*
  Copyright (C) 2006, 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson, Markus Ringnér

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "Kernel.h"
#include "DataLookup1D.h"
#include "DataLookupWeighted1D.h"
#include "KernelFunction.h"
#include "MatrixLookup.h"
#include "MatrixLookupWeighted.h"

#include "yat/utility/Exception.h"

#include <cassert>
#include <vector>

namespace theplu {
namespace yat {
namespace classifier {

  Kernel::Kernel(const MatrixLookup& data, const KernelFunction& kf, 
                 const bool own) 
    : ml_(&data), mlw_(0), kf_(&kf), ref_count_w_(NULL)
  {
    if (own)
      ref_count_ = new unsigned int(1);
    else
      ref_count_ = NULL;
  }


  Kernel::Kernel(const MatrixLookupWeighted& data, const KernelFunction& kf,
                 const bool own) 
    : ml_(NULL), mlw_(&data), kf_(&kf)
  {
    if (own){
      ref_count_w_ = new unsigned int(1);
    }
    else {
      ref_count_w_ = NULL;
    }
    ref_count_ = NULL;
  }


  Kernel::Kernel(const Kernel& other, const std::vector<size_t>& index)
    : kf_(other.kf_)
  {
    
    if (other.weighted()){
      mlw_ = new MatrixLookupWeighted(*other.mlw_, utility::Index(index),
                                      utility::Index(other.mlw_->columns()));
      ref_count_w_ = new unsigned int(1);
      ml_=NULL;
      ref_count_ = NULL;
    }
    else{
      ml_ = new MatrixLookup(*other.ml_, utility::Index(index),true);
      ref_count_ = new unsigned int(1);
      mlw_=NULL;
      ref_count_w_ = NULL;
    }

  }


  Kernel::~Kernel()
  {
    if (ref_count_)
      if (!--(*ref_count_))
        delete ml_;

    if (ref_count_w_)
      if (!--(*ref_count_w_))
        delete mlw_;

  }

  
  const MatrixLookup& Kernel::data(void) const
  {
    if (weighted())
      throw utility::runtime_error("Kernel::data when Kernel is weighted");
    assert(ml_);
    return *ml_;
  }


  const MatrixLookupWeighted& Kernel::data_weighted(void) const
  {
    if (!weighted())
      throw utility::runtime_error("Kernel:data_weighted when Kernel is unweighted");
    assert(mlw_);
    return *mlw_;
  }


  double Kernel::element(const DataLookup1D& vec, const size_t i) const
  {
    if (weighted())
      return kf_->operator()(vec, DataLookupWeighted1D(*mlw_,i, false)); 
    else
      return kf_->operator()(vec,DataLookup1D(*ml_,i, false)); 
  }


  double Kernel::element(const DataLookupWeighted1D& vec, const size_t i) const
  {
    if (weighted())
      return kf_->operator()(vec, DataLookupWeighted1D(*mlw_,i, false)); 
    else
      return kf_->operator()(vec, DataLookup1D(*ml_,i, false)); 
  }


  size_t Kernel::size(void) const
  {
    if (weighted())
      return mlw_->columns();
    assert(ml_);
    return ml_->columns();
  }


  bool Kernel::weighted(void) const
  {
    return mlw_;
  }

}}} // of namespace classifier, yat, and theplu