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

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

using DataWeight? rather than std::pair<double, double>

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