source: trunk/c++_tools/classifier/MatrixLookup.cc @ 675

// $Id$

/*
  Copyright (C) The authors contributing to this file.

  This file is part of the yat library, http://lev.thep.lu.se/trac/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 "yat/classifier/MatrixLookup.h"

#include "yat/utility/matrix.h"

#ifndef NDEBUG
#include <algorithm>
#endif 

#include <fstream>

namespace theplu {
namespace classifier {

  MatrixLookup::MatrixLookup(const utility::matrix& data, const bool own)
    : DataLookup2D(own), data_(&data)
  {
    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);
  }
  


  MatrixLookup::MatrixLookup(const utility::matrix& data, 
                             const std::vector<size_t>& row, 
                             const std::vector<size_t>& col)
    : DataLookup2D(row,col), data_(&data)
  {
    // 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());
  }
  


  MatrixLookup::MatrixLookup(const utility::matrix& data, 
                             const std::vector<size_t>& index, 
                             const bool row)
    : DataLookup2D(), data_(&data)
  {
    if (row){
      // Checking that each row index is less than data.rows()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<data.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());
      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);
    }
  }
  


  MatrixLookup::MatrixLookup(const MatrixLookup& other)
    : DataLookup2D(other), data_(other.data_)
  {
    ref_count_=other.ref_count_;
    if (ref_count_)
      ++(*ref_count_);
  }



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


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

    // 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());
  }
  


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


  MatrixLookup::MatrixLookup(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);
  }


  MatrixLookup::~MatrixLookup(void)
  {
    if (ref_count_)
      if (!--(*ref_count_))
        delete data_;
  }


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



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



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



  bool MatrixLookup::weighted(void) const 
  {
    return false;
  }



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


  std::ostream& operator<<(std::ostream& s, const MatrixLookup& 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++) {
        s << m(i,j);
        if (j<m.columns()-1)
          s << s.fill();
        else if (i<m.rows()-1)
          s << "\n";
      }
    return s;
  }



}} // of namespace classifier and namespace theplu