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

Last change on this file since 826 was 826, checked in by Peter, 15 years ago

documentation and some minor fixes Fixes #135

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