source: trunk/yat/classifier/MatrixLookup.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: 5.5 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 "MatrixLookup.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  MatrixLookup::MatrixLookup(const utility::matrix& data, const bool own)
39    : DataLookup2D(own), data_(&data)
40  {
41    for(size_t i=0;i<(*data_).rows();i++)
42      row_index_.push_back(i);
43    for(size_t i=0;i<(*data_).columns();i++)
44      column_index_.push_back(i);
45  }
46 
47
48
49  MatrixLookup::MatrixLookup(const utility::matrix& data, 
50                             const std::vector<size_t>& row, 
51                             const std::vector<size_t>& col)
52    : DataLookup2D(row,col), data_(&data)
53  {
54    // Checking that each row index is less than data.rows()
55    assert(row.empty() || 
56           *(std::max_element(row.begin(),row.end()))<data.rows());
57    // Checking that each column index is less than data.column()
58    assert(col.empty() || 
59           *(std::max_element(col.begin(),col.end()))<data.columns());
60  }
61 
62
63
64  MatrixLookup::MatrixLookup(const utility::matrix& data, 
65                             const std::vector<size_t>& index, 
66                             const bool row)
67    : DataLookup2D(), data_(&data)
68  {
69    if (row){
70      // Checking that each row index is less than data.rows()
71      assert(index.empty() || 
72             *(std::max_element(index.begin(),index.end()))<data.rows());
73      row_index_=index;
74      assert(column_index_.empty());
75      column_index_.reserve(data.columns());
76      for (size_t i=0; i<data.columns(); i++)
77        column_index_.push_back(i);
78    }
79    else{
80      // Checking that each column index is less than data.column()
81      assert(index.empty() || 
82             *(std::max_element(index.begin(),index.end()))<data.columns());
83      column_index_=index;
84      assert(row_index_.empty());
85      column_index_.reserve(data.rows());
86      for (size_t i=0; i<data.rows(); i++)
87        row_index_.push_back(i);
88    }
89  }
90 
91
92
93  MatrixLookup::MatrixLookup(const MatrixLookup& other)
94    : DataLookup2D(other), data_(other.data_)
95  {
96    ref_count_=other.ref_count_;
97    if (ref_count_)
98      ++(*ref_count_);
99  }
100
101
102
103  MatrixLookup::MatrixLookup(const MatrixLookup& other, 
104                             const std::vector<size_t>& row, 
105                             const std::vector<size_t>& col)
106    : DataLookup2D(other,row,col), data_(other.data_)
107  {
108    ref_count_=other.ref_count_;
109    if (ref_count_)
110      ++(*ref_count_);
111  }
112 
113
114
115  MatrixLookup::MatrixLookup(const MatrixLookup& other, 
116                             const std::vector<size_t>& index, bool row)
117    : DataLookup2D(other,index,row), data_(other.data_)
118  {
119    ref_count_=other.ref_count_;
120    if (ref_count_)
121      ++(*ref_count_);
122
123    // Checking that no index is out of range
124    assert(row_index_.empty() || 
125           *(max_element(row_index_.begin(), row_index_.end()))<data_->rows());
126    assert(column_index_.empty() || 
127           *(max_element(column_index_.begin(), column_index_.end()))<
128           data_->columns());
129  }
130 
131
132
133  MatrixLookup::MatrixLookup(const size_t rows, const size_t columns, 
134                             const double value)
135    : DataLookup2D(rows,columns) 
136  {
137    data_ = new utility::matrix(1,1,value);
138    ref_count_= new u_int(1);
139  }
140
141
142  MatrixLookup::MatrixLookup(std::istream& is, char sep)
143    : DataLookup2D()
144  {
145    data_ = new utility::matrix(is,sep);
146    ref_count_= new u_int(1);
147    for(size_t i=0;i<(*data_).rows();i++)
148      row_index_.push_back(i);
149    for(size_t i=0;i<(*data_).columns();i++)
150      column_index_.push_back(i);
151  }
152
153
154  MatrixLookup::~MatrixLookup(void)
155  {
156    if (ref_count_)
157      if (!--(*ref_count_))
158        delete data_;
159  }
160
161
162  const MatrixLookup* 
163  MatrixLookup::selected(const std::vector<size_t>& i) const
164  { 
165    return new MatrixLookup(*this,i, true); 
166  }
167
168
169
170  const MatrixLookup* 
171  MatrixLookup::training_data(const std::vector<size_t>& i) const
172  { 
173    return new MatrixLookup(*this,i, false); 
174  }
175
176
177
178  const MatrixLookup* 
179  MatrixLookup::validation_data(const std::vector<size_t>& train,
180                                const std::vector<size_t>& val) const
181  { 
182    return new MatrixLookup(*this,val, false); 
183  }
184
185
186
187  bool MatrixLookup::weighted(void) const 
188  {
189    return false;
190  }
191
192
193
194  double MatrixLookup::operator()(const size_t row, const size_t column) const
195  {
196    assert(row<rows());
197    assert(column<columns());
198    return (*data_)(row_index_[row], column_index_[column]);
199  }
200
201
202
203  const MatrixLookup& MatrixLookup::operator=(const MatrixLookup& other)
204  {
205    if (this!=&other){
206      if (ref_count_ && !--(*ref_count_))
207        delete data_;
208      DataLookup2D::operator=(other);
209      data_ = other.data_;
210      ref_count_=other.ref_count_;
211      if (ref_count_)
212        ++(*ref_count_);
213    }
214    return *this;
215  }
216
217
218  std::ostream& operator<<(std::ostream& s, const MatrixLookup& m)
219  {
220    s.setf(std::ios::dec);
221    s.precision(12);
222    for(size_t i=0, j=0; i<m.rows(); i++)
223      for (j=0; j<m.columns(); j++) {
224        s << m(i,j);
225        if (j<m.columns()-1)
226          s << s.fill();
227        else if (i<m.rows()-1)
228          s << "\n";
229      }
230    return s;
231  }
232
233
234
235}}} // of namespace classifier, yat, and theplu
Note: See TracBrowser for help on using the repository browser.