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

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

changing operator() in weighted lookups and removing operator[] in 1D lookups

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