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

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

changing name to ROCScore and also added some cassert includes

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