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

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

using Index class instead of std::vector<size_t>

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