source: trunk/yat/classifier/MatrixLookup.cc @ 1134

Last change on this file since 1134 was 1134, checked in by Peter, 13 years ago

using Index class instead of std::vector<size_t>

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