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

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

Fixes #170. Almost all inlines removed, some classes have no cc file.

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