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

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

refs #396
stupid implementation of constructors - copying should be avoided when
internal representation in MatrixLookupWeighted? has changed

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date ID
File size: 9.5 KB
Line 
1// $Id$
2
3/*
4  Copyright (C) 2006 Jari Häkkinen, Peter Johansson, Markus Ringnér
5  Copyright (C) 2007 Jari Häkkinen, Peter Johansson
6  Copyright (C) 2008 Peter Johansson
7
8  This file is part of the yat library, http://dev.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 "MatrixLookupWeighted.h"
27#include "MatrixLookup.h"
28#include "yat/utility/DataIterator.h"
29#include "yat/utility/Matrix.h"
30#include "yat/utility/MatrixWeighted.h"
31#include "yat/utility/WeightIterator.h"
32
33#include <algorithm>
34#include <cassert>
35#include <fstream>
36#include <vector>
37
38namespace theplu {
39namespace yat {
40namespace classifier {
41
42  MatrixLookupWeighted::MatrixLookupWeighted(const utility::MatrixWeighted& m,
43                                             const utility::Index& rows,
44                                             const utility::Index& columns)
45    : column_index_(columns), row_index_(rows)
46  {
47    utility::Matrix* data = new utility::Matrix(m.rows(), m.columns());
48    utility::Matrix* weight = new utility::Matrix(m.rows(), m.columns());
49    for (size_t i=0; i<m.rows(); ++i)
50      for (size_t j=0; j<m.columns(); ++j) {
51        (*data)(i,j) = m(i,j).data();
52        (*weight)(i,j) = m(i,j).weight();
53      }
54    // smart pointers are taking ownership
55    data_ = MatrixP(data);
56    weights_ = MatrixP(weight);
57  }
58
59
60  MatrixLookupWeighted::MatrixLookupWeighted(const utility::MatrixWeighted& m)
61    : column_index_(utility::Index(m.columns())), 
62      row_index_(utility::Index(m.rows()))
63  {
64    utility::Matrix* data = new utility::Matrix(m.rows(), m.columns());
65    utility::Matrix* weight = new utility::Matrix(m.rows(), m.columns());
66    for (size_t i=0; i<m.rows(); ++i)
67      for (size_t j=0; j<m.columns(); ++j) {
68        (*data)(i,j) = m(i,j).data();
69        (*weight)(i,j) = m(i,j).weight();
70      } 
71  // smart pointers are taking ownership
72    data_ = MatrixP(data);
73    weights_ = MatrixP(weight);
74  }
75
76
77  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data, 
78                                             const utility::Matrix& weights,
79                                             const bool own)
80    : data_(MatrixP(&data, own)), weights_(MatrixP(&weights, own)) 
81  {
82    assert(data.rows()==weights.rows());
83    assert(data.columns()==weights.columns());
84    row_index_ = utility::Index(data.rows());
85    column_index_ = utility::Index(data.columns());
86    assert(validate());
87  }
88
89
90  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data)
91    : data_(MatrixP(&data, false))
92  {
93    utility::Matrix weights;
94    utility::nan(*data_,weights);
95    weights_= MatrixP(new utility::Matrix(weights));
96    row_index_ = utility::Index(data.rows());
97    column_index_ = utility::Index(data.columns());
98    assert(validate());
99  }
100
101
102  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& ml)
103    : column_index_(ml.column_index_), data_(ml.data_),
104      row_index_(ml.row_index_), 
105      weights_(MatrixP(new utility::Matrix(data_->rows(),data_->columns(),1.0)))
106  { 
107    assert(validate());
108  }
109 
110
111  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data, 
112                                             const utility::Matrix& weights, 
113                                             const utility::Index& row, 
114                                             const utility::Index& col)
115    : column_index_(col), data_(MatrixP(new utility::Matrix(data), false)), 
116      row_index_(row), weights_(MatrixP(new utility::Matrix(weights), false))
117  {
118    assert(validate());
119  }
120 
121
122
123  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data, 
124                                             const utility::Matrix& weights, 
125                                             const utility::Index& index, 
126                                             const bool row)
127    : data_(MatrixP(new utility::Matrix(data), false)), 
128      weights_(MatrixP(new utility::Matrix(weights), false))
129  {
130    assert(data.rows()==weights.rows());
131    assert(data.columns()==weights.columns());
132    if (row){
133      row_index_=index;
134      column_index_ = utility::Index(data.columns());
135    }
136    else{
137      column_index_=index;
138      row_index_ = utility::Index(data.rows());
139    }
140    assert(validate());
141  }
142 
143
144  /*
145  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& dv,
146                                             const MatrixLookup& wv)
147    : DataLookup2D(dv), data_(dv.data_), weights_(dv.data_)
148  {
149  }
150  */
151
152
153  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other)
154    : column_index_(other.column_index_), data_(other.data_), 
155      row_index_(other.row_index_), weights_(other.weights_)
156  {
157    assert(validate());
158  }
159
160
161
162  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other,
163                                             const utility::Index& row, 
164                                             const utility::Index& col)
165    : column_index_(utility::Index(other.column_index_, col)), 
166      data_(other.data_), row_index_(utility::Index(other.row_index_, row)), 
167      weights_(other.weights_)
168  {
169    assert(validate());
170  }
171 
172
173
174  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other, 
175                                             const utility::Index& index, 
176                                             bool row)
177    : data_(other.data_), 
178      weights_(other.weights_)
179  {
180    if (row){
181      row_index_ = utility::Index(other.row_index_, index);
182      column_index_= other.column_index_;
183    }
184    else{
185      column_index_ = utility::Index(other.column_index_, index);
186      row_index_= other.row_index_;
187    }
188    assert(validate());
189  }
190 
191
192
193  MatrixLookupWeighted::MatrixLookupWeighted(const size_t rows, 
194                                             const size_t columns, 
195                                             const double value,
196                                             const double weight)
197    : column_index_(utility::Index(std::vector<size_t>(rows, 0))),
198      data_(MatrixP(new utility::Matrix(1,1,value))),
199      row_index_(utility::Index(std::vector<size_t>(columns, 0))), 
200      weights_(MatrixP(new utility::Matrix(1,1,weight)))
201  {
202    assert(validate());
203  }
204
205 
206  MatrixLookupWeighted::MatrixLookupWeighted(std::istream& is, char sep)
207    : data_(MatrixP(new utility::Matrix(is,sep)))
208  {
209    column_index_ = utility::Index(data_->columns());
210    row_index_ = utility::Index(data_->rows());
211    utility::Matrix weights;
212    utility::nan(*data_,weights);
213    // Peter, should be possible to avoid this copying
214    weights_= MatrixP(new utility::Matrix(weights));
215    assert(validate());
216  }
217 
218
219  MatrixLookupWeighted::~MatrixLookupWeighted(void)
220  {
221  }
222
223
224
225  MatrixLookupWeighted::const_iterator MatrixLookupWeighted::begin(void) const
226  {
227    return const_iterator(const_iterator::iterator_type(*this, 0, 0), 1);
228  }
229
230
231  MatrixLookupWeighted::const_column_iterator
232  MatrixLookupWeighted::begin_column(size_t i) const
233  {
234    return const_column_iterator(const_column_iterator::iterator_type(*this,0, 
235                                                                      i),
236                                 columns());
237  }
238
239
240  MatrixLookupWeighted::const_iterator
241  MatrixLookupWeighted::begin_row(size_t i) const
242  {
243    return const_row_iterator(const_row_iterator::iterator_type(*this,i, 0), 1);
244  }
245
246
247  size_t MatrixLookupWeighted::columns(void) const
248  {
249    return column_index_.size();
250  }
251
252
253  double MatrixLookupWeighted::data(size_t row, size_t column) const
254  {
255    assert(row<rows());
256    assert(column<columns());
257    assert(row_index_[row]<data_->rows());
258    assert(column_index_[column]<data_->columns());
259    return (*data_)(row_index_[row], column_index_[column]);
260  }
261
262
263
264  MatrixLookupWeighted::const_iterator MatrixLookupWeighted::end(void) const
265  {
266    return const_iterator(const_iterator::iterator_type(*this, rows(), 0), 1);
267  }
268
269
270  MatrixLookupWeighted::const_iterator
271  MatrixLookupWeighted::end_column(size_t i) const
272  {
273    return const_column_iterator(const_column_iterator::iterator_type(*this, 
274                                                                      rows(),i),
275                                 columns());
276  }
277
278
279  MatrixLookupWeighted::const_row_iterator
280  MatrixLookupWeighted::end_row(size_t i) const
281  {
282    return const_row_iterator(const_row_iterator::iterator_type(*this,i+1,0),1);
283  }
284
285
286  size_t MatrixLookupWeighted::rows(void) const
287  {
288    return row_index_.size();
289  }
290
291
292  bool MatrixLookupWeighted::validate(void) const
293  {
294    for (size_t i=0; i<row_index_.size(); ++i)
295      if (row_index_[i]>=data_->rows())
296        return false;
297    for (size_t i=0; i<column_index_.size(); ++i)
298      if (column_index_[i]>=data_->columns())
299        return false;
300    for (size_t i=0; i<row_index_.size(); ++i)
301      if (row_index_[i]>=weights_->rows())
302        return false;
303    for (size_t i=0; i<column_index_.size(); ++i)
304      if (column_index_[i]>=weights_->columns())
305        return false;
306    return true;
307  }
308
309
310  double MatrixLookupWeighted::weight(size_t row, size_t column) const
311  {
312    assert(row<rows());
313    assert(column<columns());
314    assert(row_index_[row]<weights_->rows());
315    assert(column_index_[column]<weights_->columns());
316    return (*weights_)(row_index_[row], column_index_[column]);
317  }
318
319
320
321  bool MatrixLookupWeighted::weighted(void) const 
322  {
323    return true;
324  }
325
326
327
328  std::pair<double, double> 
329  MatrixLookupWeighted::operator()(const size_t row, const size_t column) const
330  { 
331    return std::make_pair(data(row, column), weight(row,column));
332  }
333
334
335
336  const MatrixLookupWeighted& MatrixLookupWeighted::operator=
337  (const MatrixLookupWeighted& other)
338  {
339    if (this!=&other){
340      column_index_=other.column_index_;
341      row_index_=other.row_index_;
342      data_ = other.data_;
343      weights_ = other.weights_;
344    }
345    assert(validate());
346    return *this;
347  }
348
349
350}}} // of namespace classifier, yat, and theplu
Note: See TracBrowser for help on using the repository browser.