source: trunk/yat/classifier/MatrixLookup.cc @ 1274

Last change on this file since 1274 was 1170, checked in by Peter, 13 years ago

removing DataLookup2D closes ticket:243

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date ID
File size: 6.1 KB
Line 
1// $Id$
2
3/*
4  Copyright (C) 2005 Markus Ringnér, Peter Johansson
5  Copyright (C) 2006 Jari Häkkinen, Markus Ringnér, Peter Johansson
6  Copyright (C) 2007 Peter Johansson
7
8  This file is part of the yat library, http://trac.thep.lu.se/yat
9
10  The yat library is free software; you can redistribute it and/or
11  modify it under the terms of the GNU General Public License as
12  published by the Free Software Foundation; either version 2 of the
13  License, or (at your option) any later version.
14
15  The yat library is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  General Public License for more details.
19
20  You should have received a copy of the GNU General Public License
21  along with this program; if not, write to the Free Software
22  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
23  02111-1307, USA.
24*/
25
26#include "MatrixLookup.h"
27#include "yat/utility/Matrix.h"
28
29#include <algorithm>
30#include <cassert>
31#include <fstream>
32#include <vector>
33
34namespace theplu {
35namespace yat {
36namespace classifier {
37
38  MatrixLookup::MatrixLookup(const utility::Matrix& data, const bool own)
39    : data_(MatrixP(&data, own))
40  {
41    column_index_ = utility::Index(data.columns());
42    row_index_ = utility::Index(data.rows());
43    assert(rows()==data.rows());
44    assert(columns()==data.columns());
45    assert(validate());
46  }
47 
48
49
50  MatrixLookup::MatrixLookup(const utility::Matrix& data, 
51                             const utility::Index& row, 
52                             const utility::Index& col)
53    : column_index_(col),
54      data_(MatrixP(&data, false)), 
55      row_index_(row)
56
57  {
58    assert(rows()==row.size());
59    assert(columns()==col.size());
60    assert(validate());
61  }
62 
63
64
65  MatrixLookup::MatrixLookup(const utility::Matrix& data, 
66                             const utility::Index& index, 
67                             const bool row)
68    : data_(MatrixP(&data, false))
69  {
70    if (row){
71      row_index_=index;
72      column_index_ = utility::Index(data.columns());
73    }
74    else{
75      column_index_=index;
76      row_index_ = utility::Index(data.rows());
77    }
78    assert(row || rows()==data.rows());
79    assert(row || columns()==index.size());
80    assert(!row || rows()==index.size());
81    assert(!row || columns()==data.columns());
82    assert(validate());
83  }
84 
85
86
87  MatrixLookup::MatrixLookup(const MatrixLookup& other)
88    : column_index_(other.column_index_), 
89      data_(other.data_),
90      row_index_(other.row_index_)
91  {
92    assert(validate());
93  }
94
95
96
97  MatrixLookup::MatrixLookup(const MatrixLookup& other, 
98                             const utility::Index& row, 
99                             const utility::Index& col)
100    : column_index_(utility::Index(other.column_index_, col)), 
101      data_(other.data_), row_index_(utility::Index(other.row_index_, row)) 
102  {
103    assert(rows()==row.size());
104    assert(columns()==col.size());
105    assert(validate());
106  }
107 
108
109
110  MatrixLookup::MatrixLookup(const MatrixLookup& other, 
111                             const utility::Index& index, bool row)
112    : data_(other.data_)
113  {
114    if (row){
115      row_index_ = utility::Index(other.row_index_, index);
116      column_index_= other.column_index_;
117    }
118    else{
119      column_index_ = utility::Index(other.column_index_, index);
120      row_index_= other.row_index_;
121    }
122    assert(validate());
123  }
124 
125
126
127  MatrixLookup::MatrixLookup(const size_t rows, const size_t columns, 
128                             const double value)
129    : data_(MatrixP(new utility::Matrix(1,1,value)))
130  {   
131    column_index_ = utility::Index(std::vector<size_t>(columns, 0));
132    row_index_ = utility::Index(std::vector<size_t>(rows,0));
133    assert(validate());
134  }
135
136
137  MatrixLookup::MatrixLookup(std::istream& is, char sep)
138    : data_(MatrixP(new utility::Matrix(is,sep)))
139  {
140    column_index_ = utility::Index(data_->columns());
141    row_index_ = utility::Index(data_->rows());
142    assert(validate());
143  }
144
145
146  MatrixLookup::~MatrixLookup(void)
147  {
148  }
149
150
151  MatrixLookup::const_iterator MatrixLookup::begin(void) const
152  {
153    return const_iterator(const_iterator::iterator_type(*this, 0, 0), 1);
154  }
155
156
157  MatrixLookup::const_column_iterator MatrixLookup::begin_column(size_t i) const
158  {
159    return const_column_iterator(const_column_iterator::iterator_type(*this, 0,
160                                                                      i),
161                                 columns());
162  }
163
164
165  MatrixLookup::const_row_iterator MatrixLookup::begin_row(size_t i) const
166  {
167    return const_row_iterator(const_row_iterator::iterator_type(*this,i,0), 1);
168  }
169
170
171  size_t MatrixLookup::columns(void) const
172  {
173    return column_index_.size();
174  }
175
176
177  MatrixLookup::const_iterator MatrixLookup::end(void) const
178  {
179    return const_iterator(const_iterator::iterator_type(*this, rows(), 0), 1);
180  }
181
182
183  MatrixLookup::const_column_iterator MatrixLookup::end_column(size_t i) const
184  {
185    return 
186      const_column_iterator(const_column_iterator::iterator_type(*this,rows(),
187                                                                      i), 
188                            columns());
189  }
190
191
192  MatrixLookup::const_row_iterator MatrixLookup::end_row(size_t i) const
193  {
194    return const_row_iterator(const_row_iterator::iterator_type(*this,i+1,0),1);
195  }
196
197
198  size_t MatrixLookup::rows(void) const
199  {
200    return row_index_.size();
201  }
202
203
204  bool MatrixLookup::validate(void) const
205  {
206    for (size_t i=0; i<row_index_.size(); ++i)
207      if (row_index_[i]>=data_->rows())
208        return false;
209    for (size_t i=0; i<column_index_.size(); ++i)
210      if (column_index_[i]>=data_->columns())
211        return false;
212    return true;
213  }
214
215
216  bool MatrixLookup::weighted(void) const 
217  {
218    return false;
219  }
220
221
222
223  double MatrixLookup::operator()(const size_t row, const size_t column) const
224  {
225    assert(row<rows());
226    assert(column<columns());
227    assert(row_index_[row]<data_->rows());
228    assert(column_index_[column]<data_->columns());
229    return (*data_)(row_index_[row], column_index_[column]);
230  }
231
232
233
234  const MatrixLookup& MatrixLookup::operator=(const MatrixLookup& other)
235  {
236    if (this!=&other){
237      row_index_ = other.row_index_;
238      column_index_ = other.column_index_;
239      data_ = other.data_;
240    }
241    assert(validate());
242    return *this;
243  }
244
245
246  std::ostream& operator<<(std::ostream& s, const MatrixLookup& m)
247  {
248    s.setf(std::ios::dec);
249    s.precision(12);
250    for(size_t i=0, j=0; i<m.rows(); i++)
251      for (j=0; j<m.columns(); j++) {
252        s << m(i,j);
253        if (j<m.columns()-1)
254          s << s.fill();
255        else if (i<m.rows()-1)
256          s << "\n";
257      }
258    return s;
259  }
260
261
262
263}}} // of namespace classifier, yat, and theplu
Note: See TracBrowser for help on using the repository browser.