MIST (Media Integration Standard Toolkit)
Revision | b3508c99b2bf1e8784434cdd9bd0050bd374f909 (tree) |
---|---|
Zeit | 2004-06-04 18:31:07 |
Autor | Daisuke Deguchi <ddeguchi@nago...> |
Commiter | Daisuke Deguchi |
2004年6月4日のリリース.
Bスプライン曲線を制御するクラスの実装.
集合演算を扱うクラスの実装.
クォータにオンを用いたトラックボールの実装.
行列演算で,行列が対称行列である場合には,処理を沸けるようにした.
行列演算での,トレースと行列式を計算するルーチンの追加.
その他バグフィックス.
@@ -79,10 +79,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_test", "set_test.vcproj | ||
79 | 79 | ProjectSection(ProjectDependencies) = postProject |
80 | 80 | EndProjectSection |
81 | 81 | EndProject |
82 | -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vector_test", "vector_test.vcproj", "{5B87E451-7196-400B-9898-D276C6418B72}" | |
83 | - ProjectSection(ProjectDependencies) = postProject | |
84 | - EndProjectSection | |
85 | -EndProject | |
86 | 82 | Global |
87 | 83 | GlobalSection(SolutionConfiguration) = preSolution |
88 | 84 | Debug = Debug |
@@ -169,10 +165,6 @@ Global | ||
169 | 165 | {5B87E451-7196-400B-9898-D276C6418B72}.Debug.Build.0 = Debug|Win32 |
170 | 166 | {5B87E451-7196-400B-9898-D276C6418B72}.Release.ActiveCfg = Release|Win32 |
171 | 167 | {5B87E451-7196-400B-9898-D276C6418B72}.Release.Build.0 = Release|Win32 |
172 | - {5B87E451-7196-400B-9898-D276C6418B72}.Debug.ActiveCfg = Debug|Win32 | |
173 | - {5B87E451-7196-400B-9898-D276C6418B72}.Debug.Build.0 = Debug|Win32 | |
174 | - {5B87E451-7196-400B-9898-D276C6418B72}.Release.ActiveCfg = Release|Win32 | |
175 | - {5B87E451-7196-400B-9898-D276C6418B72}.Release.Build.0 = Release|Win32 | |
176 | 168 | EndGlobalSection |
177 | 169 | GlobalSection(ExtensibilityGlobals) = postSolution |
178 | 170 | EndGlobalSection |
@@ -87,9 +87,6 @@ _MIST_BEGIN | ||
87 | 87 | #define _MIST_THREAD_SUPPORT_ 1 // MISTの各アルゴリズムでのスレッドサポートをするかどうか |
88 | 88 | // サポートする場合は,LINUX系の場合は pthread ライブラリが必要 |
89 | 89 | |
90 | -#define _MIST_VECTOR_SUPPORT_ 0 // MISTのVECTORを有効にする.MATRIXとの掛け算等もサポートする. | |
91 | - // STLのvectorとクラス名がかぶるため,名前空間を正しくインポートする必要がある. | |
92 | - | |
93 | 90 | |
94 | 91 | // 行列演算のオプション |
95 | 92 | #define _USE_BALANCING_MATRIX_EIGEN_ 1 // 行列の対角化を行うことで計算精度を上げる(若干メモリを大目に食う) |
@@ -57,8 +57,6 @@ struct matrix_expression | ||
57 | 57 | T expression; |
58 | 58 | |
59 | 59 | value_type operator()( size_type r, size_type c ) const { return( expression( r, c ) ); } |
60 | - value_type operator[]( size_type indx ) const { return( expression[ indx ] ); } | |
61 | - size_type size( ) const { return( expression.size( ) ); }; | |
62 | 60 | size_type rows( ) const { return( expression.rows( ) ); }; |
63 | 61 | size_type cols( ) const { return( expression.cols( ) ); }; |
64 | 62 |
@@ -112,11 +110,9 @@ struct matrix_minus : public matrix_single_operation< T > | ||
112 | 110 | typedef matrix_single_operation< T > base; |
113 | 111 | |
114 | 112 | explicit matrix_minus( const T &mhs ) : base( mhs ){} |
115 | - size_type size( ) const { return( base::middle_.size( ) ); }; | |
116 | 113 | size_type rows( ) const { return( base::middle_.rows( ) ); } |
117 | 114 | size_type cols( ) const { return( base::middle_.cols( ) ); } |
118 | 115 | value_type operator()( size_type r, size_type c ) const { return( - base::middle_( r, c ) ); } |
119 | - value_type operator[]( size_type indx ) const { return( - base::middle_[ indx ] ); } | |
120 | 116 | }; |
121 | 117 | |
122 | 118 |
@@ -130,11 +126,9 @@ struct matrix_transpose : public matrix_single_operation< T > | ||
130 | 126 | typedef matrix_single_operation< T > base; |
131 | 127 | |
132 | 128 | explicit matrix_transpose( const T &mhs ) : base( mhs ){} |
133 | - size_type size( ) const { return( base::middle_.size( ) ); }; | |
134 | 129 | size_type rows( ) const { return( base::middle_.cols( ) ); } |
135 | 130 | size_type cols( ) const { return( base::middle_.rows( ) ); } |
136 | 131 | value_type operator()( size_type r, size_type c ) const { return( base::middle_( c, r ) ); } |
137 | - value_type operator[]( size_type indx ) const { return( base::middle_[ indx ] ); } | |
138 | 132 | }; |
139 | 133 | |
140 | 134 |
@@ -157,11 +151,9 @@ struct matrix_add : public matrix_bind_operation< T1, T2 > | ||
157 | 151 | } |
158 | 152 | #endif |
159 | 153 | } |
160 | - size_type size( ) const { return( base::left_.size( ) ); }; | |
161 | 154 | size_type rows( ) const { return( base::left_.rows( ) ); } |
162 | 155 | size_type cols( ) const { return( base::left_.cols( ) ); } |
163 | 156 | value_type operator()( size_type r, size_type c ) const { return( base::left_( r, c ) + base::right_( r, c ) ); } |
164 | - value_type operator[]( size_type indx ) const { return( base::left_[ indx ] + base::right_[ indx ] ); } | |
165 | 157 | }; |
166 | 158 | |
167 | 159 |
@@ -184,11 +176,9 @@ struct matrix_sub : public matrix_bind_operation< T1, T2 > | ||
184 | 176 | } |
185 | 177 | #endif |
186 | 178 | } |
187 | - size_type size( ) const { return( base::left_.size( ) ); }; | |
188 | 179 | size_type rows( ) const { return( base::left_.rows( ) ); } |
189 | 180 | size_type cols( ) const { return( base::left_.cols( ) ); } |
190 | 181 | value_type operator()( size_type r, size_type c ) const { return( base::left_( r, c ) - base::right_( r, c ) ); } |
191 | - value_type operator[]( size_type indx ) const { return( base::left_[ indx ] - base::right_[ indx ] ); } | |
192 | 182 | }; |
193 | 183 | |
194 | 184 |
@@ -211,7 +201,6 @@ struct matrix_mul : public matrix_bind_operation< T1, T2 > | ||
211 | 201 | } |
212 | 202 | #endif |
213 | 203 | } |
214 | - size_type size( ) const { return( base::left_.size( ) ); }; | |
215 | 204 | size_type rows( ) const { return( base::left_.rows( ) ); } |
216 | 205 | size_type cols( ) const { return( base::right_.cols( ) ); } |
217 | 206 | value_type operator()( size_type r, size_type c ) const |
@@ -224,7 +213,6 @@ struct matrix_mul : public matrix_bind_operation< T1, T2 > | ||
224 | 213 | } |
225 | 214 | return( v ); |
226 | 215 | } |
227 | - value_type operator[]( size_type indx ) const { return( base::left_[ indx ] * base::right_[ indx ] ); } | |
228 | 216 | }; |
229 | 217 | |
230 | 218 |
@@ -238,11 +226,9 @@ struct matrix_add_const : public matrix_bind_operation< T1, T2 > | ||
238 | 226 | typedef matrix_bind_operation< T1, T2 > base; |
239 | 227 | |
240 | 228 | matrix_add_const( const T1 &lhs, const T2 &rhs ) : base( lhs, rhs ){} |
241 | - size_type size( ) const { return( base::left_.size( ) ); }; | |
242 | 229 | size_type rows( ) const { return( base::left_.rows( ) ); } |
243 | 230 | size_type cols( ) const { return( base::left_.cols( ) ); } |
244 | 231 | value_type operator()( size_type r, size_type c ) const { return( base::left_( r, c ) + ( r == c ? base::right_ : 0 ) ); } |
245 | - value_type operator[]( size_type indx ) const { return( base::left_[ indx ] + base::right_ ); } | |
246 | 232 | }; |
247 | 233 | |
248 | 234 | // 定数の足し算オペレータ(右側が定数) |
@@ -255,11 +241,9 @@ struct matrix_sub_const1 : public matrix_bind_operation< T1, T2 > | ||
255 | 241 | typedef matrix_bind_operation< T1, T2 > base; |
256 | 242 | |
257 | 243 | matrix_sub_const1( const T1 &lhs, const T2 &rhs ) : base( lhs, rhs ){} |
258 | - size_type size( ) const { return( base::left_.size( ) ); }; | |
259 | 244 | size_type rows( ) const { return( base::left_.rows( ) ); } |
260 | 245 | size_type cols( ) const { return( base::left_.cols( ) ); } |
261 | 246 | value_type operator()( size_type r, size_type c ) const { return( base::left_( r, c ) - ( r == c ? base::right_ : 0 ) ); } |
262 | - value_type operator[]( size_type indx ) const { return( base::left_[ indx ] - base::right_ ); } | |
263 | 247 | }; |
264 | 248 | |
265 | 249 | // 定数の足し算オペレータ(左側が定数) |
@@ -272,11 +256,9 @@ struct matrix_sub_const2 : public matrix_bind_operation< T1, T2 > | ||
272 | 256 | typedef matrix_bind_operation< T1, T2 > base; |
273 | 257 | |
274 | 258 | matrix_sub_const2( const T1 &lhs, const T2 &rhs ) : base( lhs, rhs ){} |
275 | - size_type size( ) const { return( base::left_.size( ) ); }; | |
276 | 259 | size_type rows( ) const { return( base::left_.rows( ) ); } |
277 | 260 | size_type cols( ) const { return( base::left_.cols( ) ); } |
278 | 261 | value_type operator()( size_type r, size_type c ) const { return( ( r == c ? base::right_ : 0 ) - base::left_( r, c ) ); } |
279 | - value_type operator[]( size_type indx ) const { return( base::right_[ indx ] - base::left_ ); } | |
280 | 262 | }; |
281 | 263 | |
282 | 264 | // 定数の掛け算オペレータ |
@@ -289,11 +271,9 @@ struct matrix_mul_const : public matrix_bind_operation< T1, T2 > | ||
289 | 271 | typedef matrix_bind_operation< T1, T2 > base; |
290 | 272 | |
291 | 273 | matrix_mul_const( const T1 &lhs, const T2 &rhs ) : base( lhs, rhs ){} |
292 | - size_type size( ) const { return( base::left_.size( ) ); }; | |
293 | 274 | size_type rows( ) const { return( base::left_.rows( ) ); } |
294 | 275 | size_type cols( ) const { return( base::left_.cols( ) ); } |
295 | 276 | value_type operator()( size_type r, size_type c ) const { return( base::left_( r, c ) * base::right_ ); } |
296 | - value_type operator[]( size_type indx ) const { return( base::left_[ indx ] * base::right_ ); } | |
297 | 277 | }; |
298 | 278 | |
299 | 279 | // 定数の割り算オペレータ |
@@ -315,11 +295,9 @@ struct matrix_div_const : public matrix_bind_operation< T1, T2 > | ||
315 | 295 | } |
316 | 296 | #endif |
317 | 297 | } |
318 | - size_type size( ) const { return( base::left_.size( ) ); }; | |
319 | 298 | size_type rows( ) const { return( base::left_.rows( ) ); } |
320 | 299 | size_type cols( ) const { return( base::left_.cols( ) ); } |
321 | 300 | value_type operator()( size_type r, size_type c ) const { return( base::left_( r, c ) / base::right_ ); } |
322 | - value_type operator[]( size_type indx ) const { return( base::left_[ indx ] / base::right_ ); } | |
323 | 301 | }; |
324 | 302 | |
325 | 303 | #endif |
@@ -473,7 +451,7 @@ public: // | ||
473 | 451 | } |
474 | 452 | |
475 | 453 | // 転置行列 |
476 | - matrix t( ) const | |
454 | + matrix t() const | |
477 | 455 | { |
478 | 456 | const matrix &m = *this; |
479 | 457 | matrix o( size2_, size1_ ); |
@@ -253,172 +253,6 @@ template < class T > inline std::ostream &operator <<( std::ostream &out, const | ||
253 | 253 | return( out ); |
254 | 254 | } |
255 | 255 | |
256 | - | |
257 | - | |
258 | -#if defined( _MIST_VECTOR_SUPPORT_ ) && _MIST_VECTOR_SUPPORT_ != 0 | |
259 | - | |
260 | - | |
261 | -// 行列 | |
262 | -template < class T, class Allocator = ::std::allocator< T > > | |
263 | -class vector : public matrix< T, Allocator > | |
264 | -{ | |
265 | -private: | |
266 | - typedef matrix< T, Allocator > base; | |
267 | - | |
268 | -public: | |
269 | - typedef typename base::allocator_type allocator_type; | |
270 | - typedef typename base::reference reference; | |
271 | - typedef typename base::const_reference const_reference; | |
272 | - typedef typename base::value_type value_type; | |
273 | - typedef typename base::size_type size_type; | |
274 | - typedef typename base::difference_type difference_type; | |
275 | - typedef typename base::pointer pointer; | |
276 | - typedef typename base::const_pointer const_pointer; | |
277 | - | |
278 | - typedef typename base::iterator iterator; | |
279 | - typedef typename base::const_iterator const_iterator; | |
280 | - typedef typename base::reverse_iterator reverse_iterator; | |
281 | - typedef typename base::const_reverse_iterator const_reverse_iterator; | |
282 | - | |
283 | - | |
284 | -/************************************************************************************************************ | |
285 | -** | |
286 | -** 行列に対する演算子 | |
287 | -** += 行列 | |
288 | -** += 定数 | |
289 | -** | |
290 | -** -= 行列 | |
291 | -** -= 定数 | |
292 | -** | |
293 | -** *= 行列 | |
294 | -** *= 定数 | |
295 | -** | |
296 | -** /= 定数 | |
297 | -** | |
298 | -************************************************************************************************************/ | |
299 | - //template < class TT, class AAlocator > | |
300 | - //const vector& operator +=( const vector< TT, AAlocator > &v2 ) | |
301 | - //{ | |
302 | - // base::operator +=( v2 ); | |
303 | - // return( v1 ); | |
304 | - //} | |
305 | - | |
306 | - //template < class TT, class AAlocator > | |
307 | - //const vector& operator -=( const vector< TT, AAlocator > &v2 ) | |
308 | - //{ | |
309 | - // base::operator -=( v2 ); | |
310 | - // return( v1 ); | |
311 | - //} | |
312 | - | |
313 | - template < class TT, class AAlocator > | |
314 | - const vector& operator *=( const vector< TT, AAlocator > &v2 ) | |
315 | - { | |
316 | - vector &v1 = *this; | |
317 | - typedef typename vector< T, Allocator >::size_type size_type; | |
318 | -#ifdef _CHECK_MATRIX_OPERATION_ | |
319 | - if( base::size( ) != v2.size( ) ) | |
320 | - { | |
321 | - // 外積の計算ができません例外 | |
322 | - ::std::cout << "can't calculate outer product of two vectors." << ::std::endl; | |
323 | - return( v1 ); | |
324 | - } | |
325 | -#endif | |
326 | - | |
327 | - vector v( v1.size( ) ); | |
328 | - | |
329 | - for( size_type i = 0 ; i < ret.dim-2 ; ++i ) | |
330 | - { | |
331 | - v[ i ] = v1[ i + 1 ] * v2[ i + 2 ] - v1[ i + 2 ] * v2[ i + 1 ]; | |
332 | - } | |
333 | - | |
334 | - v[ i ] = v1[ i + 1 ] * v2[ 0 ] - v1[ 0 ] * v2[ i + 1 ]; | |
335 | - v[ i + 1 ] = v1[ 0 ] * v2[ 1 ] - v1[ 1 ] * v2[ 0 ]; | |
336 | - | |
337 | - v1.swap( v ); | |
338 | - | |
339 | - return( *this ); | |
340 | - } | |
341 | - | |
342 | - //const vector& operator *=( typename type_trait< T >::value_type val ) | |
343 | - //{ | |
344 | - // base::operator *=( val ); | |
345 | - // return( *this ); | |
346 | - //} | |
347 | - | |
348 | - //const vector& operator /=( typename type_trait< T >::value_type val ) | |
349 | - //{ | |
350 | - // base::operator /=( val ); | |
351 | - // return( *this ); | |
352 | - //} | |
353 | - | |
354 | - | |
355 | -public: | |
356 | - // 構築 | |
357 | - vector( ) : base( ), size1_( 0 ), size2_( 0 ) {} | |
358 | - explicit vector( const Allocator &a ) : base( a ), size1_( 0 ), size2_( 0 ) {} | |
359 | - | |
360 | - vector( size_type num ) : base( num, 1 ) {} | |
361 | - vector( size_type num, const Allocator &a ) : base( num, 1, a ) {} | |
362 | - | |
363 | - vector( size_type num, const T &val ) : base( num, 1, val ) {} | |
364 | - vector( size_type num, const T &val, const Allocator &a ) : base( num, 1, val, a ) {} | |
365 | - | |
366 | - template < class TT, class AAlocator > | |
367 | - vector( const vector< TT, AAlocator > &o ) : base( o ){ } | |
368 | - | |
369 | - vector( const vector< T, Allocator > &o ) : base( o ){ } | |
370 | - | |
371 | -#if _USE_EXPRESSION_TEMPLATE_ != 0 | |
372 | - template < class Expression > | |
373 | - vector( const matrix_expression< Expression > &expression ) : base( expression.size( ), 1 ) | |
374 | - { | |
375 | - vector &v = *this; | |
376 | - for( size_type indx = 0 ; indx < v.size( ) ; indx++ ) | |
377 | - { | |
378 | - v[ indx ] = expression[ indx ]; | |
379 | - } | |
380 | - } | |
381 | -#endif | |
382 | -}; | |
383 | - | |
384 | - | |
385 | - | |
386 | -/************************************************************************************************************ | |
387 | -** | |
388 | -** 標準出力への行列の出力 | |
389 | -** | |
390 | -************************************************************************************************************/ | |
391 | -template < class T, class Allocator > | |
392 | -inline ::std::ostream &operator <<( ::std::ostream &out, const vector< T, Allocator > &m ) | |
393 | -{ | |
394 | - typename vector< T, Allocator >::size_type indx; | |
395 | - for( indx = 0 ; indx < v.size( ) ; indx++ ) | |
396 | - { | |
397 | - out << m[ indx ]; | |
398 | - if( indx != m.size( ) - 1 ) out << ", "; | |
399 | - } | |
400 | - out << ::std::endl; | |
401 | - | |
402 | - return( out ); | |
403 | -} | |
404 | - | |
405 | - | |
406 | -//#if _USE_EXPRESSION_TEMPLATE_ != 0 | |
407 | -// | |
408 | -//template < class T > | |
409 | -//inline ::std::ostream &operator <<( ::std::ostream &out, const matrix_expression< T > &m ) | |
410 | -//{ | |
411 | -// typedef typename matrix_expression< T >::allocator_type allocator_type; | |
412 | -// typedef typename matrix_expression< T >::value_type value_type; | |
413 | -// return( operator <<( out, vector< value_type, allocator_type >( m ) ) ); | |
414 | -//} | |
415 | -// | |
416 | -//#endif | |
417 | - | |
418 | -#endif // _MIST_VECTOR_SUPPORT_ | |
419 | - | |
420 | - | |
421 | - | |
422 | 256 | // mist名前空間の終わり |
423 | 257 | _MIST_END |
424 | 258 |
@@ -164,10 +164,9 @@ void evaluate_matrix_operation1( ) | ||
164 | 164 | mist::matrix< double > A( 100, 100 ); |
165 | 165 | mist::matrix< double > B( 100, 100 ); |
166 | 166 | |
167 | - size_type r, c; | |
168 | - for( r = 0 ; r < mat1.rows( ) ; r++ ) | |
167 | + for( size_type r = 0 ; r < mat1.rows( ) ; r++ ) | |
169 | 168 | { |
170 | - for( c = 0 ; c < mat1.cols( ) ; c++ ) | |
169 | + for( size_type c = 0 ; c < mat1.cols( ) ; c++ ) | |
171 | 170 | { |
172 | 171 | mat1( r, c ) = rand( ) / 3.0 * 10000.0; |
173 | 172 | mat2( r, c ) = rand( ) / 3.0 * 10000.0; |
@@ -185,7 +184,6 @@ void evaluate_matrix_operation1( ) | ||
185 | 184 | { |
186 | 185 | mist::timer t; |
187 | 186 | double tmp; |
188 | - double error = 0.0; | |
189 | 187 | for( j = 0 ; j < A.rows( ) ; j++ ) |
190 | 188 | { |
191 | 189 | for( i = 0 ; i < A.cols( ) ; i++ ) |
@@ -195,17 +193,11 @@ void evaluate_matrix_operation1( ) | ||
195 | 193 | { |
196 | 194 | tmp += mat2( i, k ) * mat3( k, j ); |
197 | 195 | } |
198 | - double tt = mat1( i, j ) + tmp + mat4( i, j ); | |
199 | - double ttt = mat1( i, j ) + tmp; | |
200 | - ttt = ttt + mat4( i, j ); | |
201 | - A( j, i ) = mat1( i, j ) + tmp; | |
202 | - A( j, i ) = A( j, i ) + mat4( i, j ); | |
203 | -// A( j, i ) = mat1( i, j ) + tmp + mat4( i, j ); | |
204 | - error += ( tt - ttt ) * ( tt - ttt ); | |
196 | + A( j, i ) = mat1( i, j ) + tmp + mat4( i, j ); | |
205 | 197 | } |
206 | 198 | } |
207 | 199 | cout << "< In the case of Non Expression Template >" << endl; |
208 | - cout << "Calculation Time: " << t << " (sec)" << error << endl; | |
200 | + cout << "Calculation Time: " << t << " (sec)" << endl; | |
209 | 201 | } |
210 | 202 | |
211 | 203 | { |
@@ -218,12 +210,9 @@ void evaluate_matrix_operation1( ) | ||
218 | 210 | } |
219 | 211 | |
220 | 212 | double err = 0.0; |
221 | - for( r = 0 ; r < mat1.rows( ) ; r++ ) | |
213 | + for( l = 0 ; l < A.size( ) ; l++ ) | |
222 | 214 | { |
223 | - for( c = 0 ; c < mat1.cols( ) ; c++ ) | |
224 | - { | |
225 | - err += ( A( r, c ) - B( r, c ) ) * ( A( r, c ) - B( r, c ) ); | |
226 | - } | |
215 | + err += ( A[ l ] - B[ l ] ) * ( A[ l ] - B[ l ] ); | |
227 | 216 | } |
228 | 217 | |
229 | 218 | cout << "Estimate Error: " << err << endl; |