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

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

refs #396 - removing a constructor in MatrixLookupWeighted? - needed to re-organize tests in ncc_test to track down an error

  • 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  /*
91  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data)
92    : data_(MatrixP(&data, false))
93  {
94    utility::Matrix weights;
95    utility::nan(*data_,weights);
96    weights_= MatrixP(new utility::Matrix(weights));
97    row_index_ = utility::Index(data.rows());
98    column_index_ = utility::Index(data.columns());
99    assert(validate());
100  }
101  */
102
103
104  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& ml)
105    : column_index_(ml.column_index_), data_(ml.data_),
106      row_index_(ml.row_index_), 
107      weights_(MatrixP(new utility::Matrix(data_->rows(),data_->columns(),1.0)))
108  { 
109    assert(validate());
110  }
111 
112
113  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data, 
114                                             const utility::Matrix& weights, 
115                                             const utility::Index& row, 
116                                             const utility::Index& col)
117    : column_index_(col), data_(MatrixP(new utility::Matrix(data), false)), 
118      row_index_(row), weights_(MatrixP(new utility::Matrix(weights), false))
119  {
120    assert(validate());
121  }
122 
123
124
125  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data, 
126                                             const utility::Matrix& weights, 
127                                             const utility::Index& index, 
128                                             const bool row)
129    : data_(MatrixP(new utility::Matrix(data), false)), 
130      weights_(MatrixP(new utility::Matrix(weights), false))
131  {
132    assert(data.rows()==weights.rows());
133    assert(data.columns()==weights.columns());
134    if (row){
135      row_index_=index;
136      column_index_ = utility::Index(data.columns());
137    }
138    else{
139      column_index_=index;
140      row_index_ = utility::Index(data.rows());
141    }
142    assert(validate());
143  }
144 
145
146  /*
147  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& dv,
148                                             const MatrixLookup& wv)
149    : DataLookup2D(dv), data_(dv.data_), weights_(dv.data_)
150  {
151  }
152  */
153
154
155  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other)
156    : column_index_(other.column_index_), data_(other.data_), 
157      row_index_(other.row_index_), weights_(other.weights_)
158  {
159    assert(validate());
160  }
161
162
163
164  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other,
165                                             const utility::Index& row, 
166                                             const utility::Index& col)
167    : column_index_(utility::Index(other.column_index_, col)), 
168      data_(other.data_), row_index_(utility::Index(other.row_index_, row)), 
169      weights_(other.weights_)
170  {
171    assert(validate());
172  }
173 
174
175
176  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other, 
177                                             const utility::Index& index, 
178                                             bool row)
179    : data_(other.data_), 
180      weights_(other.weights_)
181  {
182    if (row){
183      row_index_ = utility::Index(other.row_index_, index);
184      column_index_= other.column_index_;
185    }
186    else{
187      column_index_ = utility::Index(other.column_index_, index);
188      row_index_= other.row_index_;
189    }
190    assert(validate());
191  }
192 
193
194
195  MatrixLookupWeighted::MatrixLookupWeighted(const size_t rows, 
196                                             const size_t columns, 
197                                             const double value,
198                                             const double weight)
199    : column_index_(utility::Index(std::vector<size_t>(rows, 0))),
200      data_(MatrixP(new utility::Matrix(1,1,value))),
201      row_index_(utility::Index(std::vector<size_t>(columns, 0))), 
202      weights_(MatrixP(new utility::Matrix(1,1,weight)))
203  {
204    assert(validate());
205  }
206
207 
208  MatrixLookupWeighted::MatrixLookupWeighted(std::istream& is, char sep)
209    : data_(MatrixP(new utility::Matrix(is,sep)))
210  {
211    column_index_ = utility::Index(data_->columns());
212    row_index_ = utility::Index(data_->rows());
213    utility::Matrix weights;
214    utility::nan(*data_,weights);
215    // Peter, should be possible to avoid this copying
216    weights_= MatrixP(new utility::Matrix(weights));
217    assert(validate());
218  }
219 
220
221  MatrixLookupWeighted::~MatrixLookupWeighted(void)
222  {
223  }
224
225
226
227  MatrixLookupWeighted::const_iterator MatrixLookupWeighted::begin(void) const
228  {
229    return const_iterator(const_iterator::iterator_type(*this, 0, 0), 1);
230  }
231
232
233  MatrixLookupWeighted::const_column_iterator
234  MatrixLookupWeighted::begin_column(size_t i) const
235  {
236    return const_column_iterator(const_column_iterator::iterator_type(*this,0, 
237                                                                      i),
238                                 columns());
239  }
240
241
242  MatrixLookupWeighted::const_iterator
243  MatrixLookupWeighted::begin_row(size_t i) const
244  {
245    return const_row_iterator(const_row_iterator::iterator_type(*this,i, 0), 1);
246  }
247
248
249  size_t MatrixLookupWeighted::columns(void) const
250  {
251    return column_index_.size();
252  }
253
254
255  double MatrixLookupWeighted::data(size_t row, size_t column) const
256  {
257    assert(row<rows());
258    assert(column<columns());
259    assert(row_index_[row]<data_->rows());
260    assert(column_index_[column]<data_->columns());
261    return (*data_)(row_index_[row], column_index_[column]);
262  }
263
264
265
266  MatrixLookupWeighted::const_iterator MatrixLookupWeighted::end(void) const
267  {
268    return const_iterator(const_iterator::iterator_type(*this, rows(), 0), 1);
269  }
270
271
272  MatrixLookupWeighted::const_iterator
273  MatrixLookupWeighted::end_column(size_t i) const
274  {
275    return const_column_iterator(const_column_iterator::iterator_type(*this, 
276                                                                      rows(),i),
277                                 columns());
278  }
279
280
281  MatrixLookupWeighted::const_row_iterator
282  MatrixLookupWeighted::end_row(size_t i) const
283  {
284    return const_row_iterator(const_row_iterator::iterator_type(*this,i+1,0),1);
285  }
286
287
288  size_t MatrixLookupWeighted::rows(void) const
289  {
290    return row_index_.size();
291  }
292
293
294  bool MatrixLookupWeighted::validate(void) const
295  {
296    for (size_t i=0; i<row_index_.size(); ++i)
297      if (row_index_[i]>=data_->rows())
298        return false;
299    for (size_t i=0; i<column_index_.size(); ++i)
300      if (column_index_[i]>=data_->columns())
301        return false;
302    for (size_t i=0; i<row_index_.size(); ++i)
303      if (row_index_[i]>=weights_->rows())
304        return false;
305    for (size_t i=0; i<column_index_.size(); ++i)
306      if (column_index_[i]>=weights_->columns())
307        return false;
308    return true;
309  }
310
311
312  double MatrixLookupWeighted::weight(size_t row, size_t column) const
313  {
314    assert(row<rows());
315    assert(column<columns());
316    assert(row_index_[row]<weights_->rows());
317    assert(column_index_[column]<weights_->columns());
318    return (*weights_)(row_index_[row], column_index_[column]);
319  }
320
321
322
323  bool MatrixLookupWeighted::weighted(void) const 
324  {
325    return true;
326  }
327
328
329
330  std::pair<double, double> 
331  MatrixLookupWeighted::operator()(const size_t row, const size_t column) const
332  { 
333    return std::make_pair(data(row, column), weight(row,column));
334  }
335
336
337
338  const MatrixLookupWeighted& MatrixLookupWeighted::operator=
339  (const MatrixLookupWeighted& other)
340  {
341    if (this!=&other){
342      column_index_=other.column_index_;
343      row_index_=other.row_index_;
344      data_ = other.data_;
345      weights_ = other.weights_;
346    }
347    assert(validate());
348    return *this;
349  }
350
351
352}}} // of namespace classifier, yat, and theplu
Note: See TracBrowser for help on using the repository browser.