← Back to branch summary

~ubuntu-branches/ubuntu/raring/mdds/raring

« back to all changes in this revision

Viewing changes to include/mdds/mixed_type_matrix_def.inl

  • Committer: Bazaar Package Importer
  • Author(s): Rene Engelhard
  • Date: 2010-12-21 03:00:49 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20101221030049-15awcps1vyzo90s0
Tags: 0.4.0-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/mdds/mixed_type_matrix_def.inl
 
1
/*************************************************************************
 
2
 *
 
3
 * Copyright (c) 2010 Kohei Yoshida
 
4
 * 
 
5
 * Permission is hereby granted, free of charge, to any person
 
6
 * obtaining a copy of this software and associated documentation
 
7
 * files (the "Software"), to deal in the Software without
 
8
 * restriction, including without limitation the rights to use,
 
9
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 
10
 * copies of the Software, and to permit persons to whom the
 
11
 * Software is furnished to do so, subject to the following
 
12
 * conditions:
 
13
 * 
 
14
 * The above copyright notice and this permission notice shall be
 
15
 * included in all copies or substantial portions of the Software.
 
16
 * 
 
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
18
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 
19
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
20
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 
21
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 
22
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
23
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 
24
 * OTHER DEALINGS IN THE SOFTWARE.
 
25
 *
 
26
 ************************************************************************/
 
27
 
 
28
namespace mdds {
 
29
 
 
30
template<typename _String, typename _Flag>
 
31
typename mixed_type_matrix<_String,_Flag>::storage_base*
 
32
mixed_type_matrix<_String,_Flag>::create_storage(size_t rows, size_t cols, matrix_density_t density)
 
33
{
 
34
    switch (density)
 
35
    {
 
36
        case matrix_density_filled_zero:
 
37
            return new filled_storage_type(rows, cols, matrix_init_element_zero);
 
38
        case matrix_density_filled_empty:
 
39
            return new filled_storage_type(rows, cols, matrix_init_element_empty);
 
40
        case matrix_density_sparse_zero:
 
41
            return new sparse_storage_type(rows, cols, matrix_init_element_zero);
 
42
        case matrix_density_sparse_empty:
 
43
            return new sparse_storage_type(rows, cols, matrix_init_element_empty);
 
44
        default:
 
45
            throw matrix_error("unknown density type");
 
46
    }
 
47
    return NULL;
 
48
}
 
49
 
 
50
template<typename _String, typename _Flag>
 
51
mixed_type_matrix<_String,_Flag>::mixed_type_matrix() :
 
52
    mp_storage(NULL)
 
53
{
 
54
    mp_storage = create_storage(0, 0, matrix_density_filled_zero);
 
55
}
 
56
 
 
57
template<typename _String, typename _Flag>
 
58
mixed_type_matrix<_String,_Flag>::mixed_type_matrix(matrix_density_t density) :
 
59
    mp_storage(NULL)
 
60
{
 
61
    mp_storage = create_storage(0, 0, density);
 
62
}
 
63
 
 
64
template<typename _String, typename _Flag>
 
65
mixed_type_matrix<_String,_Flag>::mixed_type_matrix(size_t rows, size_t cols, matrix_density_t density) :
 
66
    mp_storage(NULL)
 
67
{
 
68
    mp_storage = create_storage(rows, cols, density);
 
69
}
 
70
 
 
71
template<typename _String, typename _Flag>
 
72
mixed_type_matrix<_String,_Flag>::mixed_type_matrix(const mixed_type_matrix& r) :
 
73
    mp_storage(r.mp_storage->clone())
 
74
{
 
75
}
 
76
 
 
77
template<typename _String, typename _Flag>
 
78
mixed_type_matrix<_String,_Flag>::~mixed_type_matrix()
 
79
{
 
80
    delete mp_storage;
 
81
}
 
82
 
 
83
template<typename _String, typename _Flag>
 
84
typename mixed_type_matrix<_String,_Flag>::const_iterator
 
85
mixed_type_matrix<_String,_Flag>::begin() const
 
86
{
 
87
    return mp_storage->begin();
 
88
}
 
89
 
 
90
template<typename _String, typename _Flag>
 
91
typename mixed_type_matrix<_String,_Flag>::const_iterator
 
92
mixed_type_matrix<_String,_Flag>::end() const
 
93
{
 
94
    return mp_storage->end();
 
95
}
 
96
 
 
97
template<typename _String, typename _Flag>
 
98
mixed_type_matrix<_String,_Flag>&
 
99
mixed_type_matrix<_String,_Flag>::operator= (const mixed_type_matrix& r)
 
100
{
 
101
    if (this == &r)
 
102
        // self assignment.
 
103
        return *this;
 
104
 
 
105
    delete mp_storage;
 
106
    mp_storage = r.mp_storage->clone();
 
107
    return *this;
 
108
}
 
109
 
 
110
template<typename _String, typename _Flag>
 
111
matrix_element_t mixed_type_matrix<_String,_Flag>::get_type(size_t row, size_t col) const
 
112
{
 
113
    return mp_storage->get_type(row, col);
 
114
}
 
115
 
 
116
template<typename _String, typename _Flag>
 
117
double mixed_type_matrix<_String,_Flag>::get_numeric(size_t row, size_t col) const
 
118
{
 
119
    return mp_storage->get_numeric(row, col);
 
120
}
 
121
 
 
122
template<typename _String, typename _Flag>
 
123
bool mixed_type_matrix<_String,_Flag>::get_boolean(size_t row, size_t col) const
 
124
{
 
125
    return mp_storage->get_boolean(row, col);
 
126
}
 
127
 
 
128
template<typename _String, typename _Flag>
 
129
const typename mixed_type_matrix<_String,_Flag>::string_type*
 
130
mixed_type_matrix<_String,_Flag>::get_string(size_t row, size_t col) const
 
131
{
 
132
    return mp_storage->get_string(row, col);
 
133
}
 
134
 
 
135
template<typename _String, typename _Flag>
 
136
void mixed_type_matrix<_String,_Flag>::set_numeric(size_t row, size_t col, double val)
 
137
{
 
138
    mp_storage->get_element(row, col).set_numeric(val);
 
139
}
 
140
 
 
141
template<typename _String, typename _Flag>
 
142
void mixed_type_matrix<_String,_Flag>::set_boolean(size_t row, size_t col, bool val)
 
143
{
 
144
    mp_storage->get_element(row, col).set_boolean(val);
 
145
}
 
146
 
 
147
template<typename _String, typename _Flag>
 
148
void mixed_type_matrix<_String,_Flag>::set_string(size_t row, size_t col, string_type* str)
 
149
{
 
150
    mp_storage->get_element(row, col).set_string(str);
 
151
}
 
152
 
 
153
template<typename _String, typename _Flag>
 
154
void mixed_type_matrix<_String,_Flag>::set_flag(size_t row, size_t col, flag_type flag)
 
155
{
 
156
    mp_storage->get_flag_storage().set_flag(row, col, flag);
 
157
}
 
158
 
 
159
template<typename _String, typename _Flag>
 
160
typename mixed_type_matrix<_String,_Flag>::flag_type
 
161
mixed_type_matrix<_String,_Flag>::get_flag(size_t row, size_t col) const
 
162
{
 
163
    return mp_storage->get_flag_storage().get_flag(row, col);
 
164
}
 
165
 
 
166
template<typename _String, typename _Flag>
 
167
void mixed_type_matrix<_String,_Flag>::clear_flag(size_t row, size_t col)
 
168
{
 
169
    return mp_storage->get_flag_storage().clear_flag(row, col);
 
170
}
 
171
 
 
172
template<typename _String, typename _Flag>
 
173
void mixed_type_matrix<_String,_Flag>::set_empty(size_t row, size_t col)
 
174
{
 
175
    mp_storage->get_element(row, col).set_empty();
 
176
}
 
177
 
 
178
template<typename _String, typename _Flag>
 
179
void mixed_type_matrix<_String,_Flag>::set(size_t row, size_t col, double val)
 
180
{
 
181
    set_numeric(row, col, val);
 
182
}
 
183
 
 
184
template<typename _String, typename _Flag>
 
185
void mixed_type_matrix<_String,_Flag>::set(size_t row, size_t col, bool val)
 
186
{
 
187
    set_boolean(row, col, val);
 
188
}
 
189
 
 
190
template<typename _String, typename _Flag>
 
191
void mixed_type_matrix<_String,_Flag>::set(size_t row, size_t col, string_type* str)
 
192
{
 
193
    set_string(row, col, str);
 
194
}
 
195
 
 
196
template<typename _String, typename _Flag>
 
197
typename mixed_type_matrix<_String,_Flag>::size_pair_type
 
198
mixed_type_matrix<_String,_Flag>::size() const
 
199
{
 
200
    size_pair_type size_pair(mp_storage->rows(), mp_storage->cols());
 
201
    return size_pair;
 
202
}
 
203
 
 
204
template<typename _String, typename _Flag>
 
205
mixed_type_matrix<_String,_Flag>&
 
206
mixed_type_matrix<_String,_Flag>::transpose()
 
207
{
 
208
    mp_storage->transpose();
 
209
    return *this;
 
210
}
 
211
 
 
212
template<typename _String, typename _Flag>
 
213
void mixed_type_matrix<_String,_Flag>::assign(const mixed_type_matrix& r)
 
214
{
 
215
    if (this == &r)
 
216
        // assignment to self.
 
217
        return;
 
218
 
 
219
    size_t row_count = ::std::min(mp_storage->rows(), r.mp_storage->rows());
 
220
    size_t col_count = ::std::min(mp_storage->cols(), r.mp_storage->cols());
 
221
    for (size_t i = 0; i < row_count; ++i)
 
222
        for (size_t j = 0; j < col_count; ++j)
 
223
            mp_storage->get_element(i, j) = r.mp_storage->get_element(i, j);
 
224
}
 
225
 
 
226
template<typename _String, typename _Flag>
 
227
void mixed_type_matrix<_String,_Flag>::resize(size_t row, size_t col)
 
228
{
 
229
    mp_storage->resize(row, col);
 
230
}
 
231
 
 
232
template<typename _String, typename _Flag>
 
233
void mixed_type_matrix<_String,_Flag>::clear()
 
234
{
 
235
    mp_storage->clear();
 
236
}
 
237
 
 
238
template<typename _String, typename _Flag>
 
239
bool mixed_type_matrix<_String,_Flag>::numeric() const
 
240
{
 
241
    return mp_storage->numeric();
 
242
}
 
243
 
 
244
template<typename _String, typename _Flag>
 
245
bool mixed_type_matrix<_String,_Flag>::empty() const
 
246
{
 
247
    return mp_storage->empty();
 
248
}
 
249
 
 
250
template<typename _String, typename _Flag>
 
251
void mixed_type_matrix<_String,_Flag>::swap(mixed_type_matrix& r)
 
252
{
 
253
    ::std::swap(mp_storage, r.mp_storage);
 
254
}
 
255
 
 
256
#ifdef UNIT_TEST
 
257
template<typename _String, typename _Flag>
 
258
void mixed_type_matrix<_String,_Flag>::dump() const
 
259
{
 
260
    using namespace std;
 
261
    size_t rows = mp_storage->rows(), cols = mp_storage->cols();
 
262
    cout << "rows: " << mp_storage->rows() << "  cols: " << mp_storage->cols() << endl;
 
263
    for (size_t i = 0; i < rows; ++i)
 
264
    {
 
265
        cout << "row " << i << ": ";
 
266
        for (size_t j = 0; j < cols; ++j)
 
267
        {
 
268
            matrix_element_t etype = mp_storage->get_type(i, j);
 
269
            if (j > 0)
 
270
                cout << ", ";
 
271
            cout << "(col " << j << ": ";
 
272
            switch (etype)
 
273
            {
 
274
                case element_boolean:
 
275
                    cout << boolalpha << mp_storage->get_boolean(i, j) << noboolalpha;
 
276
                    break;
 
277
                case element_empty:
 
278
                    cout << "-";
 
279
                    break;
 
280
                case element_numeric:
 
281
                    cout << mp_storage->get_numeric(i, j);
 
282
                    break;
 
283
                case element_string:
 
284
                    cout << "'" << mp_storage->get_string(i, j) << "'";
 
285
                    break;
 
286
                default:
 
287
                    ;
 
288
            }
 
289
            cout << ")";
 
290
        }
 
291
        cout << endl;
 
292
    }
 
293
}
 
294
 
 
295
template<typename _String, typename _Flag>
 
296
void mixed_type_matrix<_String,_Flag>::dump_flags() const
 
297
{
 
298
    mp_storage->get_flag_storage().dump();
 
299
}
 
300
#endif
 
301
 
 
302
}