source: trunk/yat/classifier/MatrixLookupWeighted.cc @ 1091

// $Id$

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

  This file is part of the yat library, http://trac.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 2 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "MatrixLookupWeighted.h"
#include "MatrixLookup.h"
#include "yat/utility/matrix.h"

#include <algorithm>
#include <cassert>
#include <fstream>

namespace theplu {
namespace yat {
namespace classifier {

  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data, 
                                             const utility::matrix& weights,
                                             const bool own)
    : DataLookup2D(own), data_(&data), weights_(&weights), 
      ref_count_weights_(NULL)
  {
    assert(data.rows()==weights.rows());
    assert(data.columns()==weights.columns());
    for(size_t i=0;i<(*data_).rows();i++)
      row_index_.push_back(i);
    for(size_t i=0;i<(*data_).columns();i++)
      column_index_.push_back(i);
  }


  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data)
    : DataLookup2D(), data_(&data)
  {
    utility::matrix weights;
    utility::nan(*data_,weights);
    weights_= new utility::matrix(weights);
    ref_count_weights_=new u_int(1);
    for(size_t i=0;i<(*data_).rows();i++)
      row_index_.push_back(i);
    for(size_t i=0;i<(*data_).columns();i++)
      column_index_.push_back(i);
  }


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& ml)
    : DataLookup2D(ml), data_(ml.data_)
  {
    weights_= new utility::matrix(data_->rows(), data_->columns(), 1.0);
    ref_count_weights_=new u_int(1);
    ref_count_=ml.ref_count_;
    if (ref_count_)
      ++(*ref_count_);

  }
  

  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data, 
                                             const utility::matrix& weights, 
                                             const std::vector<size_t>& row, 
                                             const std::vector<size_t>& col)
    : DataLookup2D(row,col), data_(&data), weights_(&weights),
      ref_count_weights_(NULL)
  {
    // Checking that each row index is less than data.rows()
    assert(row.empty() || 
           *(std::max_element(row.begin(),row.end()))<data.rows());
    // Checking that each column index is less than data.column()
    assert(col.empty() || 
           *(std::max_element(col.begin(),col.end()))<data.columns());
    // Checking that each row index is less than weights.rows()
    assert(row.empty() || 
           *(std::max_element(row.begin(),row.end()))<weights.rows());
    // Checking that each column index is less than weights.column()
    assert(col.empty() || 
           *(std::max_element(col.begin(),col.end()))<weights.columns());
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data, 
                                             const utility::matrix& weights, 
                                             const std::vector<size_t>& index, 
                                             const bool row)
    : DataLookup2D(), data_(&data), weights_(&weights),
      ref_count_weights_(NULL)
  {
    if (row){
      // Checking that each row index is less than data.rows()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<data.rows());
      // Checking that each row index is less than weights.rows()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<weights.rows());
      row_index_=index;
      assert(column_index_.empty());
      column_index_.reserve(data.columns());
      for (size_t i=0; i<data.columns(); i++)
        column_index_.push_back(i);
    }
    else{
      // Checking that each column index is less than data.column()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<data.columns());
      // Checking that each column index is less than weights.column()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<weights.columns());
      column_index_=index;
      assert(row_index_.empty());
      column_index_.reserve(data.rows());
      for (size_t i=0; i<data.rows(); i++)
        row_index_.push_back(i);
    }
  }
  

  /*
  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& dv,
                                             const MatrixLookup& wv)
    : DataLookup2D(dv), data_(dv.data_), weights_(dv.data_)
  {
  }
  */


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other)
    : DataLookup2D(other), data_(other.data_), weights_(other.weights_)
  {
    ref_count_ = other.ref_count_;
    if (ref_count_)
      ++(*ref_count_);
    ref_count_weights_ = other.ref_count_weights_;
    if (ref_count_weights_)
      ++(*ref_count_weights_);

  }



  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other,
                                             const std::vector<size_t>& row, 
                                             const std::vector<size_t>& col)
    : DataLookup2D(other,row,col), data_(other.data_), weights_(other.weights_)
  {
    ref_count_ = other.ref_count_;
    if (ref_count_)
      ++(*ref_count_);
    ref_count_weights_ = other.ref_count_weights_;
    if (ref_count_weights_)
      ++(*ref_count_weights_);
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other, 
                                             const std::vector<size_t>& index, 
                                             bool row)
    : DataLookup2D(other,index,row), data_(other.data_), 
      weights_(other.weights_)
  {
    ref_count_ = other.ref_count_;
    if (ref_count_)
      ++(*ref_count_);
    ref_count_weights_ = other.ref_count_weights_;
    if (ref_count_weights_)
      ++(*ref_count_weights_);

    // Checking that no index is out of range
    assert(row_index_.empty() || 
           *(max_element(row_index_.begin(), row_index_.end()))<data_->rows());
    assert(column_index_.empty() || 
           *(max_element(column_index_.begin(), column_index_.end()))<
           data_->columns());
    // Checking that no index is out of range
    assert(row_index_.empty() || 
           *(max_element(row_index_.begin(), row_index_.end()))<
           weights_->rows());
    assert(column_index_.empty() || 
           *(max_element(column_index_.begin(), column_index_.end()))<
           weights_->columns());
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const size_t rows, 
                                             const size_t columns, 
                                             const double value,
                                             const double weight)
    : DataLookup2D(rows,columns)
  {
    data_ = new utility::matrix(1,1,value);
    ref_count_=new u_int(1);
    weights_ = new utility::matrix(1,1,weight);
    ref_count_weights_=new u_int(1);
  }

  
  MatrixLookupWeighted::MatrixLookupWeighted(std::istream& is, char sep)
    : DataLookup2D()
  {
    data_ = new utility::matrix(is,sep);
    ref_count_=new u_int(1);
    for(size_t i=0;i<(*data_).rows();i++)
      row_index_.push_back(i);
    for(size_t i=0;i<(*data_).columns();i++)
      column_index_.push_back(i);
    utility::matrix weights;
    utility::nan(*data_,weights);
    weights_= new utility::matrix(weights);
    ref_count_weights_=new u_int(1);
  }
  

  MatrixLookupWeighted::~MatrixLookupWeighted(void)
  {
    if (ref_count_)
      if (!--(*ref_count_))
        delete data_;
    if (ref_count_weights_)
      if (!--(*ref_count_weights_))
        delete weights_;
  }



  MatrixLookupWeighted::const_iterator MatrixLookupWeighted::begin(void) const
  {
    return const_iterator(const_iterator::iterator_type(*this, 0, 0), 1);
  }


  MatrixLookupWeighted::const_iterator 
  MatrixLookupWeighted::begin_column(size_t i) const
  {
    return const_iterator(const_iterator::iterator_type(*this, 0, i),columns());
  }


  MatrixLookupWeighted::const_iterator 
  MatrixLookupWeighted::begin_row(size_t i) const
  {
    return const_iterator(const_iterator::iterator_type(*this, i, 0), 1);
  }


  double MatrixLookupWeighted::data(size_t row, size_t column) const
  {
    return (*data_)(row_index_[row], column_index_[column]);
  }



  MatrixLookupWeighted::const_iterator MatrixLookupWeighted::end(void) const
  {
    return const_iterator(const_iterator::iterator_type(*this, rows(), 0), 1);
  }


  MatrixLookupWeighted::const_iterator 
  MatrixLookupWeighted::end_column(size_t i) const
  {
    return const_iterator(const_iterator::iterator_type(*this, rows(), i), 
                          columns());
  }


  MatrixLookupWeighted::const_iterator 
  MatrixLookupWeighted::end_row(size_t i) const
  {
    return const_iterator(const_iterator::iterator_type(*this, i+1, 0), 1);
  }


  const MatrixLookupWeighted* 
  MatrixLookupWeighted::selected(const std::vector<size_t>& i) const
  { 
    return new MatrixLookupWeighted(*this,i, true); 
  }



  const MatrixLookupWeighted* 
  MatrixLookupWeighted::training_data(const std::vector<size_t>& i) const
  { 
    return new MatrixLookupWeighted(*this,i, false); 
  }



  const MatrixLookupWeighted* 
  MatrixLookupWeighted::validation_data(const std::vector<size_t>& train,
                                        const std::vector<size_t>& val) const
  { 
    return new MatrixLookupWeighted(*this,val, false); 
  }



  double MatrixLookupWeighted::weight(size_t row, size_t column) const
  {
    return (*weights_)(row_index_[row], column_index_[column]);
  }



  bool MatrixLookupWeighted::weighted(void) const 
  {
    return true;
  }



  double MatrixLookupWeighted::operator()(const size_t row,
                                          const size_t column) const
  { 
    return (weight(row,column) ? data(row,column)*weight(row,column) : 0);
  }



  const MatrixLookupWeighted& MatrixLookupWeighted::operator=
  (const MatrixLookupWeighted& other)
  {
    if (this!=&other){
      if (ref_count_ && !--(*ref_count_))
        delete data_;
      if (ref_count_weights_ && !--(*ref_count_weights_))
        delete weights_;
      DataLookup2D::operator=(other);
      data_ = other.data_;
      ref_count_=other.ref_count_;
      if (ref_count_)
        ++(*ref_count_);
      weights_ = other.weights_;
      ref_count_weights_ = other.ref_count_weights_;
      if (ref_count_weights_)
        ++(*ref_count_weights_);
    }
    return *this;
  }


  std::ostream& operator<<(std::ostream& s, const MatrixLookupWeighted& m)
  {
    s.setf(std::ios::dec);
    s.precision(12);
    for(size_t i=0, j=0; i<m.rows(); i++)
      for (j=0; j<m.columns(); j++) {
        if (m.weight(i,j))
          s << m.data(i,j);
        if (j<m.columns()-1)
          s << s.fill();
        else if (i<m.rows()-1)
          s << "\n";
      }
    return s;
  }



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