source: trunk/yat/classifier/SVindex.cc @ 1487

// $Id: SVindex.cc 1487 2008-09-10 08:41:36Z jari $

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

  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 "SVindex.h"
#include "yat/random/random.h"
#include "yat/statistics/Averager.h"
#include "yat/utility/Vector.h"

#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <limits>
#include <utility>
#include <vector>

namespace theplu {
namespace yat {
namespace classifier {  

  SVindex::SVindex(void)
    : nof_sv_(0), vec_(std::vector<size_t>(0))
  {
  }

  SVindex::SVindex(const size_t n)
    : nof_sv_(0), vec_(std::vector<size_t>(n))
  {
    for (size_t i=0; i<vec_.size(); i++)
      vec_[i]=i;
  }

  size_t SVindex::index_first(void) const
  {
    assert(index_first_<size());
    return index_first_;
  }

  size_t SVindex::index_second(void) const
  {
    assert(index_second_<size());
    return index_second_;
  }

  void SVindex::init(const utility::Vector& alpha, const double tol)
  {
    nof_sv_=0;
    size_t nof_nsv=0;
    vec_.resize(alpha.size());
    for (size_t i=0; i<alpha.size(); i++) 
      if (alpha(i)<tol){
        nof_nsv++;
        vec_[vec_.size()-nof_nsv]=i;
      }
      else{
        vec_[nof_sv_]=i;
        nof_sv_++;
      }
    assert(nof_sv_+nof_nsv==vec_.size());

  }

  size_t SVindex::nof_sv(void) const
  {
    return nof_sv_;
  }

  void SVindex::nsv_first(void)
  {
    // if already nsv, do nothing
    if ( !(index_first_<nof_sv()) )
      return;
    
    if(index_second_==nof_sv_-1)
      index_second_=index_first_;
    vec_[index_first_]=vec_[nof_sv_-1];
    vec_[nof_sv_-1]=value_first_;
    index_first_=nof_sv_-1;
    
    nof_sv_--;
  }

  void SVindex::nsv_second(void)
  {
    // if already nsv, do nothing
    if ( !(index_second_<nof_sv()) )
      return;

    if(index_first_==nof_sv_-1)
      index_first_=index_second_;
    vec_[index_second_]=vec_[nof_sv_-1];
    vec_[nof_sv_-1]=value_second_;
    index_second_ = nof_sv_-1;
    
    nof_sv_--;
  }


  void SVindex::shuffle(void)
  {
    random::random_shuffle(vec_.begin()+nof_sv_, vec_.end()); 
  }

  size_t SVindex::size(void) const
  {
    return vec_.size();
  }

  void SVindex::sv_first(void)
  {
    // if already sv, do nothing
    if (index_first_<nof_sv())
      return;

    // swap elements
    if(index_second_==nof_sv_){
      index_second_=index_first_;
    }
    vec_[index_first_]=vec_[nof_sv_];
    vec_[nof_sv_]=value_first_;
    index_first_ = nof_sv_;

    nof_sv_++;

  }

  void SVindex::sv_second(void)
  {
    // if already sv, do nothing
    if (index_second_<nof_sv())
      return;

    // swap elements
    if(index_first_==nof_sv_){
      index_first_=index_second_;
    }

    vec_[index_second_]=vec_[nof_sv_];
    vec_[nof_sv_]=value_second_;
    index_second_=nof_sv_;

    nof_sv_++;
  }

  void SVindex::update_first(const size_t i)
  {
    assert(i<size());
    index_first_=i;
    value_first_=vec_[i];
  }

  void SVindex::update_second(const size_t i)
  {
    assert(i<size());
    index_second_=i;
    value_second_=vec_[i];
  }

  size_t SVindex::value_first(void) const
  {
    assert(value_first_<size());
    return value_first_;
  }

  size_t SVindex::value_second(void) const
  {
    assert(value_second_<size());
    return value_second_;
  }

  size_t SVindex::operator()(size_t i) const
  {
    assert(i<size());
    assert(vec_[i]<size());
    return vec_[i];
  }

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