source: trunk/yat/classifier/MatrixLookup.cc

Last change on this file was 2919, checked in by Peter, 9 years ago

update copyright years

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date ID
File size: 6.2 KB
Line 
1// $Id$
2
3/*
4  Copyright (C) 2005 Peter Johansson, Markus Ringnér
5  Copyright (C) 2006 Jari Häkkinen, Peter Johansson, Markus Ringnér
6  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
7  Copyright (C) 2009, 2012 Peter Johansson
8
9  This file is part of the yat library, http://dev.thep.lu.se/yat
10
11  The yat library is free software; you can redistribute it and/or
12  modify it under the terms of the GNU General Public License as
13  published by the Free Software Foundation; either version 3 of the
14  License, or (at your option) any later version.
15
16  The yat library is distributed in the hope that it will be useful,
17  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  General Public License for more details.
20
21  You should have received a copy of the GNU General Public License
22  along with yat. If not, see <http://www.gnu.org/licenses/>.
23*/
24
25#include <config.h>
26
27#include "MatrixLookup.h"
28#include "yat/utility/Deleter.h"
29#include "yat/utility/Matrix.h"
30
31#include <algorithm>
32#include <cassert>
33#include <fstream>
34#include <limits>
35#include <vector>
36
37namespace theplu {
38namespace yat {
39namespace classifier {
40
41  MatrixLookup::MatrixLookup(const utility::Matrix& data, const bool own)
42    : data_(&data, utility::Deleter(own))
43  {
44    column_index_ = utility::Index(data.columns());
45    row_index_ = utility::Index(data.rows());
46    assert(rows()==data.rows());
47    assert(columns()==data.columns());
48    assert(validate());
49  }
50
51
52
53  MatrixLookup::MatrixLookup(const utility::Matrix& data,
54                             const utility::Index& row,
55                             const utility::Index& col)
56    : column_index_(col),
57      data_(&data, utility::Deleter(false)),
58      row_index_(row)
59
60  {
61    assert(rows()==row.size());
62    assert(columns()==col.size());
63    assert(validate());
64  }
65
66
67
68  MatrixLookup::MatrixLookup(const utility::Matrix& data,
69                             const utility::Index& index,
70                             const bool row)
71    : data_(&data, utility::Deleter(false))
72  {
73    if (row){
74      row_index_=index;
75      column_index_ = utility::Index(data.columns());
76    }
77    else{
78      column_index_=index;
79      row_index_ = utility::Index(data.rows());
80    }
81    assert(row || rows()==data.rows());
82    assert(row || columns()==index.size());
83    assert(!row || rows()==index.size());
84    assert(!row || columns()==data.columns());
85    assert(validate());
86  }
87
88
89
90  MatrixLookup::MatrixLookup(const MatrixLookup& other)
91    : column_index_(other.column_index_),
92      data_(other.data_),
93      row_index_(other.row_index_)
94  {
95    assert(validate());
96  }
97
98
99
100  MatrixLookup::MatrixLookup(const MatrixLookup& other,
101                             const utility::Index& row,
102                             const utility::Index& col)
103    : column_index_(utility::Index(other.column_index_, col)),
104      data_(other.data_), row_index_(utility::Index(other.row_index_, row))
105  {
106    assert(rows()==row.size());
107    assert(columns()==col.size());
108    assert(validate());
109  }
110
111
112
113  MatrixLookup::MatrixLookup(const MatrixLookup& other,
114                             const utility::Index& index, bool row)
115    : data_(other.data_)
116  {
117    assert(other.validate());
118    if (row){
119      row_index_ = utility::Index(other.row_index_, index);
120      column_index_= other.column_index_;
121    }
122    else{
123      column_index_ = utility::Index(other.column_index_, index);
124      row_index_= other.row_index_;
125    }
126    assert(validate());
127  }
128
129
130  MatrixLookup::MatrixLookup(const size_t rows, const size_t columns,
131                             const double value)
132    : data_(MatrixP(new utility::Matrix(1,1,value)))
133  {
134    column_index_ = utility::Index(std::vector<size_t>(columns, 0));
135    row_index_ = utility::Index(std::vector<size_t>(rows,0));
136    assert(validate());
137  }
138
139
140  MatrixLookup::MatrixLookup(std::istream& is, char sep)
141    : data_(MatrixP(new utility::Matrix(is,sep)))
142  {
143    column_index_ = utility::Index(data_->columns());
144    row_index_ = utility::Index(data_->rows());
145    assert(validate());
146  }
147
148
149  MatrixLookup::~MatrixLookup(void)
150  {
151  }
152
153
154  MatrixLookup::const_iterator MatrixLookup::begin(void) const
155  {
156    return const_iterator(*this, 0, 0);
157  }
158
159
160  MatrixLookup::const_column_iterator MatrixLookup::begin_column(size_t i) const
161  {
162    return const_column_iterator(data_->begin_column(column_index_[i]),
163                                 row_index_.begin());
164  }
165
166
167  MatrixLookup::const_row_iterator MatrixLookup::begin_row(size_t i) const
168  {
169    return const_row_iterator(data_->begin_row(row_index_[i]),
170                              column_index_.begin());
171  }
172
173
174  size_t MatrixLookup::columns(void) const
175  {
176    return column_index_.size();
177  }
178
179
180  MatrixLookup::const_iterator MatrixLookup::end(void) const
181  {
182    return const_iterator(*this, rows(), 0);
183  }
184
185
186  MatrixLookup::const_column_iterator MatrixLookup::end_column(size_t i) const
187  {
188    return const_column_iterator(data_->end_column(column_index_[i]),
189                                 row_index_.end());
190  }
191
192
193  MatrixLookup::const_row_iterator MatrixLookup::end_row(size_t i) const
194  {
195    return const_row_iterator(data_->end_row(row_index_[i]),
196                                 column_index_.end());
197  }
198
199
200  size_t MatrixLookup::rows(void) const
201  {
202    return row_index_.size();
203  }
204
205
206  bool MatrixLookup::validate(void) const
207  {
208    for (size_t i=0; i<row_index_.size(); ++i)
209      if (row_index_[i]>=data_->rows())
210        return false;
211    for (size_t i=0; i<column_index_.size(); ++i)
212      if (column_index_[i]>=data_->columns())
213        return false;
214    return true;
215  }
216
217
218  bool MatrixLookup::weighted(void) const
219  {
220    return false;
221  }
222
223
224
225  MatrixLookup::const_reference
226  MatrixLookup::operator()(size_t row, size_t column) const
227  {
228    assert(row<rows());
229    assert(column<columns());
230    assert(row_index_[row]<data_->rows());
231    assert(column_index_[column]<data_->columns());
232    return (*data_)(row_index_[row], column_index_[column]);
233  }
234
235
236
237  const MatrixLookup& MatrixLookup::operator=(const MatrixLookup& other)
238  {
239    if (this!=&other){
240      row_index_ = other.row_index_;
241      column_index_ = other.column_index_;
242      data_ = other.data_;
243    }
244    assert(validate());
245    return *this;
246  }
247
248
249  std::ostream& operator<<(std::ostream& s, const MatrixLookup& m)
250  {
251    s.setf(std::ios::dec);
252    std::streamsize precision = s.precision();
253    s.precision(std::numeric_limits<double>().digits10);
254    for(size_t i=0, j=0; i<m.rows(); i++)
255      for (j=0; j<m.columns(); j++) {
256        s << m(i,j);
257        if (j<m.columns()-1)
258          s << s.fill();
259        else if (i<m.rows()-1)
260          s << "\n";
261      }
262    s.precision(precision);
263    return s;
264  }
265
266
267
268}}} // of namespace classifier, yat, and theplu
Note: See TracBrowser for help on using the repository browser.