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

Last change on this file since 1000 was 1000, checked in by Jari Häkkinen, 14 years ago

trac moved to new location.

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