vmmlib-1.0/0000755000175000017500000000000011710571076012201 5ustar shevekshevekvmmlib-1.0/ACKNOWLEDGEMENTS0000644000175000017500000000554311674116156014470 0ustar shevekshevek=========================================================================== enable_if (http://www.boost.org/doc/libs/1_39_0/libs/utility/enable_if.html) =========================================================================== Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. =========================================================================== Parts of vector and matrix code (http://www.cs.cmu.edu/~ajw/doc/vl.html) =========================================================================== Except where otherwise noted, Copyright (c) 2000 Andrew Willmott. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form have no conditions on them. THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. vmmlib-1.0/Makefile.atlas0000644000175000017500000000355011674116156014752 0ustar shevekshevek VMMLIB_UNIT_TESTS =\ tests/unit_test.cpp\ tests/vector_test.cpp\ tests/matrix_test.cpp\ tests/quaternion_test.cpp\ tests/qr_decomposition_test.cpp\ tests/svd_test.cpp\ tests/lapack_svd_test.cpp\ tests/lapack_linear_least_squares_test.cpp\ tests/lapack_gaussian_elimination_test.cpp\ tests/vmmlib_unit_tests_main.cpp\ tests/lapack_sym_eigs_test.cpp\ tests/tensor3_test.cpp \ tests/tensor3_iterator_test.cpp \ tests/tucker3_tensor_test.cpp \ tests/qtucker3_tensor_test.cpp \ tests/tucker3_exporter_importer_test.cpp \ tests/cp3_tensor_test.cpp \ tests/t3_hosvd_test.cpp \ tests/t3_hooi_test.cpp \ tests/t3_hopm_test.cpp \ tests/t3_ihopm_test.cpp \ tests/matrix_pseudoinverse_test.cpp \ tests/blas_dgemm_test.cpp \ tests/blas_dot_test.cpp \ VMMLIB_UNIT_TESTS_OBJECTS = ${VMMLIB_UNIT_TESTS:%.cpp=%.o} CXXFLAGS += -I. -Iinclude -Itests -include stdint.h # Mac OS X specific stuff # on mac we want to use the frameworks, not the unix style libs ARCH = $(shell uname) ifeq "$(ARCH)" "Darwin" CXXFLAGS += -framework Accelerate LDFLAGS += -framework Accelerate else # Linux specific stuff CXXFLAGS += -include f2c.h -include f2c_fix.h LBITS := $(shell getconf LONG_BIT) ifeq ($(LBITS),64) LIBDIR=$(DESTDIR)/usr/lib64 else LIBDIR=$(DESTDIR)/usr/lib endif LDFLAGS += -L$(LIBDIR)/atlas -u MAIN__ CXXFLAGS += LDFLAGS += # adjust libs depending on your LAPACK and BLAS distribution LIBS += -lclapack -lf2c -lcblas -llapack # LIBS += -llapack -lblas endif all: vmmlib_unit_tests .cpp.o: $(CXX) $(CXXFLAGS) -c $< -o $@ vmmlib_unit_tests: $(VMMLIB_UNIT_TESTS_OBJECTS) ifeq "$(ARCH)" "Darwin" $(CXX) $(LDFLAGS) $(VMMLIB_UNIT_TESTS_OBJECTS) -o $@ else $(CXX) $(LDFLAGS) $(VMMLIB_UNIT_TESTS_OBJECTS) -o $@ $(LIBS) endif clean: rm -rf $(VMMLIB_UNIT_TESTS_OBJECTS) vmmlib_unit_tests vmmlib-1.0/AUTHORS0000644000175000017500000000126011674116156013253 0ustar shevekshevekVMMLib - Vector & Matrix Math Lib - AUTHORS Susanne Suter (susuter@ifi.uzh.ch) Jonas Boesch (boesch@ifi.uzh.ch) Stefan Eilemann (eile@gmail.com) Renato Pajarola (pajarola@ifi.uzh.ch) Philip Schlegel (schlegel@ifi.uzh.ch) With contributions from: Daniel Pfeifer (daniel@pfeifer-mail.de) - CMake Build System, Linux fixes Jaroslav Skarvada (jskarvad@redhat.com) - Red Hat packaging, RH compatibility fixes Bas Wijnen (wijnen@debian.org) - Debian packaging see ACKNOWLEDGEMENTS - Parts of the source code of VMMLib were inspired by David Eberly's Wild Magic and Andrew Willmott's VL. - enable_if was inspired by Boost (http://www.boost.org/doc/libs/1_39_0/libs/utility/enable_if.html) vmmlib-1.0/include/0000755000175000017500000000000011710570642013622 5ustar shevekshevekvmmlib-1.0/include/vmmlib/0000755000175000017500000000000011674116156015115 5ustar shevekshevekvmmlib-1.0/include/vmmlib/ACKNOWLEDGEMENTS0000644000175000017500000000554311674116156017401 0ustar shevekshevek=========================================================================== enable_if (http://www.boost.org/doc/libs/1_39_0/libs/utility/enable_if.html) =========================================================================== Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. =========================================================================== Parts of vector and matrix code (http://www.cs.cmu.edu/~ajw/doc/vl.html) =========================================================================== Except where otherwise noted, Copyright (c) 2000 Andrew Willmott. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form have no conditions on them. THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. vmmlib-1.0/include/vmmlib/frustum_culler.hpp0000644000175000017500000001132211674116156020700 0ustar shevekshevek/* * VMMLib - Vector & Matrix Math Lib * * @author Stefan Eilemann * * @license revised BSD license, check LICENSE */ #ifndef __VMML__FRUSTUM_CULLER__HPP__ #define __VMML__FRUSTUM_CULLER__HPP__ #include #include #include // - declaration - namespace vmml { /** Helper class for OpenGL view frustum culling. */ template< class T > class frustum_culler { public: typedef vector< 3, T > vec3; typedef vector< 4, T > vec4; // contructors frustum_culler() {}// warning: components NOT initialised ( for performance ) ~frustum_culler(){} void setup( const matrix< 4, 4, T >& proj_modelview ); Visibility test_sphere( const vector< 4, T >& sphere ); private: inline void _normalize_plane( vector< 4, T >& plane ) const; vec4 _left_plane; vec4 _right_plane; vec4 _bottom_plane; vec4 _top_plane; vec4 _near_plane; vec4 _far_plane; }; // class frustum_culler #ifndef VMMLIB_NO_TYPEDEFS typedef frustum_culler< float > frustum_cullerf; typedef frustum_culler< double > frustum_cullerd; #endif } // namespace vmml // - implementation - // namespace vmml { /** * Setup the culler by extracting the frustum planes from the projection * matrix. The projection matrix should contain the viewing transformation. */ template < class T > void frustum_culler< T >::setup( const matrix< 4, 4, T >& proj_modelview ) { // See http://www2.ravensoft.com/users/ggribb/plane%20extraction.pdf pp.5 const vec4& row0 = proj_modelview.get_row( 0 ); const vec4& row1 = proj_modelview.get_row( 1 ); const vec4& row2 = proj_modelview.get_row( 2 ); const vec4& row3 = proj_modelview.get_row( 3 ); _left_plane = row3 + row0; _right_plane = row3 - row0; _bottom_plane = row3 + row1; _top_plane = row3 - row1; _near_plane = row3 + row2; _far_plane = row3 - row2; _normalize_plane( _left_plane ); _normalize_plane( _right_plane ); _normalize_plane( _bottom_plane ); _normalize_plane( _top_plane ); _normalize_plane( _near_plane ); _normalize_plane( _far_plane ); } template < class T > inline void frustum_culler< T >::_normalize_plane( vector< 4, T >& plane ) const { const vec3& v3 = plane.template get_sub_vector< 3 >(); const T len_i = 1.0 / v3.length(); plane.x() *= len_i; plane.y() *= len_i; plane.z() *= len_i; plane.w() *= len_i; } template < class T > Visibility frustum_culler< T >::test_sphere( const vector< 4, T >& sphere ) { Visibility visibility = VISIBILITY_FULL; // see http://www.flipcode.com/articles/article_frustumculling.shtml // distance = plane.normal . sphere.center + plane.distance // Test all planes: // - if sphere behind plane: not visible // - if sphere intersects one plane: partially visible // - else: fully visible T distance = _left_plane.x() * sphere.x() + _left_plane.y() * sphere.y() + _left_plane.z() * sphere.z() + _left_plane.w(); if( distance <= -sphere.w() ) return VISIBILITY_NONE; if( distance < sphere.w() ) visibility = VISIBILITY_PARTIAL; distance = _right_plane.x() * sphere.x() + _right_plane.y() * sphere.y() + _right_plane.z() * sphere.z() + _right_plane.w(); if( distance <= -sphere.w() ) return VISIBILITY_NONE; if( distance < sphere.w() ) visibility = VISIBILITY_PARTIAL; distance = _bottom_plane.x() * sphere.x() + _bottom_plane.y() * sphere.y() + _bottom_plane.z() * sphere.z() + _bottom_plane.w(); if( distance <= -sphere.w() ) return VISIBILITY_NONE; if( distance < sphere.w() ) visibility = VISIBILITY_PARTIAL; distance = _top_plane.x() * sphere.x() + _top_plane.y() * sphere.y() + _top_plane.z() * sphere.z() + _top_plane.w(); if( distance <= -sphere.w() ) return VISIBILITY_NONE; if( distance < sphere.w() ) visibility = VISIBILITY_PARTIAL; distance = _near_plane.x() * sphere.x() + _near_plane.y() * sphere.y() + _near_plane.z() * sphere.z() + _near_plane.w(); if( distance <= -sphere.w() ) return VISIBILITY_NONE; if( distance < sphere.w() ) visibility = VISIBILITY_PARTIAL; distance = _far_plane.x() * sphere.x() + _far_plane.y() * sphere.y() + _far_plane.z() * sphere.z() + _far_plane.w(); if( distance <= -sphere.w() ) return VISIBILITY_NONE; if( distance < sphere.w() ) visibility = VISIBILITY_PARTIAL; return visibility; } } // namespace vmml #endif // include protection vmmlib-1.0/include/vmmlib/lapack_svd.hpp0000644000175000017500000001621311674116156017740 0ustar shevekshevek#ifndef __VMML__VMMLIB_LAPACK_SVD__HPP__ #define __VMML__VMMLIB_LAPACK_SVD__HPP__ #include #include #include #include #include #include /** * * a wrapper for lapack's DGESVD routine. * * returns a boolean to indicate success of the operation. * if the return value is false, you can get the parameters using * get_params(). * error states: * * INFO (output) INTEGER * = 0: successful exit. * < 0: if INFO = -i, the i-th argument had an illegal value. * > 0: if DBDSQR did not converge, INFO specifies how many * superdiagonals of an intermediate bidiagonal form B * did not converge to zero. See the description of WORK * above for details. * * more information in: http://www.netlib.org/lapack/double/dgesvd.f ** */ namespace vmml { namespace lapack { // XYYZZZ // X = data type: S - float, D - double // YY = matrix type, GE - general, TR - triangular // ZZZ = function name template< typename float_t > struct svd_params { char jobu; char jobvt; lapack_int m; lapack_int n; float_t* a; lapack_int lda; float_t* s; float_t* u; lapack_int ldu; float_t* vt; lapack_int ldvt; float_t* work; lapack_int lwork; lapack_int info; friend std::ostream& operator << ( std::ostream& os, const svd_params< float_t >& p ) { os << "jobu " << p.jobu << " jobvt " << p.jobvt << " m " << p.m << " n " << p.n << " lda " << p.lda << " ldu " << p.ldu << " ldvt " << p.ldvt << " lwork " << p.lwork << " info " << p.info << std::endl; return os; } }; #if 0 /* Subroutine */ int dgesvd_(char *jobu, char *jobvt, integer *m, integer *n, doublereal *a, integer *lda, doublereal *s, doublereal *u, integer * ldu, doublereal *vt, integer *ldvt, doublereal *work, integer *lwork, integer *info); #endif template< typename float_t > inline void svd_call( svd_params< float_t >& p ) { VMMLIB_ERROR( "not implemented for this type.", VMMLIB_HERE ); } template<> inline void svd_call( svd_params< float >& p ) { //std::cout << "calling lapack svd (single precision) " << std::endl; sgesvd_( &p.jobu, &p.jobvt, &p.m, &p.n, p.a, &p.lda, p.s, p.u, &p.ldu, p.vt, &p.ldvt, p.work, &p.lwork, &p.info ); } template<> inline void svd_call( svd_params< double >& p ) { //std::cout << "calling lapack svd (double precision) " << std::endl; dgesvd_( &p.jobu, &p.jobvt, &p.m, &p.n, p.a, &p.lda, p.s, p.u, &p.ldu, p.vt, &p.ldvt, p.work, &p.lwork, &p.info ); } } // namespace lapack template< size_t M, size_t N, typename float_t > struct lapack_svd { lapack_svd(); ~lapack_svd(); // slow version, full SVD, use if all values of U(MXM) and Vt(NXN) are needed bool compute_full( const matrix< M, N, float_t >& A, matrix< M, M, float_t >& U, vector< N, float_t >& sigma, matrix< N, N, float_t >& Vt ); // version of reduced SVD, computes only most significant left and right singular vectors, // i.e., use if U(MXN) and Vt(NXN) are needed bool compute( const matrix< M, N, float_t >& A, matrix< M, N, float_t >& U, vector< N, float_t >& sigma, matrix< N, N, float_t >& Vt ); // overwrites A with the result U, bool compute_and_overwrite_input( matrix< M, N, float_t >& A_U, vector< N, float_t >& sigma ); // fast version, use if only sigma is needed. bool compute( const matrix< M, N, float_t >& A, vector< N, float_t >& sigma ); inline bool test_success( lapack::lapack_int info ); lapack::svd_params< float_t > p; const lapack::svd_params< float_t >& get_params(){ return p; }; }; // struct lapack_svd template< size_t M, size_t N, typename float_t > lapack_svd< M, N, float_t >::lapack_svd() { p.jobu = 'N'; p.jobvt = 'N'; p.m = M; p.n = N; p.a = 0; p.lda = M; p.s = 0; p.u = 0; p.ldu = M; p.vt = 0; p.ldvt = 1; p.work = new float_t; p.lwork = -1; // workspace query lapack::svd_call( p ); p.lwork = static_cast< lapack::lapack_int >( p.work[0] ); delete p.work; p.work = new float_t[ p.lwork ]; } template< size_t M, size_t N, typename float_t > lapack_svd< M, N, float_t >::~lapack_svd() { delete[] p.work; } template< size_t M, size_t N, typename float_t > bool lapack_svd< M, N, float_t >::compute_full( const matrix< M, N, float_t >& A, matrix< M, M, float_t >& U, vector< N, float_t >& S, matrix< N, N, float_t >& Vt ) { // lapack destroys the contents of the input matrix typedef matrix< M, N, float_t > m_type; m_type* AA = new m_type( A ); p.jobu = 'A'; p.jobvt = 'A'; p.a = AA->array; p.u = U.array; p.s = S.array; p.vt = Vt.array; p.ldvt = N; lapack::svd_call< float_t >( p ); delete AA; return p.info == 0; } template< size_t M, size_t N, typename float_t > bool lapack_svd< M, N, float_t >::compute( const matrix< M, N, float_t >& A, matrix< M, N, float_t >& U, vector< N, float_t >& S, matrix< N, N, float_t >& Vt ) { // lapack destroys the contents of the input matrix typedef matrix< M, N, float_t > m_type; m_type* AA = new m_type( A ); p.jobu = 'S'; p.jobvt = 'S'; p.a = AA->array; p.u = U.array; p.s = S.array; p.vt = Vt.array; p.ldvt = N; lapack::svd_call< float_t >( p ); delete AA; return p.info == 0; } template< size_t M, size_t N, typename float_t > bool lapack_svd< M, N, float_t >::compute_and_overwrite_input( matrix< M, N, float_t >& A_U, vector< N, float_t >& S ) { p.jobu = 'O'; p.jobvt = 'N'; p.a = A_U.array; p.s = S.array; p.ldvt = N; lapack::svd_call< float_t >( p ); return p.info == 0; } template< size_t M, size_t N, typename float_t > bool lapack_svd< M, N, float_t >::compute( const matrix< M, N, float_t >& A, vector< N, float_t >& S ) { // lapack destroys the contents of the input matrix typedef matrix< M, N, float_t > m_type; m_type* AA = new m_type( A ); p.jobu = 'N'; p.jobvt = 'N'; p.a = AA.array; p.u = 0; p.s = S.array; p.vt = 0; lapack::svd_call< float_t >( p ); delete AA; return p.info == 0; } } // namespace vmml #endif vmmlib-1.0/include/vmmlib/t3_ihopm.hpp0000644000175000017500000001142411674116156017352 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * * iHOPM stands for incremental higher-order power method. * in other words, it is an incremental rank-r CP-ALS * * CP stands for Candecomp/Parafac (1970); ALS for alternating least squares algorithm * references: * - Carroll & Chang, 1970: Analysis of Individual Differences in Multidimensional Scaling via an N-way generalization of ``Eckart--Young'' decompositions, Psychometrika. * - Harshman, 1970: Foundations of the PARAFAC procedure: Models and conditions for an 'explanatory' multi-modal factor analysis, UCLA Working Papers in Phonetics. * - De Lathauwer, De Moor, Vandewalle, 2000: A multilinear singular value decomposition, SIAM J. Matrix Anal. Appl. * - Kolda & Bader, 2009: Tensor Decompositions and Applications, SIAM Review. * * incremental rank-r approximation: * - Zang & Golub, 2001: Rank-one approximation to higher order tensors, SIAM J. Matrix Anal. Appl. */ #ifndef __VMML__T3_IHOPM__HPP__ #define __VMML__T3_IHOPM__HPP__ #include namespace vmml { template< size_t R, size_t R_incr, size_t I1, size_t I2, size_t I3, typename T_val = float, typename T_coeff = double > class t3_ihopm { public: typedef tensor3< I1, I2, I3, T_val > t3_type; typedef tensor3< I1, I2, I3, T_coeff > t3_coeff_type; typedef vector< R*R_incr, T_val > lambda_type; typedef vector< R*R_incr, T_coeff > lambda_incr_type; typedef vector< R, T_coeff > lambda_tmp_type; typedef matrix< I1, R*R_incr, T_val > u1_type; typedef matrix< I2, R*R_incr, T_val > u2_type; typedef matrix< I3, R*R_incr, T_val > u3_type; typedef matrix< I1, R*R_incr, T_coeff > u1_incr_type; typedef matrix< I2, R*R_incr, T_coeff > u2_incr_type; typedef matrix< I3, R*R_incr, T_coeff > u3_incr_type; typedef matrix< I1, R, T_coeff > u1_tmp_type; typedef matrix< I2, R, T_coeff > u2_tmp_type; typedef matrix< I3, R, T_coeff > u3_tmp_type; typedef matrix< I1, 1, T_coeff > u1_1col_type; typedef matrix< I2, 1, T_coeff > u2_1col_type; typedef matrix< I3, 1, T_coeff > u3_1col_type; //incremental cp als (zang&golub, 2001) static void incremental_als( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_, lambda_type& lambdas_ ); }; #define VMML_TEMPLATE_STRING template< size_t R, size_t R_incr, size_t I1, size_t I2, size_t I3, typename T_val, typename T_coeff > #define VMML_TEMPLATE_CLASSNAME t3_ihopm< R, R_incr, I1, I2, I3, T_val, T_coeff > VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::incremental_als( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_, lambda_type& lambdas_ ) { t3_coeff_type* approx_data = new t3_coeff_type; approx_data->zero(); t3_coeff_type* residual_data = new t3_coeff_type; residual_data->cast_from( data_ ); lambda_tmp_type* lambdas_tmp = new lambda_tmp_type; lambdas_tmp->set( 0 ); u1_tmp_type* u1_tmp = new u1_tmp_type; u2_tmp_type* u2_tmp = new u2_tmp_type; u3_tmp_type* u3_tmp = new u3_tmp_type; lambda_incr_type* lambdas_incr = new lambda_incr_type; lambdas_incr->set( 0 ); u1_incr_type* u1_incr = new u1_incr_type; u1_incr->zero(); u2_incr_type* u2_incr = new u2_incr_type; u2_incr->zero(); u3_incr_type* u3_incr = new u3_incr_type; u3_incr->zero(); u1_1col_type* u1_1col = new u1_1col_type; u2_1col_type* u2_1col = new u2_1col_type; u3_1col_type* u3_1col = new u3_1col_type; typedef t3_hopm< R, I1, I2, I3, T_coeff > hopm_type; for ( size_t i= 0; i < R_incr; ++i ) { //init all values to zero u1_tmp->zero(); u2_tmp->zero(); u3_tmp->zero(); *lambdas_tmp = 0.0; approx_data->zero(); hopm_type::als( *residual_data, *u1_tmp, *u2_tmp, *u3_tmp, *lambdas_tmp, typename hopm_type::init_hosvd() ); //set lambdas und us to appropriate position size_t r_incr = 0; T_coeff lambda_r = 0; for ( size_t r = 0; r < R; ++r ) { r_incr = i * R + r; u1_tmp->get_column( r, *u1_1col ); u1_incr->set_column( r_incr, *u1_1col ); u2_tmp->get_column( r, *u2_1col ); u2_incr->set_column( r_incr, *u2_1col ); u3_tmp->get_column( r, *u3_1col ); u3_incr->set_column( r_incr, *u3_1col ); lambda_r = lambdas_tmp->at( r ); lambdas_incr->at( r_incr) = lambda_r; //set lambda } t3_hopm< R, I1, I2, I3, T_coeff >::reconstruct( *approx_data, *u1_tmp, *u2_tmp, *u3_tmp, *lambdas_tmp ); *residual_data = *residual_data - *approx_data; } u1_.cast_from( *u1_incr ); u2_.cast_from( *u2_incr ); u3_.cast_from( *u3_incr ); lambdas_.cast_from( *lambdas_incr ); delete u1_1col; delete u2_1col; delete u3_1col; delete u1_tmp; delete u2_tmp; delete u3_tmp; delete lambdas_tmp; delete u1_incr; delete u2_incr; delete u3_incr; delete lambdas_incr; delete residual_data; delete approx_data; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME }//end vmml namespace #endif vmmlib-1.0/include/vmmlib/tensor3.hpp0000644000175000017500000020261011674116156017224 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * @author Jonas Boesch * * a tensor is a generalization of a multidimensional array * a tensor3 is a tensor data structure with three modes I1, I2 and I3 */ #ifndef __VMML__TENSOR3__HPP__ #define __VMML__TENSOR3__HPP__ #include // file I/O #include #include #include #include namespace vmml { // tensor with three modes, containing a series I3 of I1 x I2 vmml matrices //I1 is number of rows, I2 is number of columns and I3 is number of tubes template< size_t I1, size_t I2, size_t I3, typename T = float > class tensor3 { public: typedef T value_type; typedef T* pointer; typedef T& reference; typedef float T_blas; typedef typename matrix< I1, I2, T>::iterator matrix_iterator; typedef typename vmml::tensor3_iterator< tensor3< I1, I2, I3, T > > iterator; typedef typename vmml::tensor3_const_iterator< tensor3< I1, I2, I3, T > > const_iterator; typedef typename vmml::tensor3_iterator< tensor3< I1, I2, I3, T > > reverse_iterator; typedef typename vmml::tensor3_iterator< tensor3< I1, I2, I3, T > > const_reverse_iterator; typedef matrix< I1, I2, T > front_slice_type; //fwd: forward cylcling (after kiers et al., 2000) typedef matrix< I3, I1, T > lat_slice_type; typedef matrix< I2, I3, T > horiz_slice_type; typedef matrix< I1, I2*I3, T > fwd_front_unfolding_type; typedef matrix< I2, I3*I1, T > fwd_horiz_unfolding_type; typedef matrix< I3, I1*I2, T > fwd_lat_unfolding_type; typedef matrix< I2, I1, T > bwd_front_slice_type; //bwd: backward cylcling (after lathauwer et al., 2000a) typedef matrix< I1, I3, T > bwd_lat_slice_type; typedef matrix< I3, I2, T > bwd_horiz_slice_type; typedef matrix< I1, I2*I3, T > bwd_lat_unfolding_type; typedef matrix< I2, I1*I3, T > bwd_front_unfolding_type; typedef matrix< I3, I1*I2, T > bwd_horiz_unfolding_type; static const size_t ROWS = I1; static const size_t COLS = I2; static const size_t SLICES = I3; static const size_t SIZE = I1 * I2 * I3; static const size_t MATRIX_SIZE = I1 * I2; // accessors inline T& operator()( size_t i1, size_t i2, size_t i3 ); inline const T& operator()( size_t i1, size_t i2, size_t i3 ) const; inline T& at( size_t i1, size_t i2, size_t i3 ); inline const T& at( size_t i1, size_t i2, size_t i3 ) const; // element iterators - NOTE: column-major order iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const; #if 0 reverse_iterator rbegin(); reverse_iterator rend(); const_reverse_iterator rbegin() const; const_reverse_iterator rend() const; #endif // ctors tensor3(); tensor3( const tensor3& source ); template< typename U > tensor3( const tensor3< I1, I2, I3, U >& source_ ); template< size_t J1, size_t J2, size_t J3> tensor3( const tensor3< J1, J2, J3, T >& source_ ); ~tensor3(); size_t size() const; // return I1 * I2 * I3; template< size_t J1, size_t J2, size_t J3 > tensor3 get_sub_tensor3( size_t row_offset, size_t col_offset, size_t slice_offset = 0, typename enable_if< J1 <= I1 && J2 <= I2 && J3 <= I3 >::type* = 0 ) const; template< size_t J1, size_t J2, size_t J3 > typename enable_if< J1 <= I1 && J2 <= I2 && J3 <= I3 >::type* get_sub_tensor3( tensor3& result, size_t row_offset = 0, size_t col_offset = 0, size_t slice_offset = 0 ) const; template< size_t J1, size_t J2, size_t J3 > typename enable_if< J1 <= I1 && J2 <= I2 && J3 <= I3 >::type* set_sub_tensor3( const tensor3& sub_data_, size_t row_offset = 0, size_t col_offset = 0, size_t slice_offset = 0 ); inline void get_I1_vector( size_t i2, size_t i3, vector< I1, T >& data ) const; // I1_vector is a column vector with all values i1 at i2 and i3 inline void get_I2_vector( size_t i1, size_t i3, vector< I2, T >& data ) const; // I2_vector is a row vector with all values i2 at i1 and i3 inline void get_I3_vector( size_t i1, size_t i2, vector< I3, T >& data ) const; // I3_vector is a vector with all values i3 at a given i1 and i2 inline void get_row( size_t i1, size_t i3, vector< I2, T >& data ) const; // same as get_I2_vector inline void get_column( size_t i2, size_t i3, vector< I1, T >& data ) const; // same as get_I1_vector inline void get_tube( size_t i1, size_t i2, vector< I3, T >& data ) const; // same as get_I3_vector inline void set_I1_vector( size_t i2, size_t i3, const vector< I1, T >& data ); // I1_vector is a column vector with all values i1 at i2 and i3 inline void set_I2_vector( size_t i1, size_t i3, const vector< I2, T >& data ); // I2_vector is a row vector with all values i2 at i1 and i3 inline void set_I3_vector( size_t i1, size_t i2, const vector< I3, T >& data ); // I3_vector is a vector with all values i3 at a given i1 and i2 inline void set_row( size_t i1, size_t i3, const vector< I2, T >& data ); // same as set_I2_vector inline void set_column( size_t i2, size_t i3, const vector< I1, T >& data ); // same as set_I1_vector inline void set_tube( size_t i1, size_t i2, const vector< I3, T >& data ); // same as set_I3_vector inline void get_frontal_slice_fwd( size_t i3, front_slice_type& data ) const; inline void get_lateral_slice_bwd( size_t i2, bwd_lat_slice_type& data ) const; inline void get_horizontal_slice_fwd( size_t i1, horiz_slice_type& data ) const; inline void get_frontal_slice_bwd( size_t i3, bwd_front_slice_type& data ) const; inline void get_lateral_slice_fwd( size_t i2, lat_slice_type& data ) const; inline void get_horizontal_slice_bwd( size_t i1, bwd_horiz_slice_type& data ) const; inline void set_frontal_slice_fwd( size_t i3, const front_slice_type& data ); inline void set_lateral_slice_bwd( size_t i2, const bwd_lat_slice_type& data ); inline void set_horizontal_slice_fwd( size_t i1, const horiz_slice_type& data ); inline void set_frontal_slice_bwd( size_t i3, const bwd_front_slice_type& data ); inline void set_lateral_slice_fwd( size_t i2, const lat_slice_type& data ); inline void set_horizontal_slice_bwd( size_t i1, const bwd_horiz_slice_type& data ); inline front_slice_type& get_frontal_slice_fwd( size_t index ); inline const front_slice_type& get_frontal_slice_fwd( size_t index ) const; // sets all elements to fill_value void operator=( T fill_value ); //@SUS: todo void fill( T fill_value ); //special case of set method (all values are set to the same value!) //sets all tensor values with random values //set srand(time(NULL)) or srand( seed ) //if seed is set to -1, srand( seed ) was set outside set_random //otherwise srand( seed ) will be called with the given seed void fill_random( int seed = -1 ); void fill_random_signed( int seed = -1 ); void fill_increasing_values( ); void fill_rand_sym_slices( int seed = -1 ); void fill_rand_sym( int seed = -1 ); const tensor3& operator=( const tensor3& source_ ); template< size_t R > typename enable_if< R == I1 && R == I2 && R == I3 >::type* diag( const vector< R, T >& diag_values_ ); void range_threshold(tensor3< I1, I2, I3, T >& other_, const T& start_value, const T& end_value) const; template< size_t K1, size_t K2, size_t K3 > void average_8to1( tensor3< K1, K2, K3, T >& other ) const; // note: this function copies elements until either the matrix is full or // the iterator equals end_. template< typename input_iterator_t > void set( input_iterator_t begin_, input_iterator_t end_, bool row_major_layout = true ); void zero(); T get_min() const; T get_max() const; T get_abs_min() const; T get_abs_max() const; //returns number of non-zeros size_t nnz() const; size_t nnz( const T& threshold_ ) const; void threshold( const T& threshold_value_ ); template< typename TT > void quantize( tensor3< I1, I2, I3, TT >& quantized_, T& min_value_, T& max_value_ ) const; template< typename TT > void quantize_to( tensor3< I1, I2, I3, TT >& quantized_, const T& min_value_, const T& max_value_ ) const; template< typename TT > void quantize_log( tensor3< I1, I2, I3, TT >& quantized_, tensor3< I1, I2, I3, char >& signs_, T& min_value_, T& max_value_, const TT& tt_range_ ) const; template< typename TT > void dequantize( tensor3< I1, I2, I3, TT >& dequantized_, const TT& min_value_, const TT& max_value_ ) const; template< typename TT > void dequantize_log( tensor3< I1, I2, I3, TT >& dequantized_, const tensor3< I1, I2, I3, char >& signs_, const TT& min_value_, const TT& max_value_ ) const; bool operator==( const tensor3& other ) const; bool operator!=( const tensor3& other ) const; // due to limited precision, two 'idential' tensor3 might seem different. // this function allows to specify a tolerance when comparing matrices. bool equals( const tensor3& other, T tolerance ) const; // this version takes a comparison functor to compare the components of // the two tensor3 data structures template< typename compare_t > bool equals( const tensor3& other, compare_t& cmp ) const; //tensor times matrix multiplication along different modes template< size_t J1, size_t J2, size_t J3 > void multiply_horizontal_bwd( const tensor3< J1, J2, J3, T >& other, const matrix< I3, J3, T >& other_slice_ ); //output: tensor3< J1, J2, I3, T > template< size_t J1, size_t J2, size_t J3 > void multiply_lateral_bwd( const tensor3< J1, J2, J3, T >& other, const matrix< I1, J1, T >& other_slice_ ); //output: tensor3< I1, J2, J3, T > template< size_t J1, size_t J2, size_t J3 > void multiply_frontal_bwd( const tensor3< J1, J2, J3, T >& other, const matrix< I2, J2, T >& other_slice_ ); //output: tensor3< J1, I2, J3, T > //apply spherical weights template< typename float_t> void apply_spherical_weights( tensor3< I1, I2, I3, float_t >& other ); void get_sphere(); //backward cyclic matricization/unfolding (after Lathauwer et al., 2000a) template< size_t J1, size_t J2, size_t J3 > void full_tensor3_matrix_multiplication( const tensor3< J1, J2, J3, T >& core, const matrix< I1, J1, T >& U1, const matrix< I2, J2, T >& U2, const matrix< I3, J3, T >& U3 ); template< size_t J1, size_t J2, size_t J3 > void full_tensor3_matrix_kronecker_mult( const tensor3< J1, J2, J3, T >& core, const matrix< I1, J1, T >& U1, const matrix< I2, J2, T >& U2, const matrix< I3, J3, T >& U3 ); void horizontal_unfolding_bwd( bwd_horiz_unfolding_type& unfolding) const; void horizontal_unfolding_fwd( fwd_horiz_unfolding_type& unfolding) const; void lateral_unfolding_bwd( bwd_lat_unfolding_type& unfolding) const; void lateral_unfolding_fwd( fwd_lat_unfolding_type& unfolding) const; void frontal_unfolding_bwd( bwd_front_unfolding_type& unfolding) const; void frontal_unfolding_fwd( fwd_front_unfolding_type& unfolding) const; // reconstruction of a Kruskal tensor => inversion of CP (Candecomp/Parafac) // please note that the parameter U will be overwritten // temp is simply a required workspace matrix, it can be empty or uninitialized // but is passed as parameter to prevent potentially superfluous allocations. template< size_t R > void reconstruct_CP( const vmml::vector< R, T>& lambda, vmml::matrix< R, I1, T >& U, const vmml::matrix< R, I2, T >& V, const vmml::matrix< R, I3, T >& W, vmml::matrix< R, I2 * I3, T >& temp ); //-> tensor outer product template< size_t R, typename TT > T tensor_inner_product( const vmml::vector< R, TT>& lambda, const vmml::matrix< I1, R, TT >& U, const vmml::matrix< I2, R, TT >& V, const vmml::matrix< I3, R, TT >& W ) const; //error computation double frobenius_norm() const; double frobenius_norm( const tensor3< I1, I2, I3, T >& other ) const; double avg_frobenius_norm() const; double rmse( const tensor3< I1, I2, I3, T >& other ) const; //root mean-squared error double compute_psnr( const tensor3< I1, I2, I3, T >& other, const T& max_value_ ) const; //peak signal-to-noise ratio template< typename TT > void cast_from( const tensor3< I1, I2, I3, TT >& other ); template< typename TT > void float_t_to_uint_t( const tensor3< I1, I2, I3, TT >& other ); void export_to( std::vector< T >& data_ ) const ; void import_from( const std::vector< T >& data_ ) ; void write_to_raw( const std::string& dir_, const std::string& filename_ ) const; void read_from_raw( const std::string& dir_, const std::string& filename_ ) ; void write_datfile( const std::string& dir_, const std::string& filename_ ) const; void write_to_csv( const std::string& dir_, const std::string& filename_ ) const; void remove_normals_from_raw( const std::string& dir_, const std::string& filename_ ) ; void remove_uct_cylinder( const size_t radius_offset_ ) ; inline tensor3 operator+( T scalar ) const; inline tensor3 operator-( T scalar ) const; void operator+=( T scalar ); void operator-=( T scalar ); inline tensor3 operator+( const tensor3& other ) const; inline tensor3 operator-( const tensor3& other ) const; void operator+=( const tensor3& other ); void operator-=( const tensor3& other ); // // tensor3-scalar operations / scaling // tensor3 operator*( T scalar ); void operator*=( T scalar ); // // matrix-vector operations // // transform column vector by matrix ( vec = matrix * vec ) vector< I1, T > operator*( const vector< I2, T >& other ) const; // transform column vector by matrix ( vec = matrix * vec ) // assume homogenous coords, e.g. vec3 = mat4x4 * vec3, with w = 1.0 template< size_t O > vector< O, T > operator*( const vector< O, T >& vector_ ) const; inline tensor3< I1, I2, I3, T > operator-() const; tensor3< I1, I2, I3, T > negate() const; friend std::ostream& operator << ( std::ostream& os, const tensor3< I1, I2, I3, T >& t3 ) { for(size_t i = 0; i < I3; ++i) { //os << t3.array[ i ] << "***" << std::endl; os << t3.get_frontal_slice_fwd( i ) << " *** " << std::endl; } return os; } // static members static void tensor3_allocate_data( T*& array_ ); static void tensor3_deallocate_data( T*& array_ ); static const tensor3< I1, I2, I3, T > ZERO; T* get_array_ptr(); const T* get_array_ptr() const; // computes the array index for direct access inline size_t compute_index( size_t i1, size_t i2, size_t i3 ) const; protected: front_slice_type& _get_slice( size_t index_ ); const front_slice_type& _get_slice( size_t index_ ) const; T* _array; }; // class tensor3 #define VMML_TEMPLATE_STRING template< size_t I1, size_t I2, size_t I3, typename T > #define VMML_TEMPLATE_CLASSNAME tensor3< I1, I2, I3, T > VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tensor3() : _array() { tensor3_allocate_data( _array ); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tensor3( const tensor3& source_ ) : _array() { tensor3_allocate_data( _array ); (*this) = source_; } VMML_TEMPLATE_STRING template< typename U > VMML_TEMPLATE_CLASSNAME::tensor3( const tensor3< I1, I2, I3, U >& source_ ) { tensor3_allocate_data( _array ); const U* s_array = source_.get_array_ptr(); for( size_t index = 0; index < I1 * I2 * I3; ++index ) { _array[ index ] = static_cast< T >( s_array[ index ] ); //_array[ index ] = static_cast< T >( source_._array[ index ] ); } } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > VMML_TEMPLATE_CLASSNAME::tensor3( const tensor3< J1, J2, J3, T >& source_ ) { const size_t minL = J1 < I1 ? J1 : I1; const size_t minC = J2 < I2 ? J2 : I2; const size_t minS = J3 < I3 ? J3 : I3; zero(); for ( size_t i = 0 ; i < minL ; i++ ) { for ( size_t j = 0 ; j < minC ; j++ ) { for ( size_t k = 0 ; k < minS ; k++ ) { at( i,j, k ) = source_( i, j, k ); } } } } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::~tensor3() { tensor3_deallocate_data( _array ); } VMML_TEMPLATE_STRING inline T& VMML_TEMPLATE_CLASSNAME::at( size_t i1, size_t i2, size_t i3 ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i1 >= I1 || i2 >= I2 || i3 >= I3 ) VMMLIB_ERROR( "at( i1, i2, i3 ) - index out of bounds", VMMLIB_HERE ); #endif //col_index * M + row_index return _array[ i3 * MATRIX_SIZE + i2 * ROWS + i1 ]; //return array[ i3 ].at( i1, i2 ); } VMML_TEMPLATE_STRING const inline T& VMML_TEMPLATE_CLASSNAME::at( size_t i1, size_t i2, size_t i3 ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i1 >= I1 || i2 >= I2 || i3 >= I3 ) VMMLIB_ERROR( "at( i1, i2, i3 ) - i3 index out of bounds", VMMLIB_HERE ); #endif return _array[ i3 * MATRIX_SIZE + i2 * ROWS + i1 ]; //return array[ i3 ].at( i1, i2 ); } VMML_TEMPLATE_STRING inline T& VMML_TEMPLATE_CLASSNAME::operator()( size_t i1, size_t i2, size_t i3 ) { return at( i1, i2, i3 ); } VMML_TEMPLATE_STRING const inline T& VMML_TEMPLATE_CLASSNAME::operator()( size_t i1, size_t i2, size_t i3 ) const { return at( i1, i2, i3 ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_I2_vector( size_t i1, size_t i3, vector< I2, T >& data ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "get_I1_vector() - i3 index out of bounds.", VMMLIB_HERE ); #endif _get_slice( i3 ).get_row( i1, data ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_I1_vector( size_t i2, size_t i3, vector< I1, T >& data ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "get_I2_vector() - i3 index out of bounds.", VMMLIB_HERE ); #endif _get_slice( i3 ).get_column( i2, data ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_I3_vector( size_t i1, size_t i2, vector< I3, T >& data ) const { for (size_t i3 = 0; i3 < I3; ++i3) { data[ i3 ] = _get_slice( i3 ).at( i1, i2 ); } } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_row( size_t i1, size_t i3, vector< I2, T >& data ) const { get_I2_vector( i1, i3, data ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_column( size_t i2, size_t i3, vector< I1, T >& data ) const { get_I1_vector( i2, i3, data ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_tube( size_t i1, size_t i2, vector< I3, T >& data ) const { get_I3_vector( i1, i2, data ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_I2_vector( size_t i1, size_t i3, const vector< I2, T >& data ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "set_I1_vector() - i3 index out of bounds.", VMMLIB_HERE ); #endif _get_slice( i3 ).set_row( i1, data ); //@SUS: bug fix } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_I1_vector( size_t i2, size_t i3, const vector< I1, T >& data ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "set_I2_vector() - i3 index out of bounds.", VMMLIB_HERE ); #endif _get_slice( i3 ).set_column( i2, data ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_I3_vector( size_t i1, size_t i2, const vector< I3, T >& data ) { for (size_t i3 = 0; i3 < I3; ++i3) { _get_slice( i3 ).at( i1, i2 ) = data[ i3 ]; } } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_row( size_t i1, size_t i3, const vector< I2, T >& data ) { set_I2_vector( i1, i3, data ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_column( size_t i2, size_t i3, const vector< I1, T >& data ) { set_I1_vector( i2, i3, data ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_tube( size_t i1, size_t i2, const vector< I3, T >& data ) { set_I3_vector( i1, i2, data ); } VMML_TEMPLATE_STRING inline typename VMML_TEMPLATE_CLASSNAME::front_slice_type& VMML_TEMPLATE_CLASSNAME:: get_frontal_slice_fwd( size_t i3 ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "get_frontal_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif return _get_slice( i3 ); } VMML_TEMPLATE_STRING inline const typename VMML_TEMPLATE_CLASSNAME::front_slice_type& VMML_TEMPLATE_CLASSNAME:: get_frontal_slice_fwd( size_t i3 ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "get_frontal_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif return _get_slice( i3 ); } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_frontal_slice_fwd( size_t i3, front_slice_type& data ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "get_frontal_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif data = _get_slice( i3 ); ; } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_lateral_slice_bwd( size_t i2, bwd_lat_slice_type& data ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i2 >= I2 ) VMMLIB_ERROR( "get_lateral_slice_bwd() - index out of bounds.", VMMLIB_HERE ); #endif for( size_t i3 = 0; i3 < I3; ++i3 ) { data.set_column( i3, _get_slice( i3 ).get_column( i2 )); } } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_horizontal_slice_fwd( size_t i1, horiz_slice_type& data ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i1 >= I1 ) VMMLIB_ERROR( "get_horizontal_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif for( size_t i3 = 0; i3 < I3; ++i3 ) { data.set_column( i3, _get_slice( i3 ).get_row( i1 )); //or for every i2 get/set column } } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_frontal_slice_bwd( size_t i3, bwd_front_slice_type& data ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "get_frontal_slice_bwd() - index out of bounds.", VMMLIB_HERE ); #endif front_slice_type* data_t = new front_slice_type(); *data_t = _get_slice( i3 ); data = transpose( *data_t ); delete data_t; } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_lateral_slice_fwd( size_t i2, lat_slice_type& data ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i2 >= I2 ) VMMLIB_ERROR( "get_lateral_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif bwd_lat_slice_type* data_t = new bwd_lat_slice_type(); for( size_t i3 = 0; i3 < I3; ++i3 ) { data_t->set_column( i3, _get_slice( i3 ).get_column( i2 )); } data = transpose( *data_t ); delete data_t; } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: get_horizontal_slice_bwd( size_t i1, bwd_horiz_slice_type& data ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( i1 >= I1 ) VMMLIB_ERROR( "get_horizontal_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif horiz_slice_type* data_t = new horiz_slice_type(); for( size_t i3 = 0; i3 < I3; ++i3 ) { data_t->set_column( i3, _get_slice( i3 ).get_row( i1 )); //or for every i2 get/set column } data = transpose( *data_t ); delete data_t; } //setter VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_frontal_slice_fwd( size_t i3, const front_slice_type& data ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "set_frontal_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif _get_slice( i3 ) = data; } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_lateral_slice_bwd( size_t i2, const bwd_lat_slice_type& data ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i2 >= I2 ) VMMLIB_ERROR( "set_lateral_slice_bwd() - index out of bounds.", VMMLIB_HERE ); #endif for( size_t i3 = 0; i3 < I3; ++i3 ) { _get_slice( i3 ).set_column(i2, data.get_column( i3 )); } } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_horizontal_slice_fwd( size_t i1, const horiz_slice_type& data ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i1 >= I1 ) VMMLIB_ERROR( "set_horizontal_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif for( size_t i3 = 0; i3 < I3; ++i3 ) { _get_slice( i3 ).set_row( i1, data.get_column( i3 )); } } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_frontal_slice_bwd( size_t i3, const bwd_front_slice_type& data ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i3 >= I3 ) VMMLIB_ERROR( "set_frontal_slice_bwd() - index out of bounds.", VMMLIB_HERE ); #endif front_slice_type* data_t = new front_slice_type(); *data_t = transpose( data ); _get_slice( i3 ) = *data_t; delete data_t; } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_lateral_slice_fwd( size_t i2, const lat_slice_type& data ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i2 >= I2 ) VMMLIB_ERROR( "set_lateral_slice_fwd() - index out of bounds.", VMMLIB_HERE ); #endif bwd_lat_slice_type* data_t = new bwd_lat_slice_type(); *data_t = transpose( data ); for( size_t i3 = 0; i3 < I3; ++i3 ) { _get_slice( i3 ).set_column(i2, data_t->get_column( i3 )); } delete data_t; } VMML_TEMPLATE_STRING inline void VMML_TEMPLATE_CLASSNAME:: set_horizontal_slice_bwd( size_t i1, const bwd_horiz_slice_type& data ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( i1 >= I1 ) VMMLIB_ERROR( "set_horizontal_slice_bwd() - index out of bounds.", VMMLIB_HERE ); #endif horiz_slice_type* data_t = new horiz_slice_type(); *data_t = transpose( data ); for( size_t i3 = 0; i3 < I3; ++i3 ) { _get_slice( i3 ).set_row( i1, data_t->get_column( i3 )); } delete data_t; } //fill VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: fill( T fillValue ) { for( size_t i3 = 0; i3 < I3; ++i3 ) { _get_slice( i3 ).fill( fillValue ); } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: fill_random( int seed ) { if ( seed >= 0 ) srand( seed ); double fillValue = 0.0f; for( size_t index = 0; index < I1 * I2 * I3; ++index ) { fillValue = rand(); fillValue /= RAND_MAX; fillValue *= std::numeric_limits< T >::max(); _array[ index ] = static_cast< T >( fillValue ) ; } #if 0 for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; ++i1 ) { for( size_t i2 = 0; i2 < I2; ++i2 ) { fillValue = rand(); fillValue /= RAND_MAX; fillValue *= std::numeric_limits< T >::max(); at( i1, i2, i3 ) = static_cast< T >( fillValue ) ; } } } #endif } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: fill_random_signed( int seed ) { if ( seed >= 0 ) srand( seed ); double fillValue = 0.0f; for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; ++i1 ) { for( size_t i2 = 0; i2 < I2; ++i2 ) { fillValue = rand(); fillValue /= RAND_MAX; fillValue *= std::numeric_limits< T >::max(); T fillValue2 = static_cast< T >(fillValue) % std::numeric_limits< T >::max(); fillValue2 -= std::numeric_limits< T >::max()/2; at( i1, i2, i3 ) = fillValue2 ; } } } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: fill_rand_sym( int seed ) { if ( seed >= 0 ) srand( seed ); assert(I1 == I2); assert(I1 == I3); double fillValue = 0.0f; T t_fill_value = 0; for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = i3; i1 < I1; ++i1 ) { for( size_t i2 = i1; i2 < I2; ++i2 ) { fillValue = rand(); fillValue /= RAND_MAX; fillValue *= std::numeric_limits< T >::max(); //add fillValue += 0.5; for rounding t_fill_value = static_cast< T >( fillValue ); at( i1, i2, i3 ) = t_fill_value; if ( i1 != i2 || i1 != i3 || i2 != i3 ) { if ( i1 != i2 ) at( i2, i1, i3 ) = t_fill_value; if (i2 != i3 ) at( i1, i3, i2 ) = t_fill_value; if ( i1 != i3 ) at( i3, i2, i1 ) = t_fill_value; if ( i1 != i2 && i1 != i3 && i2 != i3 ) { at( i2, i3, i1 ) = t_fill_value; at( i3, i1, i2 ) = t_fill_value; } } } } } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: fill_rand_sym_slices( int seed ) { if ( seed >= 0 ) srand( seed ); assert(I1 == I2); double fillValue = 0.0f; for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; ++i1 ) { for( size_t i2 = i1; i2 < I2; ++i2 ) { fillValue = rand(); fillValue /= RAND_MAX; fillValue *= std::numeric_limits< T >::max(); at( i1, i2, i3 ) = static_cast< T >( fillValue ); at( i2, i1, i3 ) = static_cast< T >( fillValue ); } } } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: fill_increasing_values( ) { double fillValue = 0.0f; for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; ++i1 ) { for( size_t i2 = 0; i2 < I2; ++i2 ) { at( i1, i2, i3 ) = static_cast< T >( fillValue ); fillValue++; } } } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::range_threshold(tensor3& other_, const T& start_value, const T& end_value) const { for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; ++i1 ) { for( size_t i2 = 0; i2 < I2; ++i2 ) { T value = at( i1, i2, i3 ); if (value >= start_value && value <= end_value) other_.at(i1, i2, i3 ) = static_cast< T >( value ); } } } } VMML_TEMPLATE_STRING template< size_t R> typename enable_if< R == I1 && R == I2 && R == I3>::type* VMML_TEMPLATE_CLASSNAME::diag( const vector< R, T >& diag_values_ ) { zero(); for( size_t r = 0; r < R; ++r ) { at(r, r, r) = static_cast< T >( diag_values_.at(r) ); } return 0; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::zero() { fill( static_cast< T >( 0.0 ) ); } VMML_TEMPLATE_STRING bool VMML_TEMPLATE_CLASSNAME::operator==( const tensor3< I1, I2, I3, T >& other ) const { bool ok = true; for( size_t index = 0; index < I1 * I2 * I3; ++index ) { if ( _array[ index ] != other._array[ index ] ) return false; } return true; #if 0 for( size_t i3 = 0; ok && i3 < I3; ++i3 ) { ok = array[ i3 ] == other.array[ i3 ]; } #endif return ok; } VMML_TEMPLATE_STRING bool VMML_TEMPLATE_CLASSNAME::operator!=( const tensor3< I1, I2, I3, T >& other ) const { return ! operator==( other ); } VMML_TEMPLATE_STRING bool equals( const tensor3< I1, I2, I3, T >& t3_0, const tensor3< I1, I2, I3, T >& t3_1, T tolerance ) { return t3_0.equals( t3_1, tolerance ); } VMML_TEMPLATE_STRING bool VMML_TEMPLATE_CLASSNAME::equals( const tensor3< I1, I2, I3, T >& other, T tolerance ) const { bool ok = true; for (size_t i3 = 0; ok && i3 < I3; ++i3 ) { ok = _get_slice( i3 ).equals( other.get_frontal_slice_fwd( i3 ), tolerance ); } return ok; } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::size() const { return I1 * I2 * I3; } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > tensor3 VMML_TEMPLATE_CLASSNAME:: get_sub_tensor3( size_t row_offset, size_t col_offset, size_t slice_offset, typename enable_if< J1 <= I1 && J2 <= I2 && J3 <= I3 >::type* ) const { tensor3< J1, J2, J3, T > result; get_sub_tensor3( result, row_offset, col_offset, slice_offset ); return result; } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > typename enable_if< J1 <= I1 && J2 <= I2 && J3 <= I3 >::type* VMML_TEMPLATE_CLASSNAME:: get_sub_tensor3( tensor3& result, size_t row_offset, size_t col_offset, size_t slice_offset ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( J1 + row_offset > I1 || J2 + col_offset > I2 || J3 + slice_offset > I3 ) VMMLIB_ERROR( "index out of bounds.", VMMLIB_HERE ); #endif for( size_t slice = 0; slice < J3; ++slice ) { for( size_t row = 0; row < J1; ++row ) { for( size_t col = 0; col < J2; ++col ) { result.at( row, col, slice ) = at( row_offset + row, col_offset + col, slice_offset + slice ); } } } return 0; } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > typename enable_if< J1 <= I1 && J2 <= I2 && J3 <= I3 >::type* VMML_TEMPLATE_CLASSNAME:: set_sub_tensor3( const tensor3& sub_data_, size_t row_offset, size_t col_offset, size_t slice_offset ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( J1 + row_offset > I1 || J2 + col_offset > I2 || J3 + slice_offset > I3 ) VMMLIB_ERROR( "index out of bounds.", VMMLIB_HERE ); #endif for( size_t slice = 0; slice < J3; ++slice ) { for( size_t row = 0; row < J1; ++row ) { for( size_t col = 0; col < J2; ++col ) { at( row_offset + row, col_offset + col, slice_offset + slice ) = sub_data_.at( row, col, slice ) ; } } } return 0; } VMML_TEMPLATE_STRING typename VMML_TEMPLATE_CLASSNAME::iterator VMML_TEMPLATE_CLASSNAME::begin() { return iterator( *this, true ); } VMML_TEMPLATE_STRING typename VMML_TEMPLATE_CLASSNAME::iterator VMML_TEMPLATE_CLASSNAME::end() { return iterator( *this, false ); } VMML_TEMPLATE_STRING typename VMML_TEMPLATE_CLASSNAME::const_iterator VMML_TEMPLATE_CLASSNAME::begin() const { return const_iterator( *this, true ); } VMML_TEMPLATE_STRING typename VMML_TEMPLATE_CLASSNAME::const_iterator VMML_TEMPLATE_CLASSNAME::end() const { return const_iterator( *this, false ); } VMML_TEMPLATE_STRING template< typename input_iterator_t > void VMML_TEMPLATE_CLASSNAME::set( input_iterator_t begin_, input_iterator_t end_, bool row_major_layout ) { input_iterator_t it( begin_ ); if( row_major_layout ) { for ( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; ++i1 ) { for( size_t i2 = 0; i2 < I2; ++i2, ++it ) { if ( it == end_ ) return; at( i1, i2, i3 ) = static_cast< T >( *it ); } } } } else { std::copy( it, it + ( I1 * I2 * I3 ), begin() ); } } VMML_TEMPLATE_STRING inline VMML_TEMPLATE_CLASSNAME VMML_TEMPLATE_CLASSNAME::operator+( const tensor3< I1, I2, I3, T >& other ) const { tensor3< I1, I2, I3, T > result( *this ); result += other; return result; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::operator+=( const tensor3< I1, I2, I3, T >& other ) { iterator it = begin(), it_end = end(); const_iterator other_it = other.begin(); for( ; it != it_end; ++it, ++other_it ) { *it += *other_it; } } VMML_TEMPLATE_STRING inline VMML_TEMPLATE_CLASSNAME VMML_TEMPLATE_CLASSNAME::operator-( const tensor3< I1, I2, I3, T >& other ) const { tensor3< I1, I2, I3, T > result( *this ); result -= other; return result; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::operator-=( const tensor3< I1, I2, I3, T >& other ) { iterator it = begin(), it_end = end(); const_iterator other_it = other.begin(); for( ; it != it_end; ++it, ++other_it ) { *it -= *other_it; } } //sum with scalar VMML_TEMPLATE_STRING inline VMML_TEMPLATE_CLASSNAME VMML_TEMPLATE_CLASSNAME::operator+( T scalar ) const { tensor3< I1, I2, I3, T > result( *this ); result += scalar; return result; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::operator+=( T scalar ) { iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) { *it += scalar; } } VMML_TEMPLATE_STRING inline VMML_TEMPLATE_CLASSNAME VMML_TEMPLATE_CLASSNAME::operator-( T scalar ) const { tensor3< I1, I2, I3, T > result( *this ); result -= scalar; return result; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::operator-=( T scalar ) { iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) { *it -= scalar; } } //tensor matrix multiplications VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > void VMML_TEMPLATE_CLASSNAME::multiply_horizontal_bwd( const tensor3< J1, J2, J3, T >& other, const matrix< I3, J3, T >& other_slice_ ) { matrix< J3, J2, T >* slice = new matrix< J3, J2, T >; matrix< I3, J2, T >* slice_new = new matrix< I3, J2, T >; blas_dgemm< I3, J3, J2, T_blas >* blas_dgemm1 = new blas_dgemm< I3, J3, J2, T_blas >; matrix< J3, J2, T_blas >* slice_blas = new matrix< J3, J2, T_blas >; matrix< I3, J2, T_blas >* slice_new_blas = new matrix< I3, J2, T_blas >; matrix< I3, J3, T_blas >* other_slice_blas = new matrix< I3, J3, T_blas >; other_slice_blas->cast_from( other_slice_ ); for ( size_t i1 = 0; i1 < J1; ++i1 ) { other.get_horizontal_slice_bwd( i1, *slice ); slice_blas->cast_from( *slice ); blas_dgemm1->compute( *other_slice_blas, *slice_blas, *slice_new_blas ); slice_new->cast_from( *slice_new_blas ); //slice_new->multiply( other_slice_, *slice ); set_horizontal_slice_bwd( i1, *slice_new ); } delete blas_dgemm1; delete slice; delete slice_new; delete slice_blas; delete slice_new_blas; delete other_slice_blas; } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > void VMML_TEMPLATE_CLASSNAME::multiply_lateral_bwd( const tensor3< J1, J2, J3, T >& other, const matrix< I1, J1, T >& other_slice_ ) { matrix< J1, J3, T>* slice = new matrix< J1, J3, T>(); matrix< I1, J3, T>* slice_new = new matrix< I1, J3, T>(); blas_dgemm< I1, J1, J3, T_blas >* blas_dgemm1 = new blas_dgemm< I1, J1, J3, T_blas >; matrix< J1, J3, T_blas >* slice_blas = new matrix< J1, J3, T_blas >; matrix< I1, J3, T_blas >* slice_new_blas = new matrix< I1, J3, T_blas >; matrix< I1, J1, T_blas >* other_slice_blas = new matrix< I1, J1, T_blas >; other_slice_blas->cast_from( other_slice_ ); for ( size_t i2 = 0; i2 < J2; ++i2 ) { other.get_lateral_slice_bwd( i2, *slice ); slice_blas->cast_from( *slice ); blas_dgemm1->compute( *other_slice_blas, *slice_blas, *slice_new_blas ); slice_new->cast_from( *slice_new_blas ); //slice_new->multiply( other_slice_, *slice ); set_lateral_slice_bwd( i2, *slice_new ); } delete blas_dgemm1; delete slice; delete slice_new; delete slice_blas; delete slice_new_blas; delete other_slice_blas; } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > void VMML_TEMPLATE_CLASSNAME::multiply_frontal_bwd( const tensor3< J1, J2, J3, T >& other, const matrix< I2, J2, T >& other_slice_ ) { matrix< J2, J1, T>* slice = new matrix< J2, J1, T>(); matrix< I2, J1, T>* slice_new = new matrix< I2, J1, T>(); blas_dgemm< I2, J2, J1, T_blas >* blas_dgemm1 = new blas_dgemm< I2, J2, J1, T_blas >; matrix< J2, J1, T_blas >* slice_blas = new matrix< J2, J1, T_blas >; matrix< I2, J1, T_blas >* slice_new_blas = new matrix< I2, J1, T_blas >; matrix< I2, J2, T_blas >* other_slice_blas = new matrix< I2, J2, T_blas >; other_slice_blas->cast_from( other_slice_ ); for ( size_t i3 = 0; i3 < J3; ++i3 ) { other.get_frontal_slice_bwd( i3, *slice ); slice_blas->cast_from( *slice ); blas_dgemm1->compute( *other_slice_blas, *slice_blas, *slice_new_blas ); slice_new->cast_from( *slice_new_blas ); //slice_new->multiply( other_slice_, *slice ); set_frontal_slice_bwd( i3, *slice_new ); } delete blas_dgemm1; delete slice; delete slice_new; delete slice_blas; delete slice_new_blas; delete other_slice_blas; } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > void VMML_TEMPLATE_CLASSNAME::full_tensor3_matrix_multiplication( const tensor3< J1, J2, J3, T >& core, const matrix< I1, J1, T >& U1, const matrix< I2, J2, T >& U2, const matrix< I3, J3, T >& U3 ) { tensor3< I1, J2, J3, T> t3_result_1; tensor3< I1, I2, J3, T> t3_result_2; //backward cyclic matricization/unfolding (after Lathauwer et al., 2000a) t3_result_1.multiply_lateral_bwd( core, U1 ); t3_result_2.multiply_frontal_bwd( t3_result_1, U2 ); multiply_horizontal_bwd( t3_result_2, U3 ); } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3 > void VMML_TEMPLATE_CLASSNAME::full_tensor3_matrix_kronecker_mult( const tensor3< J1, J2, J3, T >& core, const matrix< I1, J1, T >& U1, const matrix< I2, J2, T >& U2, const matrix< I3, J3, T >& U3 ) { matrix< J1, J2*J3, T>* core_unfolded = new matrix< J1, J2*J3, T>(); core.lateral_unfolding_bwd( *core_unfolded ); matrix< I1, J2*J3, T>* tmp1 = new matrix< I1, J2*J3, T>(); tmp1->multiply( U1, *core_unfolded ); matrix< I2*I3, J2*J3, T>* kron_prod = new matrix< I2*I3, J2*J3, T>(); U2.kronecker_product( U3, *kron_prod ); matrix< I1, I2*I3, T>* res_unfolded = new matrix< I1, I2*I3, T>(); res_unfolded->multiply( *tmp1, transpose(*kron_prod) ); //std::cout << "reco2 result (matricized): " << std::endl << *res_unfolded << std::endl; //set this from res_unfolded size_t i2 = 0; for( size_t i = 0; i < (I2*I3); ++i, ++i2 ) { if (i2 >= I2) { i2 = 0; } size_t i3 = i % I3; set_column( i2, i3, res_unfolded->get_column(i)); } delete core_unfolded; delete kron_prod; delete tmp1; delete res_unfolded; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::horizontal_unfolding_bwd( bwd_horiz_unfolding_type& unfolding) const { bwd_horiz_slice_type* horizontal_slice = new bwd_horiz_slice_type(); for( size_t i = 0; i < I1; ++i ) { get_horizontal_slice_bwd(i, *horizontal_slice ); for( size_t col = 0; col < I2; ++col ) { unfolding.set_column( i*I2+col, horizontal_slice->get_column(col)); } } delete horizontal_slice; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::horizontal_unfolding_fwd( fwd_horiz_unfolding_type& unfolding) const { horiz_slice_type* horizontal_slice = new horiz_slice_type(); for( size_t i = 0; i < I1; ++i ) { get_horizontal_slice_fwd(i, *horizontal_slice ); for( size_t col = 0; col < I3; ++col ) { unfolding.set_column( i*I3+col, horizontal_slice->get_column(col)); } } delete horizontal_slice; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::lateral_unfolding_bwd( bwd_lat_unfolding_type& unfolding) const { bwd_lat_slice_type* lateral_slice = new bwd_lat_slice_type(); for( size_t i = 0; i < I2; ++i ) { get_lateral_slice_bwd(i, *lateral_slice ); for( size_t col = 0; col < I3; ++col ) { unfolding.set_column( i*I3+col, lateral_slice->get_column(col)); } } delete lateral_slice; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::lateral_unfolding_fwd( fwd_lat_unfolding_type& unfolding) const { lat_slice_type* lateral_slice = new lat_slice_type(); for( size_t i = 0; i < I2; ++i ) { get_lateral_slice_fwd(i, *lateral_slice ); for( size_t col = 0; col < I1; ++col ) { unfolding.set_column( i*I1+col, lateral_slice->get_column(col)); } } delete lateral_slice; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::frontal_unfolding_bwd( bwd_front_unfolding_type& unfolding) const { bwd_front_slice_type* frontal_slice = new bwd_front_slice_type(); for( size_t i = 0; i < I3; ++i ) { get_frontal_slice_bwd(i, *frontal_slice ); for( size_t col = 0; col < I1; ++col ) { unfolding.set_column( i*I1+col, frontal_slice->get_column(col)); } } delete frontal_slice; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::frontal_unfolding_fwd( fwd_front_unfolding_type& unfolding) const { front_slice_type* frontal_slice = new front_slice_type(); for( size_t i = 0; i < I3; ++i ) { get_frontal_slice_fwd(i, *frontal_slice ); for( size_t col = 0; col < I2; ++col ) { unfolding.set_column( i*I2+col, frontal_slice->get_column(col)); } } delete frontal_slice; } VMML_TEMPLATE_STRING tensor3< I1, I2, I3, T > VMML_TEMPLATE_CLASSNAME::operator*( T scalar ) { tensor3< I1, I2, I3, T > result; for( size_t index = 0; index < I1 * I2 * I3; ++index ) { result._array[ index ] = _array[ index ] * scalar; } #if 0 tensor3< I1, I2, I3, T >* result = (*this); for( size_t i3 = 0; i3 < I3; ++i3 ) { result.array[ i3 ] = array[ i3 ] * scalar; } return *result; #endif } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::operator*=( T scalar ) { for( size_t index = 0; index < I1 * I2 * I3; ++index ) { _array[ index ] *= scalar; } #if 0 for( size_t i3 = 0; i3 < I3; ++i3 ) { array[ i3 ] *= scalar; } #endif } VMML_TEMPLATE_STRING inline tensor3< I1, I2, I3, T > VMML_TEMPLATE_CLASSNAME::operator-() const { return negate(); } VMML_TEMPLATE_STRING tensor3< I1, I2, I3, T > VMML_TEMPLATE_CLASSNAME::negate() const { tensor3< I1, I2, I3, T > result; result *= -1.0; return result; } VMML_TEMPLATE_STRING double VMML_TEMPLATE_CLASSNAME::frobenius_norm( const tensor3< I1, I2, I3, T>& other_ ) const { double f_norm = 0.0; T abs_diff = 0; const_iterator it = begin(), it_end = end(); const_iterator it_other = other_.begin(); for( ; it != it_end; ++it, ++it_other ) { abs_diff = fabs( *it ) - fabs( *it_other ); f_norm += abs_diff * abs_diff; } return sqrt(f_norm); } VMML_TEMPLATE_STRING double VMML_TEMPLATE_CLASSNAME::frobenius_norm( ) const { double f_norm = 0.0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) f_norm += *it * *it; return sqrt(f_norm); } VMML_TEMPLATE_STRING double VMML_TEMPLATE_CLASSNAME::avg_frobenius_norm( ) const { double af_norm = 0.0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) af_norm += *it * *it; af_norm /= size(); return sqrt(af_norm); } VMML_TEMPLATE_STRING double VMML_TEMPLATE_CLASSNAME::rmse( const tensor3< I1, I2, I3, T >& other ) const { double mse = 0.0; double diff = 0.0; const_iterator it = begin(), it_end = end(); const_iterator other_it = other.begin(), other_it_end = other.end(); for( ; it != it_end; ++it, ++other_it ){ diff = abs( *it ) - abs( *other_it ); mse += diff * diff; } return sqrt(mse/size()); } VMML_TEMPLATE_STRING double VMML_TEMPLATE_CLASSNAME::compute_psnr( const tensor3< I1, I2, I3, T >& other, const T& max_value_ ) const { double rmse_val = rmse( other ); double psnr_val = log( max_value_ / rmse_val ); psnr_val *= 20; return fabs(psnr_val); } VMML_TEMPLATE_STRING template< typename TT > void VMML_TEMPLATE_CLASSNAME::cast_from( const tensor3< I1, I2, I3, TT >& other ) { typedef tensor3< I1, I2, I3, TT > t3_tt_type ; typedef typename t3_tt_type::const_iterator tt_const_iterator; iterator it = begin(), it_end = end(); tt_const_iterator other_it = other.begin(); for( ; it != it_end; ++it, ++other_it ) { *it = static_cast< T >( *other_it ); } } VMML_TEMPLATE_STRING template< typename TT > void VMML_TEMPLATE_CLASSNAME::float_t_to_uint_t( const tensor3< I1, I2, I3, TT >& other ) { typedef tensor3< I1, I2, I3, TT > t3_tt_type ; typedef typename t3_tt_type::const_iterator tt_const_iterator; if( sizeof(T) == 1 || sizeof(T) == 2) { iterator it = begin(), it_end = end(); tt_const_iterator other_it = other.begin(); for( ; it != it_end; ++it, ++other_it ) { *it = T( std::min( std::max(int(0), int( *other_it + 0.5)), int(std::numeric_limits< T >::max()) )); } } else { //std::cout << "Warning: use a different type as target (uint8 or uint16). No converstion done.\n" << std::endl; this->cast_from( other ); return; } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::export_to( std::vector< T >& data_ ) const { data_.clear(); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) { data_.push_back( *it ); } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::import_from( const std::vector< T >& data_ ) { size_t i = 0; //iterator over data_ size_t input_size = data_.size(); iterator it = begin(), it_end = end(); for( ; it != it_end; ++it, ++i ) { if ( i >= input_size) *it = static_cast (0); else *it = data_.at( i ); } } VMML_TEMPLATE_STRING T VMML_TEMPLATE_CLASSNAME::get_min() const { T tensor3_min = static_cast(std::numeric_limits::max()); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( *it < tensor3_min ) { tensor3_min = *it; } } return tensor3_min; } VMML_TEMPLATE_STRING T VMML_TEMPLATE_CLASSNAME::get_max() const { T tensor3_max = static_cast(0); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( *it > tensor3_max ) { tensor3_max = *it; } } return tensor3_max; } VMML_TEMPLATE_STRING T VMML_TEMPLATE_CLASSNAME::get_abs_min() const { T tensor3_min = static_cast(std::numeric_limits::max()); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( fabs(*it) < fabs(tensor3_min) ) { tensor3_min = fabs(*it); } } return tensor3_min; } VMML_TEMPLATE_STRING T VMML_TEMPLATE_CLASSNAME::get_abs_max() const { T tensor3_max = static_cast(0); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( fabs(*it) > fabs(tensor3_max) ) { tensor3_max = fabs(*it); } } return tensor3_max; } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz() const { size_t counter = 0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( *it != 0 ) { ++counter; } } return counter; } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz( const T& threshold_ ) const { size_t counter = 0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( fabs(*it) > threshold_ ) { ++counter; } } return counter; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::threshold( const T& threshold_value_ ) { iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( fabs(*it) <= threshold_value_ ) { *it = static_cast (0); } } } VMML_TEMPLATE_STRING template< typename TT > void VMML_TEMPLATE_CLASSNAME::quantize_to( tensor3< I1, I2, I3, TT >& quantized_, const T& min_value_, const T& max_value_ ) const { long max_tt_range = long(std::numeric_limits< TT >::max()); long min_tt_range = long(std::numeric_limits< TT >::min()); long tt_range = (max_tt_range - min_tt_range); T t_range = max_value_ - min_value_; typedef tensor3< I1, I2, I3, TT > t3_tt_type ; typedef typename t3_tt_type::iterator tt_iterator; tt_iterator it_quant = quantized_.begin(); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it, ++it_quant ) { if (std::numeric_limits::is_signed ) { *it_quant = TT( std::min( std::max( min_tt_range, long(( *it * tt_range / t_range ) + 0.5)), max_tt_range )); } else { *it_quant = TT( std::min( std::max( min_tt_range, long(((*it - min_value_ ) * tt_range / t_range) + 0.5)), max_tt_range )); } } } VMML_TEMPLATE_STRING template< typename TT > void VMML_TEMPLATE_CLASSNAME::quantize( tensor3< I1, I2, I3, TT >& quantized_, T& min_value_, T& max_value_ ) const { min_value_= get_min(); max_value_ = get_max(); quantize_to( quantized_, min_value_, max_value_ ); } VMML_TEMPLATE_STRING template< typename TT > void VMML_TEMPLATE_CLASSNAME::quantize_log( tensor3< I1, I2, I3, TT >& quantized_, tensor3< I1, I2, I3, char >& signs_, T& min_value_, T& max_value_, const TT& tt_range_ ) const { long max_tt_range = long(tt_range_); long min_tt_range = 0; min_value_ = get_abs_min(); max_value_ = get_abs_max(); T t_range = max_value_ - min_value_; typedef tensor3< I1, I2, I3, TT > t3_tt_type ; typedef typename t3_tt_type::iterator tt_iterator; tt_iterator it_quant = quantized_.begin(); const_iterator it = begin(), it_end = end(); typedef tensor3< I1, I2, I3, char > t3_sign_type ; typedef typename t3_sign_type::iterator sign_iterator; sign_iterator it_sign = signs_.begin(); for( ; it != it_end; ++it, ++it_quant, ++it_sign ) { T value = fabs(*it); *it_sign = ((*it) < 0.f) ? 0 : 1; T quant_value = 0; if (std::numeric_limits::is_signed ) { quant_value = log2( 1 + value) / log2(1 + t_range ) * tt_range_; *it_quant = TT( std::min( std::max( min_tt_range, long(quant_value + 0.5)), max_tt_range )); } else { quant_value = log2( 1 + (value - min_value_ )) / log2(1 + t_range ) * tt_range_; *it_quant = TT(std::min( std::max( min_tt_range, long(quant_value + 0.5)), max_tt_range )); } } } VMML_TEMPLATE_STRING template< typename TT > void VMML_TEMPLATE_CLASSNAME::dequantize_log( tensor3< I1, I2, I3, TT >& dequantized_, const tensor3< I1, I2, I3, char >& signs_, const TT& min_value_, const TT& max_value_ ) const { T max_t_range = get_max(); T min_t_range = get_min(); long t_range = long(max_t_range) - long(min_t_range); TT tt_range = max_value_ - min_value_; typedef tensor3< I1, I2, I3, TT > t3_tt_type ; typedef typename t3_tt_type::iterator tt_iterator; tt_iterator it_dequant = dequantized_.begin(); const_iterator it = begin(), it_end = end(); typedef tensor3< I1, I2, I3, char > t3_sign_type ; typedef typename t3_sign_type::const_iterator sign_iterator; sign_iterator it_sign = signs_.begin(); float sign = 0; for( ; it != it_end; ++it, ++it_dequant, ++it_sign ) { TT value = TT(*it); TT dequant_value = 0; sign = ((*it_sign) == 0) ? -1 : 1; if (std::numeric_limits::is_signed ) { dequant_value = exp2( (value / t_range) * log2(1 + tt_range)) - 1; *it_dequant = sign * (std::min( std::max( min_value_, dequant_value ), max_value_ )); } else { dequant_value = exp2( (value / t_range) * log2(1 + tt_range)) - 1; *it_dequant = sign * (std::min( std::max( min_value_, dequant_value + min_value_ ), max_value_ )); } } } VMML_TEMPLATE_STRING template< typename TT > void VMML_TEMPLATE_CLASSNAME::dequantize( tensor3< I1, I2, I3, TT >& dequantized_, const TT& min_value_, const TT& max_value_ ) const { T max_t_range = get_max(); T min_t_range = get_min(); long t_range = long(max_t_range) - long(min_t_range); TT tt_range = max_value_ - min_value_; typedef tensor3< I1, I2, I3, TT > t3_tt_type ; typedef typename t3_tt_type::iterator tt_iterator; tt_iterator it_dequant = dequantized_.begin(); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it, ++it_dequant ) { if (std::numeric_limits::is_signed ) { *it_dequant = std::min( std::max( min_value_, TT((TT(*it) / t_range) * tt_range)), max_value_ ); } else { *it_dequant = std::min( std::max( min_value_, TT((((TT(*it) / t_range)) * tt_range ) + min_value_ )), max_value_ ); } } } VMML_TEMPLATE_STRING const VMML_TEMPLATE_CLASSNAME& VMML_TEMPLATE_CLASSNAME::operator=( const VMML_TEMPLATE_CLASSNAME& source_ ) { memcpy( _array, source_._array, I1 * I2 * I3 * sizeof( T ) ); return *this; } #if 0 std::string format_path( const std::string& dir_, const std::string& filename_, const std::string& format_ ) { std::string path = dir_; int dir_length = dir_.size() -1; int last_separator = dir_.find_last_of( "/"); std::string path = dir_; if (last_separator < dir_length ) { path.append( "/" ); } path.append( filename_ ); //check for format if( filename_.find( format_, filename_.size() -3) == (-1)) { path.append( "."); path.append( format_ ); } return path; } #endif VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::write_to_raw( const std::string& dir_, const std::string& filename_ ) const { int dir_length = dir_.size() -1; int last_separator = dir_.find_last_of( "/"); std::string path = dir_; if (last_separator < dir_length ) { path.append( "/" ); } path.append( filename_ ); //check for format if( filename_.find( "raw", filename_.size() -3) == (-1)) { path.append( "."); path.append( "raw" ); } std::string path_raw = path; std::ofstream outfile; outfile.open( path_raw.c_str() ); if( outfile.is_open() ) { size_t len_slice = sizeof(T) * I1 * I2; for( size_t index = 0; index < I3; ++index ) { outfile.write( (char*)&(get_frontal_slice_fwd( index )), len_slice ); } outfile.close(); } else { std::cout << "no file open" << std::endl; } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::write_to_csv( const std::string& dir_, const std::string& filename_ ) const { int dir_length = dir_.size() -1; int last_separator = dir_.find_last_of( "/"); std::string path = dir_; if (last_separator < dir_length ) { path.append( "/" ); } path.append( filename_ ); //check for format if( filename_.find( "csv", filename_.size() -3) == (-1)) { path.append( "."); path.append( "csv" ); } std::ofstream outfile; outfile.open( path.c_str() ); if( outfile.is_open() ) { for(size_t i = 0; i < I3; ++i) { outfile << get_frontal_slice_fwd( i ) << std::endl; } outfile.close(); } else { std::cout << "no file open" << std::endl; } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::write_datfile( const std::string& dir_, const std::string& filename_ ) const { int dir_length = dir_.size() -1; int last_separator = dir_.find_last_of( "/"); std::string path = dir_; if (last_separator < dir_length ) { path.append( "/" ); } std::string filename = ""; int pos = filename_.size() -4; if( ( filename_.find(".raw", pos ) == pos) || ( filename_.find(".dat", pos ) == pos) ) { filename = filename_.substr(0, filename_.size() -4); } else { filename = filename_; } path.append( filename ); //check for format if( filename_.find( "dat", filename_.size() -3) == (-1)) { path.append( "."); path.append( "dat" ); } std::string path_dat = path; const char* format = (sizeof(T) == 2) ? "USHORT": "UCHAR"; FILE* datfile = fopen(path_dat.c_str(), "w"); fprintf(datfile, "ObjectFileName:\t%s.raw\n", filename.c_str()); fprintf(datfile, "TaggedFileName:\t---\nResolution:\t%i %i %i\n", I1, I2, I3); fprintf(datfile, "SliceThickness:\t1.0 1.0 1.0\n"); fprintf(datfile, "Format:\t%s\nNbrTags:\t0\n", format); fprintf(datfile, "ObjectType:\tTEXTURE_VOLUME_OBJECT\nObjectModel:\tI\nGridType:\tEQUIDISTANT\n"); fprintf(datfile, "Modality:\tunknown\nTimeStep:\t0\n"); fclose(datfile); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::read_from_raw( const std::string& dir_, const std::string& filename_ ) { int dir_length = dir_.size() -1; int last_separator = dir_.find_last_of( "/"); std::string path = dir_; if (last_separator < dir_length ) { path.append( "/" ); } path.append( filename_ ); size_t max_file_len = 2147483648u - sizeof(T) ; size_t len_data = sizeof(T) * SIZE; size_t len_read = 0; char* data = new char[ len_data ]; std::ifstream infile; infile.open( path.c_str(), std::ios::in); if( infile.is_open()) { iterator it = begin(), it_end = end(); while ( len_data > 0 ) { len_read = (len_data % max_file_len ) > 0 ? len_data % max_file_len : len_data; len_data -= len_read; infile.read( data, len_read ); T* T_ptr = (T*)&(data[0]); for( ; (it != it_end) && (len_read > 0); ++it, len_read -= sizeof(T) ) { *it = *T_ptr; ++T_ptr; } } delete[] data; infile.close(); } else { std::cout << "no file open" << std::endl; } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::remove_normals_from_raw( const std::string& dir_, const std::string& filename_ ) { int dir_length = dir_.size() -1; int last_separator = dir_.find_last_of( "/"); std::string path = dir_; if (last_separator < dir_length ) { path.append( "/" ); } path.append( filename_ ); size_t max_file_len = 2147483648u - sizeof(T) ; size_t len_data = sizeof(T) * SIZE; size_t len_value = sizeof(T) * 4; //three normals per scalar value size_t len_read = 0; char* data = new char[ len_data ]; std::ifstream infile; infile.open( path.c_str(), std::ios::in); if( infile.is_open()) { iterator it = begin(), it_end = end(); size_t counter = 0; while ( len_data > 0 ) { len_read = (len_data % max_file_len ) > 0 ? len_data % max_file_len : len_data; len_data -= len_read; infile.read( data, len_read ); T* T_ptr = (T*)&(data[0]); for( ; (it != it_end) && (len_read > 0); ++it, len_read -= len_value ) { ++T_ptr; ++T_ptr; ++T_ptr; *it = *T_ptr; ++T_ptr; ++counter; } } delete[] data; infile.close(); } else { std::cout << "no file open" << std::endl; } std::cout << "converted normals" << std::endl; std::string filename = ""; filename = filename_.substr(0, filename_.size() -6); write_datfile( ".", filename ); write_to_raw( ".", filename ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::remove_uct_cylinder( const size_t radius_offset_ ) { double length = 0; double radius = (I1-1.0)/2.0 - radius_offset_; radius *= radius; double k1 = 0; double k2 = 0; for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; i1++ ) { k1 = i1 - (I1-1.0)/2.0; for( size_t i2 = 0; i2 < I2; i2++ ) { k2 = i2 - (I2-1.0)/2.0; length = k1*k1 + k2*k2 ; if ( length >= radius ) { at( i1, i2, i3 ) = static_cast ( 0.0 ); } } } } } VMML_TEMPLATE_STRING vmml::matrix< I1, I2, T >& VMML_TEMPLATE_CLASSNAME:: _get_slice( size_t index_ ) { typedef matrix< I1, I2, T > matrix_type; return *reinterpret_cast< matrix_type* >( _array + I1 * I2 * index_ ); } VMML_TEMPLATE_STRING const vmml::matrix< I1, I2, T >& VMML_TEMPLATE_CLASSNAME:: _get_slice( size_t index_ ) const { typedef matrix< I1, I2, T > matrix_type; return *reinterpret_cast< const matrix_type* >( _array + I1 * I2 * index_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: tensor3_allocate_data( T*& array_ ) { array_ = new T[ I1 * I2 * I3]; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: tensor3_deallocate_data( T*& array_ ) { delete[] array_; } VMML_TEMPLATE_STRING T* VMML_TEMPLATE_CLASSNAME::get_array_ptr() { return _array; } VMML_TEMPLATE_STRING const T* VMML_TEMPLATE_CLASSNAME::get_array_ptr() const { return _array; } VMML_TEMPLATE_STRING template< size_t R > void VMML_TEMPLATE_CLASSNAME:: reconstruct_CP( const vmml::vector< R, T>& lambda, vmml::matrix< R, I1, T >& U, const vmml::matrix< R, I2, T >& V, const vmml::matrix< R, I3, T >& W, vmml::matrix< R, I2 * I3, T >& temp ) { for (size_t j = 0; j < I2; j++) { for (size_t k = 0; k < I3; k++) { for (size_t r = 0; r < R; r++) { temp(r, j + k * I2) = V(r, j) * W(r, k); } } } for (size_t i = 0; i < I1; i++) { for (size_t r = 0; r < R; r++) { U(r, i) = lambda[r] * U(r, i); } } vector< R, T > ui; vector< R, T > tmpi; blas_dot< R, T > bdot; for (size_t k = 0; k < I3; k++) { for (size_t j = 0; j < I2; j++) { for (size_t i = 0; i < I1; i++) { T& value = at( i, j, k ); value = static_cast< T >( 0.0 ); #if 0 ui = U.get_column( i ); tmpi = temp.get_column( j + k *I2 ); bdot.compute( ui, tmpi, value ); #else for( size_t r = 0; r < R; ++r ) value += U(r, i) * temp(r, j + k * I2); #endif } } } } VMML_TEMPLATE_STRING template< typename float_t> void VMML_TEMPLATE_CLASSNAME:: apply_spherical_weights( tensor3< I1, I2, I3, float_t >& other ) { //piecewise multiplication of every frontal slice with the weights (spherical) for( size_t i3 = 0; i3 < I3; ++i3 ) { size_t k3 = i3 - I3/2; for ( size_t i1 = 0; i1 < I1; ++i1) { size_t k1 = i1 - I1/2; for ( size_t i2 = 0; i2 < I2; ++i2 ) { size_t k2 = i2 - I2/2; float_t weight = (sqrtf( k1*k1 + k2*k2 + k3*k3) + 0.0000001); weight = exp( - weight ); //or try exp(- weight * factor) float_t value = static_cast( at(i1, i2, i3)); //value = (value > 35) ? (value - 35) : 0; other.at( i1, i2, i3 ) = static_cast ( weight * value); } } } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME:: get_sphere() { for( size_t i3 = 0; i3 < I3; ++i3 ) { size_t k3 = i3 - I3/2; for ( size_t i1 = 0; i1 < I1; ++i1) { size_t k1 = i1 - I1/2; for ( size_t i2 = 0; i2 < I2; ++i2 ) { size_t k2 = i2 - I2/2; float_t radius = sqrtf(k1*k1 + k2*k2 + k3*k3); //FIXME(choose appropriate I if (radius >= (I1/2)) at(i1, i2, i3 ) = 0; } } } } VMML_TEMPLATE_STRING template< size_t R, typename TT > T VMML_TEMPLATE_CLASSNAME::tensor_inner_product( const vmml::vector< R, TT>& lambda, const vmml::matrix< I1, R, TT >& U, const vmml::matrix< I2, R, TT >& V, const vmml::matrix< I3, R, TT >& W ) const { T inner_prod; for (size_t r = 0; r < R; ++r) { for (size_t k = 0; k < I3; ++k) { for (size_t j = 0; j < I2; ++j) { for (size_t i = 0; i < I1; ++i) { inner_prod += at(i, j, k) * static_cast ( U(i, r) * V( j, r) * W( k, r ) * lambda.at(r)); } } } } return inner_prod; } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3 > void VMML_TEMPLATE_CLASSNAME::average_8to1( tensor3< K1, K2, K3, T >& other ) const { assert(I1/2 >= K1); assert(I2/2 >= K2); assert(I3/2 >= K3); typedef matrix< K1, K2, T > other_slice_type; typedef matrix< K1, K2, float > other_slice_float_type; typedef matrix< K1, I2, T> sub_row_slice_type; front_slice_type* slice0 = new front_slice_type; front_slice_type* slice1 = new front_slice_type; sub_row_slice_type* sub_row_slice = new sub_row_slice_type; other_slice_type* slice_other = new other_slice_type; other_slice_float_type* slice_float_other = new other_slice_float_type; other.zero(); for ( size_t i3 = 0, k3 = 0; i3 < I3; ++i3, ++k3 ) { get_frontal_slice_fwd( i3++, *slice0 ); if ( i3 < I3) { get_frontal_slice_fwd( i3, *slice1 ); *slice0 += *slice1; slice0->sum_rows( *sub_row_slice ); sub_row_slice->sum_columns( *slice_other ); *slice_float_other = *slice_other; *slice_float_other /= 8.0; *slice_float_other += 0.5; slice_other->cast_from( *slice_float_other ); other.set_frontal_slice_fwd( k3, *slice_other ); } } delete slice0; delete slice1; delete slice_other; delete sub_row_slice; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME } // namespace vmml #endif vmmlib-1.0/include/vmmlib/math.hpp0000644000175000017500000000173611674116156016566 0ustar shevekshevek#ifndef __VMML__MATH__HPP__ #define __VMML__MATH__HPP__ #include namespace vmml { namespace math { // helpers for certain cmath functions template< class T > inline T squared( const T a ) { return ( a == 0.0 ) ? 0.0 : a * a; } /* * Computes (a2 + b2)1/2 without destructive underflow or overflow. */ template< class T > inline T pythag( T a, T b ) { a = fabs(a); b = fabs(b); if ( a > b ) return a * sqrt( 1.0 + squared( b / a ) ); else return ( b == 0.0 ) ? 0.0 : b * sqrt( 1.0 + squared( a / b ) ); } template< class T > inline T sign( T a, T b ) { return ( b >= 0.0 ) ? fabs( a ) : -fabs( a ); } template< typename T > struct abs_less { T operator()( const T& a, const T& b ) { return fabs(a) < fabs( b ); } }; template< typename T > struct abs_greater { T operator()( const T& a, const T& b ) { return fabs(a) > fabs( b ); } }; } // namespace math } // namespace vmml #endif vmmlib-1.0/include/vmmlib/lapack/0000755000175000017500000000000011674116155016347 5ustar shevekshevekvmmlib-1.0/include/vmmlib/lapack/detail/0000755000175000017500000000000011674116155017611 5ustar shevekshevekvmmlib-1.0/include/vmmlib/lapack/detail/f2c.h0000644000175000017500000001112011674116155020427 0ustar shevekshevek/* f2c.h -- Standard Fortran to C header file */ /** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed." - From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */ #ifndef F2C_INCLUDE #define F2C_INCLUDE typedef long int integer; typedef unsigned long int uinteger; typedef char *address; typedef short int shortint; typedef float real; typedef double doublereal; typedef struct { real r, i; } complex; typedef struct { doublereal r, i; } doublecomplex; typedef long int logical; typedef short int shortlogical; typedef char logical1; typedef char integer1; #ifdef INTEGER_STAR_8 /* Adjust for integer*8. */ typedef long long longint; /* system-dependent */ typedef unsigned long long ulongint; /* system-dependent */ #define qbit_clear(a,b) ((a) & ~((ulongint)1 << (b))) #define qbit_set(a,b) ((a) | ((ulongint)1 << (b))) #endif #define TRUE_ (1) #define FALSE_ (0) /* Extern is for use with -E */ #ifndef Extern #define Extern extern #endif /* I/O stuff */ #ifdef f2c_i2 /* for -i2 */ typedef short flag; typedef short ftnlen; typedef short ftnint; #else typedef long int flag; typedef long int ftnlen; typedef long int ftnint; #endif /*external read, write*/ typedef struct { flag cierr; ftnint ciunit; flag ciend; char *cifmt; ftnint cirec; } cilist; /*internal read, write*/ typedef struct { flag icierr; char *iciunit; flag iciend; char *icifmt; ftnint icirlen; ftnint icirnum; } icilist; /*open*/ typedef struct { flag oerr; ftnint ounit; char *ofnm; ftnlen ofnmlen; char *osta; char *oacc; char *ofm; ftnint orl; char *oblnk; } olist; /*close*/ typedef struct { flag cerr; ftnint cunit; char *csta; } cllist; /*rewind, backspace, endfile*/ typedef struct { flag aerr; ftnint aunit; } alist; /* inquire */ typedef struct { flag inerr; ftnint inunit; char *infile; ftnlen infilen; ftnint *inex; /*parameters in standard's order*/ ftnint *inopen; ftnint *innum; ftnint *innamed; char *inname; ftnlen innamlen; char *inacc; ftnlen inacclen; char *inseq; ftnlen inseqlen; char *indir; ftnlen indirlen; char *infmt; ftnlen infmtlen; char *inform; ftnint informlen; char *inunf; ftnlen inunflen; ftnint *inrecl; ftnint *innrec; char *inblank; ftnlen inblanklen; } inlist; #define VOID void union Multitype { /* for multiple entry points */ integer1 g; shortint h; integer i; /* longint j; */ real r; doublereal d; complex c; doublecomplex z; }; typedef union Multitype Multitype; /*typedef long int Long;*/ /* No longer used; formerly in Namelist */ struct Vardesc { /* for Namelist */ char *name; char *addr; ftnlen *dims; int type; }; typedef struct Vardesc Vardesc; struct Namelist { char *name; Vardesc **vars; int nvars; }; typedef struct Namelist Namelist; #define abs(x) ((x) >= 0 ? (x) : -(x)) #define dabs(x) (doublereal)abs(x) #define min(a,b) ((a) <= (b) ? (a) : (b)) #define max(a,b) ((a) >= (b) ? (a) : (b)) #define dmin(a,b) (doublereal)min(a,b) #define dmax(a,b) (doublereal)max(a,b) #define bit_test(a,b) ((a) >> (b) & 1) #define bit_clear(a,b) ((a) & ~((uinteger)1 << (b))) #define bit_set(a,b) ((a) | ((uinteger)1 << (b))) /* procedure parameter types for -A and -C++ */ #define F2C_proc_par_types 1 #ifdef __cplusplus typedef int /* Unknown procedure type */ (*U_fp)(...); typedef shortint (*J_fp)(...); typedef integer (*I_fp)(...); typedef real (*R_fp)(...); typedef doublereal (*D_fp)(...), (*E_fp)(...); typedef /* Complex */ VOID (*C_fp)(...); typedef /* Double Complex */ VOID (*Z_fp)(...); typedef logical (*L_fp)(...); typedef shortlogical (*K_fp)(...); typedef /* Character */ VOID (*H_fp)(...); typedef /* Subroutine */ int (*S_fp)(...); #else typedef int /* Unknown procedure type */ (*U_fp)(); typedef shortint (*J_fp)(); typedef integer (*I_fp)(); typedef real (*R_fp)(); typedef doublereal (*D_fp)(), (*E_fp)(); typedef /* Complex */ VOID (*C_fp)(); typedef /* Double Complex */ VOID (*Z_fp)(); typedef logical (*L_fp)(); typedef shortlogical (*K_fp)(); typedef /* Character */ VOID (*H_fp)(); typedef /* Subroutine */ int (*S_fp)(); #endif /* E_fp is for real functions when -R is not specified */ typedef VOID C_f; /* complex function */ typedef VOID H_f; /* character function */ typedef VOID Z_f; /* double complex function */ typedef doublereal E_f; /* real function with -R not specified */ /* undef any lower-case symbols that your C compiler predefines, e.g.: */ #ifndef Skip_f2c_Undefs #undef cray #undef gcos #undef mc68010 #undef mc68020 #undef mips #undef pdp11 #undef sgi #undef sparc #undef sun #undef sun2 #undef sun3 #undef sun4 #undef u370 #undef u3b #undef u3b2 #undef u3b5 #undef unix #undef vax #endif #endif vmmlib-1.0/include/vmmlib/lapack/detail/clapack.h0000644000175000017500000123651711674116155021377 0ustar shevekshevek/* header file for clapack 3.2.1 */ #ifndef __CLAPACK_H #define __CLAPACK_H #ifdef __cplusplus extern "C" { #endif /* Subroutine */ int caxpy_(integer *n, complex *ca, complex *cx, integer * incx, complex *cy, integer *incy); /* Subroutine */ int ccopy_(integer *n, complex *cx, integer *incx, complex * cy, integer *incy); /* Complex */ VOID cdotc_(complex * ret_val, integer *n, complex *cx, integer *incx, complex *cy, integer *incy); /* Complex */ VOID cdotu_(complex * ret_val, integer *n, complex *cx, integer *incx, complex *cy, integer *incy); /* Subroutine */ int cgbmv_(char *trans, integer *m, integer *n, integer *kl, integer *ku, complex *alpha, complex *a, integer *lda, complex *x, integer *incx, complex *beta, complex *y, integer *incy); /* Subroutine */ int cgemm_(char *transa, char *transb, integer *m, integer * n, integer *k, complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, complex *beta, complex *c__, integer *ldc); /* Subroutine */ int cgemv_(char *trans, integer *m, integer *n, complex * alpha, complex *a, integer *lda, complex *x, integer *incx, complex * beta, complex *y, integer *incy); /* Subroutine */ int cgerc_(integer *m, integer *n, complex *alpha, complex * x, integer *incx, complex *y, integer *incy, complex *a, integer *lda); /* Subroutine */ int cgeru_(integer *m, integer *n, complex *alpha, complex * x, integer *incx, complex *y, integer *incy, complex *a, integer *lda); /* Subroutine */ int chbmv_(char *uplo, integer *n, integer *k, complex * alpha, complex *a, integer *lda, complex *x, integer *incx, complex * beta, complex *y, integer *incy); /* Subroutine */ int chemm_(char *side, char *uplo, integer *m, integer *n, complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, complex *beta, complex *c__, integer *ldc); /* Subroutine */ int chemv_(char *uplo, integer *n, complex *alpha, complex * a, integer *lda, complex *x, integer *incx, complex *beta, complex *y, integer *incy); /* Subroutine */ int cher_(char *uplo, integer *n, real *alpha, complex *x, integer *incx, complex *a, integer *lda); /* Subroutine */ int cher2_(char *uplo, integer *n, complex *alpha, complex * x, integer *incx, complex *y, integer *incy, complex *a, integer *lda); /* Subroutine */ int cher2k_(char *uplo, char *trans, integer *n, integer *k, complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, real *beta, complex *c__, integer *ldc); /* Subroutine */ int cherk_(char *uplo, char *trans, integer *n, integer *k, real *alpha, complex *a, integer *lda, real *beta, complex *c__, integer *ldc); /* Subroutine */ int chpmv_(char *uplo, integer *n, complex *alpha, complex * ap, complex *x, integer *incx, complex *beta, complex *y, integer * incy); /* Subroutine */ int chpr_(char *uplo, integer *n, real *alpha, complex *x, integer *incx, complex *ap); /* Subroutine */ int chpr2_(char *uplo, integer *n, complex *alpha, complex * x, integer *incx, complex *y, integer *incy, complex *ap); /* Subroutine */ int crotg_(complex *ca, complex *cb, real *c__, complex *s); /* Subroutine */ int cscal_(integer *n, complex *ca, complex *cx, integer * incx); /* Subroutine */ int csrot_(integer *n, complex *cx, integer *incx, complex * cy, integer *incy, real *c__, real *s); /* Subroutine */ int csscal_(integer *n, real *sa, complex *cx, integer *incx); /* Subroutine */ int cswap_(integer *n, complex *cx, integer *incx, complex * cy, integer *incy); /* Subroutine */ int csymm_(char *side, char *uplo, integer *m, integer *n, complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, complex *beta, complex *c__, integer *ldc); /* Subroutine */ int csyr2k_(char *uplo, char *trans, integer *n, integer *k, complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, complex *beta, complex *c__, integer *ldc); /* Subroutine */ int csyrk_(char *uplo, char *trans, integer *n, integer *k, complex *alpha, complex *a, integer *lda, complex *beta, complex *c__, integer *ldc); /* Subroutine */ int ctbmv_(char *uplo, char *trans, char *diag, integer *n, integer *k, complex *a, integer *lda, complex *x, integer *incx); /* Subroutine */ int ctbsv_(char *uplo, char *trans, char *diag, integer *n, integer *k, complex *a, integer *lda, complex *x, integer *incx); /* Subroutine */ int ctpmv_(char *uplo, char *trans, char *diag, integer *n, complex *ap, complex *x, integer *incx); /* Subroutine */ int ctpsv_(char *uplo, char *trans, char *diag, integer *n, complex *ap, complex *x, integer *incx); /* Subroutine */ int ctrmm_(char *side, char *uplo, char *transa, char *diag, integer *m, integer *n, complex *alpha, complex *a, integer *lda, complex *b, integer *ldb); /* Subroutine */ int ctrmv_(char *uplo, char *trans, char *diag, integer *n, complex *a, integer *lda, complex *x, integer *incx); /* Subroutine */ int ctrsm_(char *side, char *uplo, char *transa, char *diag, integer *m, integer *n, complex *alpha, complex *a, integer *lda, complex *b, integer *ldb); /* Subroutine */ int ctrsv_(char *uplo, char *trans, char *diag, integer *n, complex *a, integer *lda, complex *x, integer *incx); doublereal dasum_(integer *n, doublereal *dx, integer *incx); /* Subroutine */ int daxpy_(integer *n, doublereal *da, doublereal *dx, integer *incx, doublereal *dy, integer *incy); doublereal dcabs1_(doublecomplex *z__); /* Subroutine */ int dcopy_(integer *n, doublereal *dx, integer *incx, doublereal *dy, integer *incy); doublereal ddot_(integer *n, doublereal *dx, integer *incx, doublereal *dy, integer *incy); /* Subroutine */ int dgbmv_(char *trans, integer *m, integer *n, integer *kl, integer *ku, doublereal *alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); /* Subroutine */ int dgemm_(char *transa, char *transb, integer *m, integer * n, integer *k, doublereal *alpha, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *beta, doublereal *c__, integer *ldc); /* Subroutine */ int dgemv_(char *trans, integer *m, integer *n, doublereal * alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); /* Subroutine */ int dger_(integer *m, integer *n, doublereal *alpha, doublereal *x, integer *incx, doublereal *y, integer *incy, doublereal *a, integer *lda); doublereal dnrm2_(integer *n, doublereal *x, integer *incx); /* Subroutine */ int drot_(integer *n, doublereal *dx, integer *incx, doublereal *dy, integer *incy, doublereal *c__, doublereal *s); /* Subroutine */ int drotg_(doublereal *da, doublereal *db, doublereal *c__, doublereal *s); /* Subroutine */ int drotm_(integer *n, doublereal *dx, integer *incx, doublereal *dy, integer *incy, doublereal *dparam); /* Subroutine */ int drotmg_(doublereal *dd1, doublereal *dd2, doublereal * dx1, doublereal *dy1, doublereal *dparam); /* Subroutine */ int dsbmv_(char *uplo, integer *n, integer *k, doublereal * alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); /* Subroutine */ int dscal_(integer *n, doublereal *da, doublereal *dx, integer *incx); doublereal dsdot_(integer *n, real *sx, integer *incx, real *sy, integer * incy); /* Subroutine */ int dspmv_(char *uplo, integer *n, doublereal *alpha, doublereal *ap, doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); /* Subroutine */ int dspr_(char *uplo, integer *n, doublereal *alpha, doublereal *x, integer *incx, doublereal *ap); /* Subroutine */ int dspr2_(char *uplo, integer *n, doublereal *alpha, doublereal *x, integer *incx, doublereal *y, integer *incy, doublereal *ap); /* Subroutine */ int dswap_(integer *n, doublereal *dx, integer *incx, doublereal *dy, integer *incy); /* Subroutine */ int dsymm_(char *side, char *uplo, integer *m, integer *n, doublereal *alpha, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *beta, doublereal *c__, integer *ldc); /* Subroutine */ int dsymv_(char *uplo, integer *n, doublereal *alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); /* Subroutine */ int dsyr_(char *uplo, integer *n, doublereal *alpha, doublereal *x, integer *incx, doublereal *a, integer *lda); /* Subroutine */ int dsyr2_(char *uplo, integer *n, doublereal *alpha, doublereal *x, integer *incx, doublereal *y, integer *incy, doublereal *a, integer *lda); /* Subroutine */ int dsyr2k_(char *uplo, char *trans, integer *n, integer *k, doublereal *alpha, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *beta, doublereal *c__, integer *ldc); /* Subroutine */ int dsyrk_(char *uplo, char *trans, integer *n, integer *k, doublereal *alpha, doublereal *a, integer *lda, doublereal *beta, doublereal *c__, integer *ldc); /* Subroutine */ int dtbmv_(char *uplo, char *trans, char *diag, integer *n, integer *k, doublereal *a, integer *lda, doublereal *x, integer *incx); /* Subroutine */ int dtbsv_(char *uplo, char *trans, char *diag, integer *n, integer *k, doublereal *a, integer *lda, doublereal *x, integer *incx); /* Subroutine */ int dtpmv_(char *uplo, char *trans, char *diag, integer *n, doublereal *ap, doublereal *x, integer *incx); /* Subroutine */ int dtpsv_(char *uplo, char *trans, char *diag, integer *n, doublereal *ap, doublereal *x, integer *incx); /* Subroutine */ int dtrmm_(char *side, char *uplo, char *transa, char *diag, integer *m, integer *n, doublereal *alpha, doublereal *a, integer * lda, doublereal *b, integer *ldb); /* Subroutine */ int dtrmv_(char *uplo, char *trans, char *diag, integer *n, doublereal *a, integer *lda, doublereal *x, integer *incx); /* Subroutine */ int dtrsm_(char *side, char *uplo, char *transa, char *diag, integer *m, integer *n, doublereal *alpha, doublereal *a, integer * lda, doublereal *b, integer *ldb); /* Subroutine */ int dtrsv_(char *uplo, char *trans, char *diag, integer *n, doublereal *a, integer *lda, doublereal *x, integer *incx); doublereal dzasum_(integer *n, doublecomplex *zx, integer *incx); doublereal dznrm2_(integer *n, doublecomplex *x, integer *incx); integer icamax_(integer *n, complex *cx, integer *incx); integer idamax_(integer *n, doublereal *dx, integer *incx); integer isamax_(integer *n, real *sx, integer *incx); integer izamax_(integer *n, doublecomplex *zx, integer *incx); logical lsame_(char *ca, char *cb); doublereal sasum_(integer *n, real *sx, integer *incx); /* Subroutine */ int saxpy_(integer *n, real *sa, real *sx, integer *incx, real *sy, integer *incy); doublereal scabs1_(complex *z__); doublereal scasum_(integer *n, complex *cx, integer *incx); doublereal scnrm2_(integer *n, complex *x, integer *incx); /* Subroutine */ int scopy_(integer *n, real *sx, integer *incx, real *sy, integer *incy); doublereal sdot_(integer *n, real *sx, integer *incx, real *sy, integer *incy); doublereal sdsdot_(integer *n, real *sb, real *sx, integer *incx, real *sy, integer *incy); /* Subroutine */ int sgbmv_(char *trans, integer *m, integer *n, integer *kl, integer *ku, real *alpha, real *a, integer *lda, real *x, integer * incx, real *beta, real *y, integer *incy); /* Subroutine */ int sgemm_(char *transa, char *transb, integer *m, integer * n, integer *k, real *alpha, real *a, integer *lda, real *b, integer * ldb, real *beta, real *c__, integer *ldc); /* Subroutine */ int sgemv_(char *trans, integer *m, integer *n, real *alpha, real *a, integer *lda, real *x, integer *incx, real *beta, real *y, integer *incy); /* Subroutine */ int sger_(integer *m, integer *n, real *alpha, real *x, integer *incx, real *y, integer *incy, real *a, integer *lda); doublereal snrm2_(integer *n, real *x, integer *incx); /* Subroutine */ int srot_(integer *n, real *sx, integer *incx, real *sy, integer *incy, real *c__, real *s); /* Subroutine */ int srotg_(real *sa, real *sb, real *c__, real *s); /* Subroutine */ int srotm_(integer *n, real *sx, integer *incx, real *sy, integer *incy, real *sparam); /* Subroutine */ int srotmg_(real *sd1, real *sd2, real *sx1, real *sy1, real *sparam); /* Subroutine */ int ssbmv_(char *uplo, integer *n, integer *k, real *alpha, real *a, integer *lda, real *x, integer *incx, real *beta, real *y, integer *incy); /* Subroutine */ int sscal_(integer *n, real *sa, real *sx, integer *incx); /* Subroutine */ int sspmv_(char *uplo, integer *n, real *alpha, real *ap, real *x, integer *incx, real *beta, real *y, integer *incy); /* Subroutine */ int sspr_(char *uplo, integer *n, real *alpha, real *x, integer *incx, real *ap); /* Subroutine */ int sspr2_(char *uplo, integer *n, real *alpha, real *x, integer *incx, real *y, integer *incy, real *ap); /* Subroutine */ int sswap_(integer *n, real *sx, integer *incx, real *sy, integer *incy); /* Subroutine */ int ssymm_(char *side, char *uplo, integer *m, integer *n, real *alpha, real *a, integer *lda, real *b, integer *ldb, real *beta, real *c__, integer *ldc); /* Subroutine */ int ssymv_(char *uplo, integer *n, real *alpha, real *a, integer *lda, real *x, integer *incx, real *beta, real *y, integer * incy); /* Subroutine */ int ssyr_(char *uplo, integer *n, real *alpha, real *x, integer *incx, real *a, integer *lda); /* Subroutine */ int ssyr2_(char *uplo, integer *n, real *alpha, real *x, integer *incx, real *y, integer *incy, real *a, integer *lda); /* Subroutine */ int ssyr2k_(char *uplo, char *trans, integer *n, integer *k, real *alpha, real *a, integer *lda, real *b, integer *ldb, real *beta, real *c__, integer *ldc); /* Subroutine */ int ssyrk_(char *uplo, char *trans, integer *n, integer *k, real *alpha, real *a, integer *lda, real *beta, real *c__, integer * ldc); /* Subroutine */ int stbmv_(char *uplo, char *trans, char *diag, integer *n, integer *k, real *a, integer *lda, real *x, integer *incx); /* Subroutine */ int stbsv_(char *uplo, char *trans, char *diag, integer *n, integer *k, real *a, integer *lda, real *x, integer *incx); /* Subroutine */ int stpmv_(char *uplo, char *trans, char *diag, integer *n, real *ap, real *x, integer *incx); /* Subroutine */ int stpsv_(char *uplo, char *trans, char *diag, integer *n, real *ap, real *x, integer *incx); /* Subroutine */ int strmm_(char *side, char *uplo, char *transa, char *diag, integer *m, integer *n, real *alpha, real *a, integer *lda, real *b, integer *ldb); /* Subroutine */ int strmv_(char *uplo, char *trans, char *diag, integer *n, real *a, integer *lda, real *x, integer *incx); /* Subroutine */ int strsm_(char *side, char *uplo, char *transa, char *diag, integer *m, integer *n, real *alpha, real *a, integer *lda, real *b, integer *ldb); /* Subroutine */ int strsv_(char *uplo, char *trans, char *diag, integer *n, real *a, integer *lda, real *x, integer *incx); /* Subroutine */ int xerbla_(char *srname, integer *info); /* Subroutine */ int xerbla_array__(char *srname_array__, integer * srname_len__, integer *info, ftnlen srname_array_len); /* Subroutine */ int zaxpy_(integer *n, doublecomplex *za, doublecomplex *zx, integer *incx, doublecomplex *zy, integer *incy); /* Subroutine */ int zcopy_(integer *n, doublecomplex *zx, integer *incx, doublecomplex *zy, integer *incy); /* Double Complex */ VOID zdotc_(doublecomplex * ret_val, integer *n, doublecomplex *zx, integer *incx, doublecomplex *zy, integer *incy); /* Double Complex */ VOID zdotu_(doublecomplex * ret_val, integer *n, doublecomplex *zx, integer *incx, doublecomplex *zy, integer *incy); /* Subroutine */ int zdrot_(integer *n, doublecomplex *cx, integer *incx, doublecomplex *cy, integer *incy, doublereal *c__, doublereal *s); /* Subroutine */ int zdscal_(integer *n, doublereal *da, doublecomplex *zx, integer *incx); /* Subroutine */ int zgbmv_(char *trans, integer *m, integer *n, integer *kl, integer *ku, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, doublecomplex *beta, doublecomplex * y, integer *incy); /* Subroutine */ int zgemm_(char *transa, char *transb, integer *m, integer * n, integer *k, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *beta, doublecomplex * c__, integer *ldc); /* Subroutine */ int zgemv_(char *trans, integer *m, integer *n, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex * x, integer *incx, doublecomplex *beta, doublecomplex *y, integer * incy); /* Subroutine */ int zgerc_(integer *m, integer *n, doublecomplex *alpha, doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, doublecomplex *a, integer *lda); /* Subroutine */ int zgeru_(integer *m, integer *n, doublecomplex *alpha, doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, doublecomplex *a, integer *lda); /* Subroutine */ int zhbmv_(char *uplo, integer *n, integer *k, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *x, integer * incx, doublecomplex *beta, doublecomplex *y, integer *incy); /* Subroutine */ int zhemm_(char *side, char *uplo, integer *m, integer *n, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex * b, integer *ldb, doublecomplex *beta, doublecomplex *c__, integer * ldc); /* Subroutine */ int zhemv_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, doublecomplex *beta, doublecomplex *y, integer *incy); /* Subroutine */ int zher_(char *uplo, integer *n, doublereal *alpha, doublecomplex *x, integer *incx, doublecomplex *a, integer *lda); /* Subroutine */ int zher2_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, doublecomplex *a, integer *lda); /* Subroutine */ int zher2k_(char *uplo, char *trans, integer *n, integer *k, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex * b, integer *ldb, doublereal *beta, doublecomplex *c__, integer *ldc); /* Subroutine */ int zherk_(char *uplo, char *trans, integer *n, integer *k, doublereal *alpha, doublecomplex *a, integer *lda, doublereal *beta, doublecomplex *c__, integer *ldc); /* Subroutine */ int zhpmv_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *ap, doublecomplex *x, integer *incx, doublecomplex * beta, doublecomplex *y, integer *incy); /* Subroutine */ int zhpr_(char *uplo, integer *n, doublereal *alpha, doublecomplex *x, integer *incx, doublecomplex *ap); /* Subroutine */ int zhpr2_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, doublecomplex *ap); /* Subroutine */ int zrotg_(doublecomplex *ca, doublecomplex *cb, doublereal * c__, doublecomplex *s); /* Subroutine */ int zscal_(integer *n, doublecomplex *za, doublecomplex *zx, integer *incx); /* Subroutine */ int zswap_(integer *n, doublecomplex *zx, integer *incx, doublecomplex *zy, integer *incy); /* Subroutine */ int zsymm_(char *side, char *uplo, integer *m, integer *n, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex * b, integer *ldb, doublecomplex *beta, doublecomplex *c__, integer * ldc); /* Subroutine */ int zsyr2k_(char *uplo, char *trans, integer *n, integer *k, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex * b, integer *ldb, doublecomplex *beta, doublecomplex *c__, integer * ldc); /* Subroutine */ int zsyrk_(char *uplo, char *trans, integer *n, integer *k, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex * beta, doublecomplex *c__, integer *ldc); /* Subroutine */ int ztbmv_(char *uplo, char *trans, char *diag, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx); /* Subroutine */ int ztbsv_(char *uplo, char *trans, char *diag, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx); /* Subroutine */ int ztpmv_(char *uplo, char *trans, char *diag, integer *n, doublecomplex *ap, doublecomplex *x, integer *incx); /* Subroutine */ int ztpsv_(char *uplo, char *trans, char *diag, integer *n, doublecomplex *ap, doublecomplex *x, integer *incx); /* Subroutine */ int ztrmm_(char *side, char *uplo, char *transa, char *diag, integer *m, integer *n, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb); /* Subroutine */ int ztrmv_(char *uplo, char *trans, char *diag, integer *n, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx); /* Subroutine */ int ztrsm_(char *side, char *uplo, char *transa, char *diag, integer *m, integer *n, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb); /* Subroutine */ int ztrsv_(char *uplo, char *trans, char *diag, integer *n, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx); /* Subroutine */ int cbdsqr_(char *uplo, integer *n, integer *ncvt, integer * nru, integer *ncc, real *d__, real *e, complex *vt, integer *ldvt, complex *u, integer *ldu, complex *c__, integer *ldc, real *rwork, integer *info); /* Subroutine */ int cgbbrd_(char *vect, integer *m, integer *n, integer *ncc, integer *kl, integer *ku, complex *ab, integer *ldab, real *d__, real *e, complex *q, integer *ldq, complex *pt, integer *ldpt, complex *c__, integer *ldc, complex *work, real *rwork, integer *info); /* Subroutine */ int cgbcon_(char *norm, integer *n, integer *kl, integer *ku, complex *ab, integer *ldab, integer *ipiv, real *anorm, real *rcond, complex *work, real *rwork, integer *info); /* Subroutine */ int cgbequ_(integer *m, integer *n, integer *kl, integer *ku, complex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer *info); /* Subroutine */ int cgbequb_(integer *m, integer *n, integer *kl, integer * ku, complex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer *info); /* Subroutine */ int cgbrfs_(char *trans, integer *n, integer *kl, integer * ku, integer *nrhs, complex *ab, integer *ldab, complex *afb, integer * ldafb, integer *ipiv, complex *b, integer *ldb, complex *x, integer * ldx, real *ferr, real *berr, complex *work, real *rwork, integer * info); /* Subroutine */ int cgbrfsx_(char *trans, char *equed, integer *n, integer * kl, integer *ku, integer *nrhs, complex *ab, integer *ldab, complex * afb, integer *ldafb, integer *ipiv, real *r__, real *c__, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *params, complex *work, real *rwork, integer * info); /* Subroutine */ int cgbsv_(integer *n, integer *kl, integer *ku, integer * nrhs, complex *ab, integer *ldab, integer *ipiv, complex *b, integer * ldb, integer *info); /* Subroutine */ int cgbsvx_(char *fact, char *trans, integer *n, integer *kl, integer *ku, integer *nrhs, complex *ab, integer *ldab, complex *afb, integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cgbsvxx_(char *fact, char *trans, integer *n, integer * kl, integer *ku, integer *nrhs, complex *ab, integer *ldab, complex * afb, integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, integer *n_err_bnds__, real * err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real * params, complex *work, real *rwork, integer *info); /* Subroutine */ int cgbtf2_(integer *m, integer *n, integer *kl, integer *ku, complex *ab, integer *ldab, integer *ipiv, integer *info); /* Subroutine */ int cgbtrf_(integer *m, integer *n, integer *kl, integer *ku, complex *ab, integer *ldab, integer *ipiv, integer *info); /* Subroutine */ int cgbtrs_(char *trans, integer *n, integer *kl, integer * ku, integer *nrhs, complex *ab, integer *ldab, integer *ipiv, complex *b, integer *ldb, integer *info); /* Subroutine */ int cgebak_(char *job, char *side, integer *n, integer *ilo, integer *ihi, real *scale, integer *m, complex *v, integer *ldv, integer *info); /* Subroutine */ int cgebal_(char *job, integer *n, complex *a, integer *lda, integer *ilo, integer *ihi, real *scale, integer *info); /* Subroutine */ int cgebd2_(integer *m, integer *n, complex *a, integer *lda, real *d__, real *e, complex *tauq, complex *taup, complex *work, integer *info); /* Subroutine */ int cgebrd_(integer *m, integer *n, complex *a, integer *lda, real *d__, real *e, complex *tauq, complex *taup, complex *work, integer *lwork, integer *info); /* Subroutine */ int cgecon_(char *norm, integer *n, complex *a, integer *lda, real *anorm, real *rcond, complex *work, real *rwork, integer *info); /* Subroutine */ int cgeequ_(integer *m, integer *n, complex *a, integer *lda, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer *info); /* Subroutine */ int cgeequb_(integer *m, integer *n, complex *a, integer * lda, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer *info); /* Subroutine */ int cgees_(char *jobvs, char *sort, L_fp select, integer *n, complex *a, integer *lda, integer *sdim, complex *w, complex *vs, integer *ldvs, complex *work, integer *lwork, real *rwork, logical * bwork, integer *info); /* Subroutine */ int cgeesx_(char *jobvs, char *sort, L_fp select, char * sense, integer *n, complex *a, integer *lda, integer *sdim, complex * w, complex *vs, integer *ldvs, real *rconde, real *rcondv, complex * work, integer *lwork, real *rwork, logical *bwork, integer *info); /* Subroutine */ int cgeev_(char *jobvl, char *jobvr, integer *n, complex *a, integer *lda, complex *w, complex *vl, integer *ldvl, complex *vr, integer *ldvr, complex *work, integer *lwork, real *rwork, integer * info); /* Subroutine */ int cgeevx_(char *balanc, char *jobvl, char *jobvr, char * sense, integer *n, complex *a, integer *lda, complex *w, complex *vl, integer *ldvl, complex *vr, integer *ldvr, integer *ilo, integer *ihi, real *scale, real *abnrm, real *rconde, real *rcondv, complex *work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int cgegs_(char *jobvsl, char *jobvsr, integer *n, complex * a, integer *lda, complex *b, integer *ldb, complex *alpha, complex * beta, complex *vsl, integer *ldvsl, complex *vsr, integer *ldvsr, complex *work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int cgegv_(char *jobvl, char *jobvr, integer *n, complex *a, integer *lda, complex *b, integer *ldb, complex *alpha, complex *beta, complex *vl, integer *ldvl, complex *vr, integer *ldvr, complex * work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int cgehd2_(integer *n, integer *ilo, integer *ihi, complex * a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cgehrd_(integer *n, integer *ilo, integer *ihi, complex * a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cgelq2_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cgelqf_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cgels_(char *trans, integer *m, integer *n, integer * nrhs, complex *a, integer *lda, complex *b, integer *ldb, complex * work, integer *lwork, integer *info); /* Subroutine */ int cgelsd_(integer *m, integer *n, integer *nrhs, complex * a, integer *lda, complex *b, integer *ldb, real *s, real *rcond, integer *rank, complex *work, integer *lwork, real *rwork, integer * iwork, integer *info); /* Subroutine */ int cgelss_(integer *m, integer *n, integer *nrhs, complex * a, integer *lda, complex *b, integer *ldb, real *s, real *rcond, integer *rank, complex *work, integer *lwork, real *rwork, integer * info); /* Subroutine */ int cgelsx_(integer *m, integer *n, integer *nrhs, complex * a, integer *lda, complex *b, integer *ldb, integer *jpvt, real *rcond, integer *rank, complex *work, real *rwork, integer *info); /* Subroutine */ int cgelsy_(integer *m, integer *n, integer *nrhs, complex * a, integer *lda, complex *b, integer *ldb, integer *jpvt, real *rcond, integer *rank, complex *work, integer *lwork, real *rwork, integer * info); /* Subroutine */ int cgeql2_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cgeqlf_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cgeqp3_(integer *m, integer *n, complex *a, integer *lda, integer *jpvt, complex *tau, complex *work, integer *lwork, real * rwork, integer *info); /* Subroutine */ int cgeqpf_(integer *m, integer *n, complex *a, integer *lda, integer *jpvt, complex *tau, complex *work, real *rwork, integer * info); /* Subroutine */ int cgeqr2_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cgeqrf_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cgerfs_(char *trans, integer *n, integer *nrhs, complex * a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex * b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cgerfsx_(char *trans, char *equed, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, real *r__, real *c__, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real * err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real * params, complex *work, real *rwork, integer *info); /* Subroutine */ int cgerq2_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cgerqf_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cgesc2_(integer *n, complex *a, integer *lda, complex * rhs, integer *ipiv, integer *jpiv, real *scale); /* Subroutine */ int cgesdd_(char *jobz, integer *m, integer *n, complex *a, integer *lda, real *s, complex *u, integer *ldu, complex *vt, integer *ldvt, complex *work, integer *lwork, real *rwork, integer *iwork, integer *info); /* Subroutine */ int cgesv_(integer *n, integer *nrhs, complex *a, integer * lda, integer *ipiv, complex *b, integer *ldb, integer *info); /* Subroutine */ int cgesvd_(char *jobu, char *jobvt, integer *m, integer *n, complex *a, integer *lda, real *s, complex *u, integer *ldu, complex * vt, integer *ldvt, complex *work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int cgesvx_(char *fact, char *trans, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, char *equed, real *r__, real *c__, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cgesvxx_(char *fact, char *trans, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, char *equed, real *r__, real *c__, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *params, complex *work, real *rwork, integer * info); /* Subroutine */ int cgetc2_(integer *n, complex *a, integer *lda, integer * ipiv, integer *jpiv, integer *info); /* Subroutine */ int cgetf2_(integer *m, integer *n, complex *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int cgetrf_(integer *m, integer *n, complex *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int cgetri_(integer *n, complex *a, integer *lda, integer * ipiv, complex *work, integer *lwork, integer *info); /* Subroutine */ int cgetrs_(char *trans, integer *n, integer *nrhs, complex * a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer * info); /* Subroutine */ int cggbak_(char *job, char *side, integer *n, integer *ilo, integer *ihi, real *lscale, real *rscale, integer *m, complex *v, integer *ldv, integer *info); /* Subroutine */ int cggbal_(char *job, integer *n, complex *a, integer *lda, complex *b, integer *ldb, integer *ilo, integer *ihi, real *lscale, real *rscale, real *work, integer *info); /* Subroutine */ int cgges_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, integer *n, complex *a, integer *lda, complex *b, integer * ldb, integer *sdim, complex *alpha, complex *beta, complex *vsl, integer *ldvsl, complex *vsr, integer *ldvsr, complex *work, integer * lwork, real *rwork, logical *bwork, integer *info); /* Subroutine */ int cggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, char *sense, integer *n, complex *a, integer *lda, complex *b, integer *ldb, integer *sdim, complex *alpha, complex *beta, complex * vsl, integer *ldvsl, complex *vsr, integer *ldvsr, real *rconde, real *rcondv, complex *work, integer *lwork, real *rwork, integer *iwork, integer *liwork, logical *bwork, integer *info); /* Subroutine */ int cggev_(char *jobvl, char *jobvr, integer *n, complex *a, integer *lda, complex *b, integer *ldb, complex *alpha, complex *beta, complex *vl, integer *ldvl, complex *vr, integer *ldvr, complex * work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int cggevx_(char *balanc, char *jobvl, char *jobvr, char * sense, integer *n, complex *a, integer *lda, complex *b, integer *ldb, complex *alpha, complex *beta, complex *vl, integer *ldvl, complex * vr, integer *ldvr, integer *ilo, integer *ihi, real *lscale, real * rscale, real *abnrm, real *bbnrm, real *rconde, real *rcondv, complex *work, integer *lwork, real *rwork, integer *iwork, logical *bwork, integer *info); /* Subroutine */ int cggglm_(integer *n, integer *m, integer *p, complex *a, integer *lda, complex *b, integer *ldb, complex *d__, complex *x, complex *y, complex *work, integer *lwork, integer *info); /* Subroutine */ int cgghrd_(char *compq, char *compz, integer *n, integer * ilo, integer *ihi, complex *a, integer *lda, complex *b, integer *ldb, complex *q, integer *ldq, complex *z__, integer *ldz, integer *info); /* Subroutine */ int cgglse_(integer *m, integer *n, integer *p, complex *a, integer *lda, complex *b, integer *ldb, complex *c__, complex *d__, complex *x, complex *work, integer *lwork, integer *info); /* Subroutine */ int cggqrf_(integer *n, integer *m, integer *p, complex *a, integer *lda, complex *taua, complex *b, integer *ldb, complex *taub, complex *work, integer *lwork, integer *info); /* Subroutine */ int cggrqf_(integer *m, integer *p, integer *n, complex *a, integer *lda, complex *taua, complex *b, integer *ldb, complex *taub, complex *work, integer *lwork, integer *info); /* Subroutine */ int cggsvd_(char *jobu, char *jobv, char *jobq, integer *m, integer *n, integer *p, integer *k, integer *l, complex *a, integer * lda, complex *b, integer *ldb, real *alpha, real *beta, complex *u, integer *ldu, complex *v, integer *ldv, complex *q, integer *ldq, complex *work, real *rwork, integer *iwork, integer *info); /* Subroutine */ int cggsvp_(char *jobu, char *jobv, char *jobq, integer *m, integer *p, integer *n, complex *a, integer *lda, complex *b, integer *ldb, real *tola, real *tolb, integer *k, integer *l, complex *u, integer *ldu, complex *v, integer *ldv, complex *q, integer *ldq, integer *iwork, real *rwork, complex *tau, complex *work, integer * info); /* Subroutine */ int cgtcon_(char *norm, integer *n, complex *dl, complex * d__, complex *du, complex *du2, integer *ipiv, real *anorm, real * rcond, complex *work, integer *info); /* Subroutine */ int cgtrfs_(char *trans, integer *n, integer *nrhs, complex * dl, complex *d__, complex *du, complex *dlf, complex *df, complex * duf, complex *du2, integer *ipiv, complex *b, integer *ldb, complex * x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cgtsv_(integer *n, integer *nrhs, complex *dl, complex * d__, complex *du, complex *b, integer *ldb, integer *info); /* Subroutine */ int cgtsvx_(char *fact, char *trans, integer *n, integer * nrhs, complex *dl, complex *d__, complex *du, complex *dlf, complex * df, complex *duf, complex *du2, integer *ipiv, complex *b, integer * ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cgttrf_(integer *n, complex *dl, complex *d__, complex * du, complex *du2, integer *ipiv, integer *info); /* Subroutine */ int cgttrs_(char *trans, integer *n, integer *nrhs, complex * dl, complex *d__, complex *du, complex *du2, integer *ipiv, complex * b, integer *ldb, integer *info); /* Subroutine */ int cgtts2_(integer *itrans, integer *n, integer *nrhs, complex *dl, complex *d__, complex *du, complex *du2, integer *ipiv, complex *b, integer *ldb); /* Subroutine */ int chbev_(char *jobz, char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, real *w, complex *z__, integer *ldz, complex *work, real *rwork, integer *info); /* Subroutine */ int chbevd_(char *jobz, char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, real *w, complex *z__, integer *ldz, complex *work, integer *lwork, real *rwork, integer *lrwork, integer * iwork, integer *liwork, integer *info); /* Subroutine */ int chbevx_(char *jobz, char *range, char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, complex *q, integer *ldq, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer * m, real *w, complex *z__, integer *ldz, complex *work, real *rwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int chbgst_(char *vect, char *uplo, integer *n, integer *ka, integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, complex *x, integer *ldx, complex *work, real *rwork, integer *info); /* Subroutine */ int chbgv_(char *jobz, char *uplo, integer *n, integer *ka, integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, real *w, complex *z__, integer *ldz, complex *work, real *rwork, integer *info); /* Subroutine */ int chbgvd_(char *jobz, char *uplo, integer *n, integer *ka, integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, real *w, complex *z__, integer *ldz, complex *work, integer *lwork, real *rwork, integer *lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int chbgvx_(char *jobz, char *range, char *uplo, integer *n, integer *ka, integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, complex *q, integer *ldq, real *vl, real *vu, integer * il, integer *iu, real *abstol, integer *m, real *w, complex *z__, integer *ldz, complex *work, real *rwork, integer *iwork, integer * ifail, integer *info); /* Subroutine */ int chbtrd_(char *vect, char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, real *d__, real *e, complex *q, integer * ldq, complex *work, integer *info); /* Subroutine */ int checon_(char *uplo, integer *n, complex *a, integer *lda, integer *ipiv, real *anorm, real *rcond, complex *work, integer * info); /* Subroutine */ int cheequb_(char *uplo, integer *n, complex *a, integer * lda, real *s, real *scond, real *amax, complex *work, integer *info); /* Subroutine */ int cheev_(char *jobz, char *uplo, integer *n, complex *a, integer *lda, real *w, complex *work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int cheevd_(char *jobz, char *uplo, integer *n, complex *a, integer *lda, real *w, complex *work, integer *lwork, real *rwork, integer *lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int cheevr_(char *jobz, char *range, char *uplo, integer *n, complex *a, integer *lda, real *vl, real *vu, integer *il, integer * iu, real *abstol, integer *m, real *w, complex *z__, integer *ldz, integer *isuppz, complex *work, integer *lwork, real *rwork, integer * lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int cheevx_(char *jobz, char *range, char *uplo, integer *n, complex *a, integer *lda, real *vl, real *vu, integer *il, integer * iu, real *abstol, integer *m, real *w, complex *z__, integer *ldz, complex *work, integer *lwork, real *rwork, integer *iwork, integer * ifail, integer *info); /* Subroutine */ int chegs2_(integer *itype, char *uplo, integer *n, complex * a, integer *lda, complex *b, integer *ldb, integer *info); /* Subroutine */ int chegst_(integer *itype, char *uplo, integer *n, complex * a, integer *lda, complex *b, integer *ldb, integer *info); /* Subroutine */ int chegv_(integer *itype, char *jobz, char *uplo, integer * n, complex *a, integer *lda, complex *b, integer *ldb, real *w, complex *work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int chegvd_(integer *itype, char *jobz, char *uplo, integer * n, complex *a, integer *lda, complex *b, integer *ldb, real *w, complex *work, integer *lwork, real *rwork, integer *lrwork, integer * iwork, integer *liwork, integer *info); /* Subroutine */ int chegvx_(integer *itype, char *jobz, char *range, char * uplo, integer *n, complex *a, integer *lda, complex *b, integer *ldb, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer * m, real *w, complex *z__, integer *ldz, complex *work, integer *lwork, real *rwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int cherfs_(char *uplo, integer *n, integer *nrhs, complex * a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex * b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cherfsx_(char *uplo, char *equed, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *params, complex *work, real *rwork, integer *info); /* Subroutine */ int chesv_(char *uplo, integer *n, integer *nrhs, complex *a, integer *lda, integer *ipiv, complex *b, integer *ldb, complex *work, integer *lwork, integer *info); /* Subroutine */ int chesvx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int chesvxx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, char *equed, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, integer * n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer * nparams, real *params, complex *work, real *rwork, integer *info); /* Subroutine */ int chetd2_(char *uplo, integer *n, complex *a, integer *lda, real *d__, real *e, complex *tau, integer *info); /* Subroutine */ int chetf2_(char *uplo, integer *n, complex *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int chetrd_(char *uplo, integer *n, complex *a, integer *lda, real *d__, real *e, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int chetrf_(char *uplo, integer *n, complex *a, integer *lda, integer *ipiv, complex *work, integer *lwork, integer *info); /* Subroutine */ int chetri_(char *uplo, integer *n, complex *a, integer *lda, integer *ipiv, complex *work, integer *info); /* Subroutine */ int chetrs_(char *uplo, integer *n, integer *nrhs, complex * a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer * info); /* Subroutine */ int chfrk_(char *transr, char *uplo, char *trans, integer *n, integer *k, real *alpha, complex *a, integer *lda, real *beta, complex *c__); /* Subroutine */ int chgeqz_(char *job, char *compq, char *compz, integer *n, integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *t, integer *ldt, complex *alpha, complex *beta, complex *q, integer *ldq, complex *z__, integer *ldz, complex *work, integer *lwork, real * rwork, integer *info); /* Character */ VOID chla_transtype__(char *ret_val, ftnlen ret_val_len, integer *trans); /* Subroutine */ int chpcon_(char *uplo, integer *n, complex *ap, integer * ipiv, real *anorm, real *rcond, complex *work, integer *info); /* Subroutine */ int chpev_(char *jobz, char *uplo, integer *n, complex *ap, real *w, complex *z__, integer *ldz, complex *work, real *rwork, integer *info); /* Subroutine */ int chpevd_(char *jobz, char *uplo, integer *n, complex *ap, real *w, complex *z__, integer *ldz, complex *work, integer *lwork, real *rwork, integer *lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int chpevx_(char *jobz, char *range, char *uplo, integer *n, complex *ap, real *vl, real *vu, integer *il, integer *iu, real * abstol, integer *m, real *w, complex *z__, integer *ldz, complex * work, real *rwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int chpgst_(integer *itype, char *uplo, integer *n, complex * ap, complex *bp, integer *info); /* Subroutine */ int chpgv_(integer *itype, char *jobz, char *uplo, integer * n, complex *ap, complex *bp, real *w, complex *z__, integer *ldz, complex *work, real *rwork, integer *info); /* Subroutine */ int chpgvd_(integer *itype, char *jobz, char *uplo, integer * n, complex *ap, complex *bp, real *w, complex *z__, integer *ldz, complex *work, integer *lwork, real *rwork, integer *lrwork, integer * iwork, integer *liwork, integer *info); /* Subroutine */ int chpgvx_(integer *itype, char *jobz, char *range, char * uplo, integer *n, complex *ap, complex *bp, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, complex * z__, integer *ldz, complex *work, real *rwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int chprfs_(char *uplo, integer *n, integer *nrhs, complex * ap, complex *afp, integer *ipiv, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int chpsv_(char *uplo, integer *n, integer *nrhs, complex * ap, integer *ipiv, complex *b, integer *ldb, integer *info); /* Subroutine */ int chpsvx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *ap, complex *afp, integer *ipiv, complex *b, integer * ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int chptrd_(char *uplo, integer *n, complex *ap, real *d__, real *e, complex *tau, integer *info); /* Subroutine */ int chptrf_(char *uplo, integer *n, complex *ap, integer * ipiv, integer *info); /* Subroutine */ int chptri_(char *uplo, integer *n, complex *ap, integer * ipiv, complex *work, integer *info); /* Subroutine */ int chptrs_(char *uplo, integer *n, integer *nrhs, complex * ap, integer *ipiv, complex *b, integer *ldb, integer *info); /* Subroutine */ int chsein_(char *side, char *eigsrc, char *initv, logical * select, integer *n, complex *h__, integer *ldh, complex *w, complex * vl, integer *ldvl, complex *vr, integer *ldvr, integer *mm, integer * m, complex *work, real *rwork, integer *ifaill, integer *ifailr, integer *info); /* Subroutine */ int chseqr_(char *job, char *compz, integer *n, integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *w, complex *z__, integer *ldz, complex *work, integer *lwork, integer *info); /* Subroutine */ int cla_gbamv__(integer *trans, integer *m, integer *n, integer *kl, integer *ku, real *alpha, complex *ab, integer *ldab, complex *x, integer *incx, real *beta, real *y, integer *incy); doublereal cla_gbrcond_c__(char *trans, integer *n, integer *kl, integer *ku, complex *ab, integer *ldab, complex *afb, integer *ldafb, integer * ipiv, real *c__, logical *capply, integer *info, complex *work, real * rwork, ftnlen trans_len); doublereal cla_gbrcond_x__(char *trans, integer *n, integer *kl, integer *ku, complex *ab, integer *ldab, complex *afb, integer *ldafb, integer * ipiv, complex *x, integer *info, complex *work, real *rwork, ftnlen trans_len); /* Subroutine */ int cla_gbrfsx_extended__(integer *prec_type__, integer * trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs, complex *ab, integer *ldab, complex *afb, integer *ldafb, integer * ipiv, logical *colequ, real *c__, complex *b, integer *ldb, complex * y, integer *ldy, real *berr_out__, integer *n_norms__, real *errs_n__, real *errs_c__, complex *res, real *ayb, complex *dy, complex * y_tail__, real *rcond, integer *ithresh, real *rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info); doublereal cla_gbrpvgrw__(integer *n, integer *kl, integer *ku, integer * ncols, complex *ab, integer *ldab, complex *afb, integer *ldafb); /* Subroutine */ int cla_geamv__(integer *trans, integer *m, integer *n, real *alpha, complex *a, integer *lda, complex *x, integer *incx, real * beta, real *y, integer *incy); doublereal cla_gercond_c__(char *trans, integer *n, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply, integer *info, complex *work, real *rwork, ftnlen trans_len); doublereal cla_gercond_x__(char *trans, integer *n, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *x, integer *info, complex *work, real *rwork, ftnlen trans_len); /* Subroutine */ int cla_gerfsx_extended__(integer *prec_type__, integer * trans_type__, integer *n, integer *nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, logical *colequ, real *c__, complex *b, integer *ldb, complex *y, integer *ldy, real *berr_out__, integer *n_norms__, real *errs_n__, real *errs_c__, complex *res, real *ayb, complex *dy, complex *y_tail__, real *rcond, integer * ithresh, real *rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info); /* Subroutine */ int cla_heamv__(integer *uplo, integer *n, real *alpha, complex *a, integer *lda, complex *x, integer *incx, real *beta, real *y, integer *incy); doublereal cla_hercond_c__(char *uplo, integer *n, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply, integer *info, complex *work, real *rwork, ftnlen uplo_len); doublereal cla_hercond_x__(char *uplo, integer *n, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *x, integer *info, complex *work, real *rwork, ftnlen uplo_len); /* Subroutine */ int cla_herfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, logical *colequ, real *c__, complex *b, integer *ldb, complex *y, integer *ldy, real *berr_out__, integer * n_norms__, real *errs_n__, real *errs_c__, complex *res, real *ayb, complex *dy, complex *y_tail__, real *rcond, integer *ithresh, real * rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info, ftnlen uplo_len); doublereal cla_herpvgrw__(char *uplo, integer *n, integer *info, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, real *work, ftnlen uplo_len); /* Subroutine */ int cla_lin_berr__(integer *n, integer *nz, integer *nrhs, complex *res, real *ayb, real *berr); doublereal cla_porcond_c__(char *uplo, integer *n, complex *a, integer *lda, complex *af, integer *ldaf, real *c__, logical *capply, integer *info, complex *work, real *rwork, ftnlen uplo_len); doublereal cla_porcond_x__(char *uplo, integer *n, complex *a, integer *lda, complex *af, integer *ldaf, complex *x, integer *info, complex *work, real *rwork, ftnlen uplo_len); /* Subroutine */ int cla_porfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, complex *a, integer *lda, complex *af, integer *ldaf, logical *colequ, real *c__, complex *b, integer *ldb, complex *y, integer *ldy, real *berr_out__, integer *n_norms__, real * errs_n__, real *errs_c__, complex *res, real *ayb, complex *dy, complex *y_tail__, real *rcond, integer *ithresh, real *rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info, ftnlen uplo_len); doublereal cla_porpvgrw__(char *uplo, integer *ncols, complex *a, integer * lda, complex *af, integer *ldaf, real *work, ftnlen uplo_len); doublereal cla_rpvgrw__(integer *n, integer *ncols, complex *a, integer *lda, complex *af, integer *ldaf); /* Subroutine */ int cla_syamv__(integer *uplo, integer *n, real *alpha, complex *a, integer *lda, complex *x, integer *incx, real *beta, real *y, integer *incy); doublereal cla_syrcond_c__(char *uplo, integer *n, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply, integer *info, complex *work, real *rwork, ftnlen uplo_len); doublereal cla_syrcond_x__(char *uplo, integer *n, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *x, integer *info, complex *work, real *rwork, ftnlen uplo_len); /* Subroutine */ int cla_syrfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, logical *colequ, real *c__, complex *b, integer *ldb, complex *y, integer *ldy, real *berr_out__, integer * n_norms__, real *errs_n__, real *errs_c__, complex *res, real *ayb, complex *dy, complex *y_tail__, real *rcond, integer *ithresh, real * rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info, ftnlen uplo_len); doublereal cla_syrpvgrw__(char *uplo, integer *n, integer *info, complex *a, integer *lda, complex *af, integer *ldaf, integer *ipiv, real *work, ftnlen uplo_len); /* Subroutine */ int cla_wwaddw__(integer *n, complex *x, complex *y, complex *w); /* Subroutine */ int clabrd_(integer *m, integer *n, integer *nb, complex *a, integer *lda, real *d__, real *e, complex *tauq, complex *taup, complex *x, integer *ldx, complex *y, integer *ldy); /* Subroutine */ int clacgv_(integer *n, complex *x, integer *incx); /* Subroutine */ int clacn2_(integer *n, complex *v, complex *x, real *est, integer *kase, integer *isave); /* Subroutine */ int clacon_(integer *n, complex *v, complex *x, real *est, integer *kase); /* Subroutine */ int clacp2_(char *uplo, integer *m, integer *n, real *a, integer *lda, complex *b, integer *ldb); /* Subroutine */ int clacpy_(char *uplo, integer *m, integer *n, complex *a, integer *lda, complex *b, integer *ldb); /* Subroutine */ int clacrm_(integer *m, integer *n, complex *a, integer *lda, real *b, integer *ldb, complex *c__, integer *ldc, real *rwork); /* Subroutine */ int clacrt_(integer *n, complex *cx, integer *incx, complex * cy, integer *incy, complex *c__, complex *s); /* Complex */ VOID cladiv_(complex * ret_val, complex *x, complex *y); /* Subroutine */ int claed0_(integer *qsiz, integer *n, real *d__, real *e, complex *q, integer *ldq, complex *qstore, integer *ldqs, real *rwork, integer *iwork, integer *info); /* Subroutine */ int claed7_(integer *n, integer *cutpnt, integer *qsiz, integer *tlvls, integer *curlvl, integer *curpbm, real *d__, complex * q, integer *ldq, real *rho, integer *indxq, real *qstore, integer * qptr, integer *prmptr, integer *perm, integer *givptr, integer * givcol, real *givnum, complex *work, real *rwork, integer *iwork, integer *info); /* Subroutine */ int claed8_(integer *k, integer *n, integer *qsiz, complex * q, integer *ldq, real *d__, real *rho, integer *cutpnt, real *z__, real *dlamda, complex *q2, integer *ldq2, real *w, integer *indxp, integer *indx, integer *indxq, integer *perm, integer *givptr, integer *givcol, real *givnum, integer *info); /* Subroutine */ int claein_(logical *rightv, logical *noinit, integer *n, complex *h__, integer *ldh, complex *w, complex *v, complex *b, integer *ldb, real *rwork, real *eps3, real *smlnum, integer *info); /* Subroutine */ int claesy_(complex *a, complex *b, complex *c__, complex * rt1, complex *rt2, complex *evscal, complex *cs1, complex *sn1); /* Subroutine */ int claev2_(complex *a, complex *b, complex *c__, real *rt1, real *rt2, real *cs1, complex *sn1); /* Subroutine */ int clag2z_(integer *m, integer *n, complex *sa, integer * ldsa, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int clags2_(logical *upper, real *a1, complex *a2, real *a3, real *b1, complex *b2, real *b3, real *csu, complex *snu, real *csv, complex *snv, real *csq, complex *snq); /* Subroutine */ int clagtm_(char *trans, integer *n, integer *nrhs, real * alpha, complex *dl, complex *d__, complex *du, complex *x, integer * ldx, real *beta, complex *b, integer *ldb); /* Subroutine */ int clahef_(char *uplo, integer *n, integer *nb, integer *kb, complex *a, integer *lda, integer *ipiv, complex *w, integer *ldw, integer *info); /* Subroutine */ int clahqr_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *w, integer *iloz, integer *ihiz, complex *z__, integer *ldz, integer * info); /* Subroutine */ int clahr2_(integer *n, integer *k, integer *nb, complex *a, integer *lda, complex *tau, complex *t, integer *ldt, complex *y, integer *ldy); /* Subroutine */ int clahrd_(integer *n, integer *k, integer *nb, complex *a, integer *lda, complex *tau, complex *t, integer *ldt, complex *y, integer *ldy); /* Subroutine */ int claic1_(integer *job, integer *j, complex *x, real *sest, complex *w, complex *gamma, real *sestpr, complex *s, complex *c__); /* Subroutine */ int clals0_(integer *icompq, integer *nl, integer *nr, integer *sqre, integer *nrhs, complex *b, integer *ldb, complex *bx, integer *ldbx, integer *perm, integer *givptr, integer *givcol, integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real * difl, real *difr, real *z__, integer *k, real *c__, real *s, real * rwork, integer *info); /* Subroutine */ int clalsa_(integer *icompq, integer *smlsiz, integer *n, integer *nrhs, complex *b, integer *ldb, complex *bx, integer *ldbx, real *u, integer *ldu, real *vt, integer *k, real *difl, real *difr, real *z__, real *poles, integer *givptr, integer *givcol, integer * ldgcol, integer *perm, real *givnum, real *c__, real *s, real *rwork, integer *iwork, integer *info); /* Subroutine */ int clalsd_(char *uplo, integer *smlsiz, integer *n, integer *nrhs, real *d__, real *e, complex *b, integer *ldb, real *rcond, integer *rank, complex *work, real *rwork, integer *iwork, integer * info); doublereal clangb_(char *norm, integer *n, integer *kl, integer *ku, complex * ab, integer *ldab, real *work); doublereal clange_(char *norm, integer *m, integer *n, complex *a, integer * lda, real *work); doublereal clangt_(char *norm, integer *n, complex *dl, complex *d__, complex *du); doublereal clanhb_(char *norm, char *uplo, integer *n, integer *k, complex * ab, integer *ldab, real *work); doublereal clanhe_(char *norm, char *uplo, integer *n, complex *a, integer * lda, real *work); doublereal clanhf_(char *norm, char *transr, char *uplo, integer *n, complex * a, real *work); doublereal clanhp_(char *norm, char *uplo, integer *n, complex *ap, real * work); doublereal clanhs_(char *norm, integer *n, complex *a, integer *lda, real * work); doublereal clanht_(char *norm, integer *n, real *d__, complex *e); doublereal clansb_(char *norm, char *uplo, integer *n, integer *k, complex * ab, integer *ldab, real *work); doublereal clansp_(char *norm, char *uplo, integer *n, complex *ap, real * work); doublereal clansy_(char *norm, char *uplo, integer *n, complex *a, integer * lda, real *work); doublereal clantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, complex *ab, integer *ldab, real *work); doublereal clantp_(char *norm, char *uplo, char *diag, integer *n, complex * ap, real *work); doublereal clantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, complex *a, integer *lda, real *work); /* Subroutine */ int clapll_(integer *n, complex *x, integer *incx, complex * y, integer *incy, real *ssmin); /* Subroutine */ int clapmt_(logical *forwrd, integer *m, integer *n, complex *x, integer *ldx, integer *k); /* Subroutine */ int claqgb_(integer *m, integer *n, integer *kl, integer *ku, complex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, char *equed); /* Subroutine */ int claqge_(integer *m, integer *n, complex *a, integer *lda, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, char * equed); /* Subroutine */ int claqhb_(char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, real *s, real *scond, real *amax, char *equed); /* Subroutine */ int claqhe_(char *uplo, integer *n, complex *a, integer *lda, real *s, real *scond, real *amax, char *equed); /* Subroutine */ int claqhp_(char *uplo, integer *n, complex *ap, real *s, real *scond, real *amax, char *equed); /* Subroutine */ int claqp2_(integer *m, integer *n, integer *offset, complex *a, integer *lda, integer *jpvt, complex *tau, real *vn1, real *vn2, complex *work); /* Subroutine */ int claqps_(integer *m, integer *n, integer *offset, integer *nb, integer *kb, complex *a, integer *lda, integer *jpvt, complex * tau, real *vn1, real *vn2, complex *auxv, complex *f, integer *ldf); /* Subroutine */ int claqr0_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *w, integer *iloz, integer *ihiz, complex *z__, integer *ldz, complex * work, integer *lwork, integer *info); /* Subroutine */ int claqr1_(integer *n, complex *h__, integer *ldh, complex * s1, complex *s2, complex *v); /* Subroutine */ int claqr2_(logical *wantt, logical *wantz, integer *n, integer *ktop, integer *kbot, integer *nw, complex *h__, integer *ldh, integer *iloz, integer *ihiz, complex *z__, integer *ldz, integer * ns, integer *nd, complex *sh, complex *v, integer *ldv, integer *nh, complex *t, integer *ldt, integer *nv, complex *wv, integer *ldwv, complex *work, integer *lwork); /* Subroutine */ int claqr3_(logical *wantt, logical *wantz, integer *n, integer *ktop, integer *kbot, integer *nw, complex *h__, integer *ldh, integer *iloz, integer *ihiz, complex *z__, integer *ldz, integer * ns, integer *nd, complex *sh, complex *v, integer *ldv, integer *nh, complex *t, integer *ldt, integer *nv, complex *wv, integer *ldwv, complex *work, integer *lwork); /* Subroutine */ int claqr4_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *w, integer *iloz, integer *ihiz, complex *z__, integer *ldz, complex * work, integer *lwork, integer *info); /* Subroutine */ int claqr5_(logical *wantt, logical *wantz, integer *kacc22, integer *n, integer *ktop, integer *kbot, integer *nshfts, complex *s, complex *h__, integer *ldh, integer *iloz, integer *ihiz, complex * z__, integer *ldz, complex *v, integer *ldv, complex *u, integer *ldu, integer *nv, complex *wv, integer *ldwv, integer *nh, complex *wh, integer *ldwh); /* Subroutine */ int claqsb_(char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, real *s, real *scond, real *amax, char *equed); /* Subroutine */ int claqsp_(char *uplo, integer *n, complex *ap, real *s, real *scond, real *amax, char *equed); /* Subroutine */ int claqsy_(char *uplo, integer *n, complex *a, integer *lda, real *s, real *scond, real *amax, char *equed); /* Subroutine */ int clar1v_(integer *n, integer *b1, integer *bn, real * lambda, real *d__, real *l, real *ld, real *lld, real *pivmin, real * gaptol, complex *z__, logical *wantnc, integer *negcnt, real *ztz, real *mingma, integer *r__, integer *isuppz, real *nrminv, real * resid, real *rqcorr, real *work); /* Subroutine */ int clar2v_(integer *n, complex *x, complex *y, complex *z__, integer *incx, real *c__, complex *s, integer *incc); /* Subroutine */ int clarcm_(integer *m, integer *n, real *a, integer *lda, complex *b, integer *ldb, complex *c__, integer *ldc, real *rwork); /* Subroutine */ int clarf_(char *side, integer *m, integer *n, complex *v, integer *incv, complex *tau, complex *c__, integer *ldc, complex * work); /* Subroutine */ int clarfb_(char *side, char *trans, char *direct, char * storev, integer *m, integer *n, integer *k, complex *v, integer *ldv, complex *t, integer *ldt, complex *c__, integer *ldc, complex *work, integer *ldwork); /* Subroutine */ int clarfg_(integer *n, complex *alpha, complex *x, integer * incx, complex *tau); /* Subroutine */ int clarfp_(integer *n, complex *alpha, complex *x, integer * incx, complex *tau); /* Subroutine */ int clarft_(char *direct, char *storev, integer *n, integer * k, complex *v, integer *ldv, complex *tau, complex *t, integer *ldt); /* Subroutine */ int clarfx_(char *side, integer *m, integer *n, complex *v, complex *tau, complex *c__, integer *ldc, complex *work); /* Subroutine */ int clargv_(integer *n, complex *x, integer *incx, complex * y, integer *incy, real *c__, integer *incc); /* Subroutine */ int clarnv_(integer *idist, integer *iseed, integer *n, complex *x); /* Subroutine */ int clarrv_(integer *n, real *vl, real *vu, real *d__, real * l, real *pivmin, integer *isplit, integer *m, integer *dol, integer * dou, real *minrgp, real *rtol1, real *rtol2, real *w, real *werr, real *wgap, integer *iblock, integer *indexw, real *gers, complex * z__, integer *ldz, integer *isuppz, real *work, integer *iwork, integer *info); /* Subroutine */ int clarscl2_(integer *m, integer *n, real *d__, complex *x, integer *ldx); /* Subroutine */ int clartg_(complex *f, complex *g, real *cs, complex *sn, complex *r__); /* Subroutine */ int clartv_(integer *n, complex *x, integer *incx, complex * y, integer *incy, real *c__, complex *s, integer *incc); /* Subroutine */ int clarz_(char *side, integer *m, integer *n, integer *l, complex *v, integer *incv, complex *tau, complex *c__, integer *ldc, complex *work); /* Subroutine */ int clarzb_(char *side, char *trans, char *direct, char * storev, integer *m, integer *n, integer *k, integer *l, complex *v, integer *ldv, complex *t, integer *ldt, complex *c__, integer *ldc, complex *work, integer *ldwork); /* Subroutine */ int clarzt_(char *direct, char *storev, integer *n, integer * k, complex *v, integer *ldv, complex *tau, complex *t, integer *ldt); /* Subroutine */ int clascl_(char *type__, integer *kl, integer *ku, real * cfrom, real *cto, integer *m, integer *n, complex *a, integer *lda, integer *info); /* Subroutine */ int clascl2_(integer *m, integer *n, real *d__, complex *x, integer *ldx); /* Subroutine */ int claset_(char *uplo, integer *m, integer *n, complex * alpha, complex *beta, complex *a, integer *lda); /* Subroutine */ int clasr_(char *side, char *pivot, char *direct, integer *m, integer *n, real *c__, real *s, complex *a, integer *lda); /* Subroutine */ int classq_(integer *n, complex *x, integer *incx, real * scale, real *sumsq); /* Subroutine */ int claswp_(integer *n, complex *a, integer *lda, integer * k1, integer *k2, integer *ipiv, integer *incx); /* Subroutine */ int clasyf_(char *uplo, integer *n, integer *nb, integer *kb, complex *a, integer *lda, integer *ipiv, complex *w, integer *ldw, integer *info); /* Subroutine */ int clatbs_(char *uplo, char *trans, char *diag, char * normin, integer *n, integer *kd, complex *ab, integer *ldab, complex * x, real *scale, real *cnorm, integer *info); /* Subroutine */ int clatdf_(integer *ijob, integer *n, complex *z__, integer *ldz, complex *rhs, real *rdsum, real *rdscal, integer *ipiv, integer *jpiv); /* Subroutine */ int clatps_(char *uplo, char *trans, char *diag, char * normin, integer *n, complex *ap, complex *x, real *scale, real *cnorm, integer *info); /* Subroutine */ int clatrd_(char *uplo, integer *n, integer *nb, complex *a, integer *lda, real *e, complex *tau, complex *w, integer *ldw); /* Subroutine */ int clatrs_(char *uplo, char *trans, char *diag, char * normin, integer *n, complex *a, integer *lda, complex *x, real *scale, real *cnorm, integer *info); /* Subroutine */ int clatrz_(integer *m, integer *n, integer *l, complex *a, integer *lda, complex *tau, complex *work); /* Subroutine */ int clatzm_(char *side, integer *m, integer *n, complex *v, integer *incv, complex *tau, complex *c1, complex *c2, integer *ldc, complex *work); /* Subroutine */ int clauu2_(char *uplo, integer *n, complex *a, integer *lda, integer *info); /* Subroutine */ int clauum_(char *uplo, integer *n, complex *a, integer *lda, integer *info); /* Subroutine */ int cpbcon_(char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, real *anorm, real *rcond, complex *work, real *rwork, integer *info); /* Subroutine */ int cpbequ_(char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, real *s, real *scond, real *amax, integer *info); /* Subroutine */ int cpbrfs_(char *uplo, integer *n, integer *kd, integer * nrhs, complex *ab, integer *ldab, complex *afb, integer *ldafb, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real * berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cpbstf_(char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, integer *info); /* Subroutine */ int cpbsv_(char *uplo, integer *n, integer *kd, integer * nrhs, complex *ab, integer *ldab, complex *b, integer *ldb, integer * info); /* Subroutine */ int cpbsvx_(char *fact, char *uplo, integer *n, integer *kd, integer *nrhs, complex *ab, integer *ldab, complex *afb, integer * ldafb, char *equed, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cpbtf2_(char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, integer *info); /* Subroutine */ int cpbtrf_(char *uplo, integer *n, integer *kd, complex *ab, integer *ldab, integer *info); /* Subroutine */ int cpbtrs_(char *uplo, integer *n, integer *kd, integer * nrhs, complex *ab, integer *ldab, complex *b, integer *ldb, integer * info); /* Subroutine */ int cpftrf_(char *transr, char *uplo, integer *n, complex *a, integer *info); /* Subroutine */ int cpftri_(char *transr, char *uplo, integer *n, complex *a, integer *info); /* Subroutine */ int cpftrs_(char *transr, char *uplo, integer *n, integer * nrhs, complex *a, complex *b, integer *ldb, integer *info); /* Subroutine */ int cpocon_(char *uplo, integer *n, complex *a, integer *lda, real *anorm, real *rcond, complex *work, real *rwork, integer *info); /* Subroutine */ int cpoequ_(integer *n, complex *a, integer *lda, real *s, real *scond, real *amax, integer *info); /* Subroutine */ int cpoequb_(integer *n, complex *a, integer *lda, real *s, real *scond, real *amax, integer *info); /* Subroutine */ int cporfs_(char *uplo, integer *n, integer *nrhs, complex * a, integer *lda, complex *af, integer *ldaf, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cporfsx_(char *uplo, char *equed, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real * err_bnds_comp__, integer *nparams, real *params, complex *work, real * rwork, integer *info); /* Subroutine */ int cposv_(char *uplo, integer *n, integer *nrhs, complex *a, integer *lda, complex *b, integer *ldb, integer *info); /* Subroutine */ int cposvx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, char * equed, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cposvxx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, char * equed, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, integer *n_err_bnds__, real * err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real * params, complex *work, real *rwork, integer *info); /* Subroutine */ int cpotf2_(char *uplo, integer *n, complex *a, integer *lda, integer *info); /* Subroutine */ int cpotrf_(char *uplo, integer *n, complex *a, integer *lda, integer *info); /* Subroutine */ int cpotri_(char *uplo, integer *n, complex *a, integer *lda, integer *info); /* Subroutine */ int cpotrs_(char *uplo, integer *n, integer *nrhs, complex * a, integer *lda, complex *b, integer *ldb, integer *info); /* Subroutine */ int cppcon_(char *uplo, integer *n, complex *ap, real *anorm, real *rcond, complex *work, real *rwork, integer *info); /* Subroutine */ int cppequ_(char *uplo, integer *n, complex *ap, real *s, real *scond, real *amax, integer *info); /* Subroutine */ int cpprfs_(char *uplo, integer *n, integer *nrhs, complex * ap, complex *afp, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cppsv_(char *uplo, integer *n, integer *nrhs, complex * ap, complex *b, integer *ldb, integer *info); /* Subroutine */ int cppsvx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *ap, complex *afp, char *equed, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cpptrf_(char *uplo, integer *n, complex *ap, integer * info); /* Subroutine */ int cpptri_(char *uplo, integer *n, complex *ap, integer * info); /* Subroutine */ int cpptrs_(char *uplo, integer *n, integer *nrhs, complex * ap, complex *b, integer *ldb, integer *info); /* Subroutine */ int cpstf2_(char *uplo, integer *n, complex *a, integer *lda, integer *piv, integer *rank, real *tol, real *work, integer *info); /* Subroutine */ int cpstrf_(char *uplo, integer *n, complex *a, integer *lda, integer *piv, integer *rank, real *tol, real *work, integer *info); /* Subroutine */ int cptcon_(integer *n, real *d__, complex *e, real *anorm, real *rcond, real *rwork, integer *info); /* Subroutine */ int cpteqr_(char *compz, integer *n, real *d__, real *e, complex *z__, integer *ldz, real *work, integer *info); /* Subroutine */ int cptrfs_(char *uplo, integer *n, integer *nrhs, real *d__, complex *e, real *df, complex *ef, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cptsv_(integer *n, integer *nrhs, real *d__, complex *e, complex *b, integer *ldb, integer *info); /* Subroutine */ int cptsvx_(char *fact, integer *n, integer *nrhs, real *d__, complex *e, real *df, complex *ef, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cpttrf_(integer *n, real *d__, complex *e, integer *info); /* Subroutine */ int cpttrs_(char *uplo, integer *n, integer *nrhs, real *d__, complex *e, complex *b, integer *ldb, integer *info); /* Subroutine */ int cptts2_(integer *iuplo, integer *n, integer *nrhs, real * d__, complex *e, complex *b, integer *ldb); /* Subroutine */ int crot_(integer *n, complex *cx, integer *incx, complex * cy, integer *incy, real *c__, complex *s); /* Subroutine */ int cspcon_(char *uplo, integer *n, complex *ap, integer * ipiv, real *anorm, real *rcond, complex *work, integer *info); /* Subroutine */ int cspmv_(char *uplo, integer *n, complex *alpha, complex * ap, complex *x, integer *incx, complex *beta, complex *y, integer * incy); /* Subroutine */ int cspr_(char *uplo, integer *n, complex *alpha, complex *x, integer *incx, complex *ap); /* Subroutine */ int csprfs_(char *uplo, integer *n, integer *nrhs, complex * ap, complex *afp, integer *ipiv, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int cspsv_(char *uplo, integer *n, integer *nrhs, complex * ap, integer *ipiv, complex *b, integer *ldb, integer *info); /* Subroutine */ int cspsvx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *ap, complex *afp, integer *ipiv, complex *b, integer * ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int csptrf_(char *uplo, integer *n, complex *ap, integer * ipiv, integer *info); /* Subroutine */ int csptri_(char *uplo, integer *n, complex *ap, integer * ipiv, complex *work, integer *info); /* Subroutine */ int csptrs_(char *uplo, integer *n, integer *nrhs, complex * ap, integer *ipiv, complex *b, integer *ldb, integer *info); /* Subroutine */ int csrscl_(integer *n, real *sa, complex *sx, integer *incx); /* Subroutine */ int cstedc_(char *compz, integer *n, real *d__, real *e, complex *z__, integer *ldz, complex *work, integer *lwork, real * rwork, integer *lrwork, integer *iwork, integer *liwork, integer * info); /* Subroutine */ int cstegr_(char *jobz, char *range, integer *n, real *d__, real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, complex *z__, integer *ldz, integer *isuppz, real *work, integer *lwork, integer *iwork, integer *liwork, integer * info); /* Subroutine */ int cstein_(integer *n, real *d__, real *e, integer *m, real *w, integer *iblock, integer *isplit, complex *z__, integer *ldz, real *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int cstemr_(char *jobz, char *range, integer *n, real *d__, real *e, real *vl, real *vu, integer *il, integer *iu, integer *m, real *w, complex *z__, integer *ldz, integer *nzc, integer *isuppz, logical *tryrac, real *work, integer *lwork, integer *iwork, integer * liwork, integer *info); /* Subroutine */ int csteqr_(char *compz, integer *n, real *d__, real *e, complex *z__, integer *ldz, real *work, integer *info); /* Subroutine */ int csycon_(char *uplo, integer *n, complex *a, integer *lda, integer *ipiv, real *anorm, real *rcond, complex *work, integer * info); /* Subroutine */ int csyequb_(char *uplo, integer *n, complex *a, integer * lda, real *s, real *scond, real *amax, complex *work, integer *info); /* Subroutine */ int csymv_(char *uplo, integer *n, complex *alpha, complex * a, integer *lda, complex *x, integer *incx, complex *beta, complex *y, integer *incy); /* Subroutine */ int csyr_(char *uplo, integer *n, complex *alpha, complex *x, integer *incx, complex *a, integer *lda); /* Subroutine */ int csyrfs_(char *uplo, integer *n, integer *nrhs, complex * a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex * b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int csyrfsx_(char *uplo, char *equed, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *params, complex *work, real *rwork, integer *info); /* Subroutine */ int csysv_(char *uplo, integer *n, integer *nrhs, complex *a, integer *lda, integer *ipiv, complex *b, integer *ldb, complex *work, integer *lwork, integer *info); /* Subroutine */ int csysvx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, integer *lwork, real *rwork, integer *info); /* Subroutine */ int csysvxx_(char *fact, char *uplo, integer *n, integer * nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer * ipiv, char *equed, real *s, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, integer * n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer * nparams, real *params, complex *work, real *rwork, integer *info); /* Subroutine */ int csytf2_(char *uplo, integer *n, complex *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int csytrf_(char *uplo, integer *n, complex *a, integer *lda, integer *ipiv, complex *work, integer *lwork, integer *info); /* Subroutine */ int csytri_(char *uplo, integer *n, complex *a, integer *lda, integer *ipiv, complex *work, integer *info); /* Subroutine */ int csytrs_(char *uplo, integer *n, integer *nrhs, complex * a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer * info); /* Subroutine */ int ctbcon_(char *norm, char *uplo, char *diag, integer *n, integer *kd, complex *ab, integer *ldab, real *rcond, complex *work, real *rwork, integer *info); /* Subroutine */ int ctbrfs_(char *uplo, char *trans, char *diag, integer *n, integer *kd, integer *nrhs, complex *ab, integer *ldab, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int ctbtrs_(char *uplo, char *trans, char *diag, integer *n, integer *kd, integer *nrhs, complex *ab, integer *ldab, complex *b, integer *ldb, integer *info); /* Subroutine */ int ctfsm_(char *transr, char *side, char *uplo, char *trans, char *diag, integer *m, integer *n, complex *alpha, complex *a, complex *b, integer *ldb); /* Subroutine */ int ctftri_(char *transr, char *uplo, char *diag, integer *n, complex *a, integer *info); /* Subroutine */ int ctfttp_(char *transr, char *uplo, integer *n, complex * arf, complex *ap, integer *info); /* Subroutine */ int ctfttr_(char *transr, char *uplo, integer *n, complex * arf, complex *a, integer *lda, integer *info); /* Subroutine */ int ctgevc_(char *side, char *howmny, logical *select, integer *n, complex *s, integer *lds, complex *p, integer *ldp, complex *vl, integer *ldvl, complex *vr, integer *ldvr, integer *mm, integer *m, complex *work, real *rwork, integer *info); /* Subroutine */ int ctgex2_(logical *wantq, logical *wantz, integer *n, complex *a, integer *lda, complex *b, integer *ldb, complex *q, integer *ldq, complex *z__, integer *ldz, integer *j1, integer *info); /* Subroutine */ int ctgexc_(logical *wantq, logical *wantz, integer *n, complex *a, integer *lda, complex *b, integer *ldb, complex *q, integer *ldq, complex *z__, integer *ldz, integer *ifst, integer * ilst, integer *info); /* Subroutine */ int ctgsen_(integer *ijob, logical *wantq, logical *wantz, logical *select, integer *n, complex *a, integer *lda, complex *b, integer *ldb, complex *alpha, complex *beta, complex *q, integer *ldq, complex *z__, integer *ldz, integer *m, real *pl, real *pr, real * dif, complex *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int ctgsja_(char *jobu, char *jobv, char *jobq, integer *m, integer *p, integer *n, integer *k, integer *l, complex *a, integer * lda, complex *b, integer *ldb, real *tola, real *tolb, real *alpha, real *beta, complex *u, integer *ldu, complex *v, integer *ldv, complex *q, integer *ldq, complex *work, integer *ncycle, integer * info); /* Subroutine */ int ctgsna_(char *job, char *howmny, logical *select, integer *n, complex *a, integer *lda, complex *b, integer *ldb, complex *vl, integer *ldvl, complex *vr, integer *ldvr, real *s, real *dif, integer *mm, integer *m, complex *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int ctgsy2_(char *trans, integer *ijob, integer *m, integer * n, complex *a, integer *lda, complex *b, integer *ldb, complex *c__, integer *ldc, complex *d__, integer *ldd, complex *e, integer *lde, complex *f, integer *ldf, real *scale, real *rdsum, real *rdscal, integer *info); /* Subroutine */ int ctgsyl_(char *trans, integer *ijob, integer *m, integer * n, complex *a, integer *lda, complex *b, integer *ldb, complex *c__, integer *ldc, complex *d__, integer *ldd, complex *e, integer *lde, complex *f, integer *ldf, real *scale, real *dif, complex *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int ctpcon_(char *norm, char *uplo, char *diag, integer *n, complex *ap, real *rcond, complex *work, real *rwork, integer *info); /* Subroutine */ int ctprfs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, complex *ap, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int ctptri_(char *uplo, char *diag, integer *n, complex *ap, integer *info); /* Subroutine */ int ctptrs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, complex *ap, complex *b, integer *ldb, integer *info); /* Subroutine */ int ctpttf_(char *transr, char *uplo, integer *n, complex * ap, complex *arf, integer *info); /* Subroutine */ int ctpttr_(char *uplo, integer *n, complex *ap, complex *a, integer *lda, integer *info); /* Subroutine */ int ctrcon_(char *norm, char *uplo, char *diag, integer *n, complex *a, integer *lda, real *rcond, complex *work, real *rwork, integer *info); /* Subroutine */ int ctrevc_(char *side, char *howmny, logical *select, integer *n, complex *t, integer *ldt, complex *vl, integer *ldvl, complex *vr, integer *ldvr, integer *mm, integer *m, complex *work, real *rwork, integer *info); /* Subroutine */ int ctrexc_(char *compq, integer *n, complex *t, integer * ldt, complex *q, integer *ldq, integer *ifst, integer *ilst, integer * info); /* Subroutine */ int ctrrfs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, complex *a, integer *lda, complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, integer *info); /* Subroutine */ int ctrsen_(char *job, char *compq, logical *select, integer *n, complex *t, integer *ldt, complex *q, integer *ldq, complex *w, integer *m, real *s, real *sep, complex *work, integer *lwork, integer *info); /* Subroutine */ int ctrsna_(char *job, char *howmny, logical *select, integer *n, complex *t, integer *ldt, complex *vl, integer *ldvl, complex *vr, integer *ldvr, real *s, real *sep, integer *mm, integer * m, complex *work, integer *ldwork, real *rwork, integer *info); /* Subroutine */ int ctrsyl_(char *trana, char *tranb, integer *isgn, integer *m, integer *n, complex *a, integer *lda, complex *b, integer *ldb, complex *c__, integer *ldc, real *scale, integer *info); /* Subroutine */ int ctrti2_(char *uplo, char *diag, integer *n, complex *a, integer *lda, integer *info); /* Subroutine */ int ctrtri_(char *uplo, char *diag, integer *n, complex *a, integer *lda, integer *info); /* Subroutine */ int ctrtrs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, complex *a, integer *lda, complex *b, integer *ldb, integer *info); /* Subroutine */ int ctrttf_(char *transr, char *uplo, integer *n, complex *a, integer *lda, complex *arf, integer *info); /* Subroutine */ int ctrttp_(char *uplo, integer *n, complex *a, integer *lda, complex *ap, integer *info); /* Subroutine */ int ctzrqf_(integer *m, integer *n, complex *a, integer *lda, complex *tau, integer *info); /* Subroutine */ int ctzrzf_(integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cung2l_(integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cung2r_(integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cungbr_(char *vect, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cunghr_(integer *n, integer *ilo, integer *ihi, complex * a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cungl2_(integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cunglq_(integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer * info); /* Subroutine */ int cungql_(integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer * info); /* Subroutine */ int cungqr_(integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer * info); /* Subroutine */ int cungr2_(integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *info); /* Subroutine */ int cungrq_(integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer * info); /* Subroutine */ int cungtr_(char *uplo, integer *n, complex *a, integer *lda, complex *tau, complex *work, integer *lwork, integer *info); /* Subroutine */ int cunm2l_(char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *info); /* Subroutine */ int cunm2r_(char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *info); /* Subroutine */ int cunmbr_(char *vect, char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *lwork, integer * info); /* Subroutine */ int cunmhr_(char *side, char *trans, integer *m, integer *n, integer *ilo, integer *ihi, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *lwork, integer * info); /* Subroutine */ int cunml2_(char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *info); /* Subroutine */ int cunmlq_(char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *lwork, integer *info); /* Subroutine */ int cunmql_(char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *lwork, integer *info); /* Subroutine */ int cunmqr_(char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *lwork, integer *info); /* Subroutine */ int cunmr2_(char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *info); /* Subroutine */ int cunmr3_(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *info); /* Subroutine */ int cunmrq_(char *side, char *trans, integer *m, integer *n, integer *k, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *lwork, integer *info); /* Subroutine */ int cunmrz_(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *lwork, integer * info); /* Subroutine */ int cunmtr_(char *side, char *uplo, char *trans, integer *m, integer *n, complex *a, integer *lda, complex *tau, complex *c__, integer *ldc, complex *work, integer *lwork, integer *info); /* Subroutine */ int cupgtr_(char *uplo, integer *n, complex *ap, complex * tau, complex *q, integer *ldq, complex *work, integer *info); /* Subroutine */ int cupmtr_(char *side, char *uplo, char *trans, integer *m, integer *n, complex *ap, complex *tau, complex *c__, integer *ldc, complex *work, integer *info); /* Subroutine */ int dbdsdc_(char *uplo, char *compq, integer *n, doublereal * d__, doublereal *e, doublereal *u, integer *ldu, doublereal *vt, integer *ldvt, doublereal *q, integer *iq, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dbdsqr_(char *uplo, integer *n, integer *ncvt, integer * nru, integer *ncc, doublereal *d__, doublereal *e, doublereal *vt, integer *ldvt, doublereal *u, integer *ldu, doublereal *c__, integer * ldc, doublereal *work, integer *info); /* Subroutine */ int ddisna_(char *job, integer *m, integer *n, doublereal * d__, doublereal *sep, integer *info); /* Subroutine */ int dgbbrd_(char *vect, integer *m, integer *n, integer *ncc, integer *kl, integer *ku, doublereal *ab, integer *ldab, doublereal * d__, doublereal *e, doublereal *q, integer *ldq, doublereal *pt, integer *ldpt, doublereal *c__, integer *ldc, doublereal *work, integer *info); /* Subroutine */ int dgbcon_(char *norm, integer *n, integer *kl, integer *ku, doublereal *ab, integer *ldab, integer *ipiv, doublereal *anorm, doublereal *rcond, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dgbequ_(integer *m, integer *n, integer *kl, integer *ku, doublereal *ab, integer *ldab, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer * info); /* Subroutine */ int dgbequb_(integer *m, integer *n, integer *kl, integer * ku, doublereal *ab, integer *ldab, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer * info); /* Subroutine */ int dgbrfs_(char *trans, integer *n, integer *kl, integer * ku, integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, integer *ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dgbrfsx_(char *trans, char *equed, integer *n, integer * kl, integer *ku, integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, integer *ipiv, doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, doublereal *x, integer * ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer * nparams, doublereal *params, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dgbsv_(integer *n, integer *kl, integer *ku, integer * nrhs, doublereal *ab, integer *ldab, integer *ipiv, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dgbsvx_(char *fact, char *trans, integer *n, integer *kl, integer *ku, integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dgbsvxx_(char *fact, char *trans, integer *n, integer * kl, integer *ku, integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *nparams, doublereal *params, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dgbtf2_(integer *m, integer *n, integer *kl, integer *ku, doublereal *ab, integer *ldab, integer *ipiv, integer *info); /* Subroutine */ int dgbtrf_(integer *m, integer *n, integer *kl, integer *ku, doublereal *ab, integer *ldab, integer *ipiv, integer *info); /* Subroutine */ int dgbtrs_(char *trans, integer *n, integer *kl, integer * ku, integer *nrhs, doublereal *ab, integer *ldab, integer *ipiv, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dgebak_(char *job, char *side, integer *n, integer *ilo, integer *ihi, doublereal *scale, integer *m, doublereal *v, integer * ldv, integer *info); /* Subroutine */ int dgebal_(char *job, integer *n, doublereal *a, integer * lda, integer *ilo, integer *ihi, doublereal *scale, integer *info); /* Subroutine */ int dgebd2_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *d__, doublereal *e, doublereal *tauq, doublereal * taup, doublereal *work, integer *info); /* Subroutine */ int dgebrd_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *d__, doublereal *e, doublereal *tauq, doublereal * taup, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgecon_(char *norm, integer *n, doublereal *a, integer * lda, doublereal *anorm, doublereal *rcond, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dgeequ_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *info); /* Subroutine */ int dgeequb_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *info); /* Subroutine */ int dgees_(char *jobvs, char *sort, L_fp select, integer *n, doublereal *a, integer *lda, integer *sdim, doublereal *wr, doublereal *wi, doublereal *vs, integer *ldvs, doublereal *work, integer *lwork, logical *bwork, integer *info); /* Subroutine */ int dgeesx_(char *jobvs, char *sort, L_fp select, char * sense, integer *n, doublereal *a, integer *lda, integer *sdim, doublereal *wr, doublereal *wi, doublereal *vs, integer *ldvs, doublereal *rconde, doublereal *rcondv, doublereal *work, integer * lwork, integer *iwork, integer *liwork, logical *bwork, integer *info); /* Subroutine */ int dgeev_(char *jobvl, char *jobvr, integer *n, doublereal * a, integer *lda, doublereal *wr, doublereal *wi, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgeevx_(char *balanc, char *jobvl, char *jobvr, char * sense, integer *n, doublereal *a, integer *lda, doublereal *wr, doublereal *wi, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, integer *ilo, integer *ihi, doublereal *scale, doublereal *abnrm, doublereal *rconde, doublereal *rcondv, doublereal *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int dgegs_(char *jobvsl, char *jobvsr, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal * alphar, doublereal *alphai, doublereal *beta, doublereal *vsl, integer *ldvsl, doublereal *vsr, integer *ldvsr, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgegv_(char *jobvl, char *jobvr, integer *n, doublereal * a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *beta, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgehd2_(integer *n, integer *ilo, integer *ihi, doublereal *a, integer *lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dgehrd_(integer *n, integer *ilo, integer *ihi, doublereal *a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgejsv_(char *joba, char *jobu, char *jobv, char *jobr, char *jobt, char *jobp, integer *m, integer *n, doublereal *a, integer *lda, doublereal *sva, doublereal *u, integer *ldu, doublereal *v, integer *ldv, doublereal *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int dgelq2_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dgelqf_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgels_(char *trans, integer *m, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgelsd_(integer *m, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal * s, doublereal *rcond, integer *rank, doublereal *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int dgelss_(integer *m, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal * s, doublereal *rcond, integer *rank, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgelsx_(integer *m, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, integer * jpvt, doublereal *rcond, integer *rank, doublereal *work, integer * info); /* Subroutine */ int dgelsy_(integer *m, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, integer * jpvt, doublereal *rcond, integer *rank, doublereal *work, integer * lwork, integer *info); /* Subroutine */ int dgeql2_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dgeqlf_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgeqp3_(integer *m, integer *n, doublereal *a, integer * lda, integer *jpvt, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgeqpf_(integer *m, integer *n, doublereal *a, integer * lda, integer *jpvt, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dgeqr2_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dgeqrf_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgerfs_(char *trans, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer * ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dgerfsx_(char *trans, char *equed, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *nparams, doublereal *params, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dgerq2_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dgerqf_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgesc2_(integer *n, doublereal *a, integer *lda, doublereal *rhs, integer *ipiv, integer *jpiv, doublereal *scale); /* Subroutine */ int dgesdd_(char *jobz, integer *m, integer *n, doublereal * a, integer *lda, doublereal *s, doublereal *u, integer *ldu, doublereal *vt, integer *ldvt, doublereal *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int dgesv_(integer *n, integer *nrhs, doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dgesvd_(char *jobu, char *jobvt, integer *m, integer *n, doublereal *a, integer *lda, doublereal *s, doublereal *u, integer * ldu, doublereal *vt, integer *ldvt, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgesvj_(char *joba, char *jobu, char *jobv, integer *m, integer *n, doublereal *a, integer *lda, doublereal *sva, integer *mv, doublereal *v, integer *ldv, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgesvx_(char *fact, char *trans, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal * rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dgesvxx_(char *fact, char *trans, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal * rcond, doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer * nparams, doublereal *params, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dgetc2_(integer *n, doublereal *a, integer *lda, integer *ipiv, integer *jpiv, integer *info); /* Subroutine */ int dgetf2_(integer *m, integer *n, doublereal *a, integer * lda, integer *ipiv, integer *info); /* Subroutine */ int dgetrf_(integer *m, integer *n, doublereal *a, integer * lda, integer *ipiv, integer *info); /* Subroutine */ int dgetri_(integer *n, doublereal *a, integer *lda, integer *ipiv, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgetrs_(char *trans, integer *n, integer *nrhs, doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer * ldb, integer *info); /* Subroutine */ int dggbak_(char *job, char *side, integer *n, integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, integer *m, doublereal *v, integer *ldv, integer *info); /* Subroutine */ int dggbal_(char *job, integer *n, doublereal *a, integer * lda, doublereal *b, integer *ldb, integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, doublereal *work, integer * info); /* Subroutine */ int dgges_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *sdim, doublereal *alphar, doublereal *alphai, doublereal *beta, doublereal *vsl, integer *ldvsl, doublereal *vsr, integer *ldvsr, doublereal *work, integer *lwork, logical *bwork, integer *info); /* Subroutine */ int dggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, char *sense, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *sdim, doublereal *alphar, doublereal *alphai, doublereal *beta, doublereal *vsl, integer *ldvsl, doublereal *vsr, integer *ldvsr, doublereal *rconde, doublereal * rcondv, doublereal *work, integer *lwork, integer *iwork, integer * liwork, logical *bwork, integer *info); /* Subroutine */ int dggev_(char *jobvl, char *jobvr, integer *n, doublereal * a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *beta, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char * sense, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar, doublereal *alphai, doublereal * beta, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, doublereal *abnrm, doublereal *bbnrm, doublereal *rconde, doublereal * rcondv, doublereal *work, integer *lwork, integer *iwork, logical * bwork, integer *info); /* Subroutine */ int dggglm_(integer *n, integer *m, integer *p, doublereal * a, integer *lda, doublereal *b, integer *ldb, doublereal *d__, doublereal *x, doublereal *y, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgghrd_(char *compq, char *compz, integer *n, integer * ilo, integer *ihi, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *q, integer *ldq, doublereal *z__, integer * ldz, integer *info); /* Subroutine */ int dgglse_(integer *m, integer *n, integer *p, doublereal * a, integer *lda, doublereal *b, integer *ldb, doublereal *c__, doublereal *d__, doublereal *x, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dggqrf_(integer *n, integer *m, integer *p, doublereal * a, integer *lda, doublereal *taua, doublereal *b, integer *ldb, doublereal *taub, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dggrqf_(integer *m, integer *p, integer *n, doublereal * a, integer *lda, doublereal *taua, doublereal *b, integer *ldb, doublereal *taub, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dggsvd_(char *jobu, char *jobv, char *jobq, integer *m, integer *n, integer *p, integer *k, integer *l, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *alpha, doublereal *beta, doublereal *u, integer *ldu, doublereal *v, integer *ldv, doublereal *q, integer *ldq, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dggsvp_(char *jobu, char *jobv, char *jobq, integer *m, integer *p, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *tola, doublereal *tolb, integer *k, integer *l, doublereal *u, integer *ldu, doublereal *v, integer *ldv, doublereal *q, integer *ldq, integer *iwork, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dgsvj0_(char *jobv, integer *m, integer *n, doublereal * a, integer *lda, doublereal *d__, doublereal *sva, integer *mv, doublereal *v, integer *ldv, doublereal *eps, doublereal *sfmin, doublereal *tol, integer *nsweep, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dgsvj1_(char *jobv, integer *m, integer *n, integer *n1, doublereal *a, integer *lda, doublereal *d__, doublereal *sva, integer *mv, doublereal *v, integer *ldv, doublereal *eps, doublereal *sfmin, doublereal *tol, integer *nsweep, doublereal *work, integer * lwork, integer *info); /* Subroutine */ int dgtcon_(char *norm, integer *n, doublereal *dl, doublereal *d__, doublereal *du, doublereal *du2, integer *ipiv, doublereal *anorm, doublereal *rcond, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dgtrfs_(char *trans, integer *n, integer *nrhs, doublereal *dl, doublereal *d__, doublereal *du, doublereal *dlf, doublereal *df, doublereal *duf, doublereal *du2, integer *ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal * ferr, doublereal *berr, doublereal *work, integer *iwork, integer * info); /* Subroutine */ int dgtsv_(integer *n, integer *nrhs, doublereal *dl, doublereal *d__, doublereal *du, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dgtsvx_(char *fact, char *trans, integer *n, integer * nrhs, doublereal *dl, doublereal *d__, doublereal *du, doublereal * dlf, doublereal *df, doublereal *duf, doublereal *du2, integer *ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal * rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dgttrf_(integer *n, doublereal *dl, doublereal *d__, doublereal *du, doublereal *du2, integer *ipiv, integer *info); /* Subroutine */ int dgttrs_(char *trans, integer *n, integer *nrhs, doublereal *dl, doublereal *d__, doublereal *du, doublereal *du2, integer *ipiv, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dgtts2_(integer *itrans, integer *n, integer *nrhs, doublereal *dl, doublereal *d__, doublereal *du, doublereal *du2, integer *ipiv, doublereal *b, integer *ldb); /* Subroutine */ int dhgeqz_(char *job, char *compq, char *compz, integer *n, integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal *t, integer *ldt, doublereal *alphar, doublereal *alphai, doublereal * beta, doublereal *q, integer *ldq, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dhsein_(char *side, char *eigsrc, char *initv, logical * select, integer *n, doublereal *h__, integer *ldh, doublereal *wr, doublereal *wi, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, integer *mm, integer *m, doublereal *work, integer * ifaill, integer *ifailr, integer *info); /* Subroutine */ int dhseqr_(char *job, char *compz, integer *n, integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal *wr, doublereal *wi, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *info); logical disnan_(doublereal *din); /* Subroutine */ int dla_gbamv__(integer *trans, integer *m, integer *n, integer *kl, integer *ku, doublereal *alpha, doublereal *ab, integer * ldab, doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); doublereal dla_gbrcond__(char *trans, integer *n, integer *kl, integer *ku, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, integer *ipiv, integer *cmode, doublereal *c__, integer *info, doublereal *work, integer *iwork, ftnlen trans_len); /* Subroutine */ int dla_gbrfsx_extended__(integer *prec_type__, integer * trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, integer *ipiv, logical *colequ, doublereal *c__, doublereal *b, integer *ldb, doublereal *y, integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal *errs_n__, doublereal *errs_c__, doublereal *res, doublereal *ayb, doublereal *dy, doublereal * y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *ignore_cwise__, integer *info); doublereal dla_gbrpvgrw__(integer *n, integer *kl, integer *ku, integer * ncols, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb); /* Subroutine */ int dla_geamv__(integer *trans, integer *m, integer *n, doublereal *alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); doublereal dla_gercond__(char *trans, integer *n, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, integer *cmode, doublereal *c__, integer *info, doublereal *work, integer *iwork, ftnlen trans_len); /* Subroutine */ int dla_gerfsx_extended__(integer *prec_type__, integer * trans_type__, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, logical *colequ, doublereal *c__, doublereal *b, integer *ldb, doublereal *y, integer * ldy, doublereal *berr_out__, integer *n_norms__, doublereal *errs_n__, doublereal *errs_c__, doublereal *res, doublereal *ayb, doublereal * dy, doublereal *y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *ignore_cwise__, integer *info); /* Subroutine */ int dla_lin_berr__(integer *n, integer *nz, integer *nrhs, doublereal *res, doublereal *ayb, doublereal *berr); doublereal dla_porcond__(char *uplo, integer *n, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *cmode, doublereal *c__, integer *info, doublereal *work, integer *iwork, ftnlen uplo_len); /* Subroutine */ int dla_porfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal * af, integer *ldaf, logical *colequ, doublereal *c__, doublereal *b, integer *ldb, doublereal *y, integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal *errs_n__, doublereal *errs_c__, doublereal *res, doublereal *ayb, doublereal *dy, doublereal * y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *ignore_cwise__, integer *info, ftnlen uplo_len); doublereal dla_porpvgrw__(char *uplo, integer *ncols, doublereal *a, integer * lda, doublereal *af, integer *ldaf, doublereal *work, ftnlen uplo_len); doublereal dla_rpvgrw__(integer *n, integer *ncols, doublereal *a, integer * lda, doublereal *af, integer *ldaf); /* Subroutine */ int dla_syamv__(integer *uplo, integer *n, doublereal *alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); doublereal dla_syrcond__(char *uplo, integer *n, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, integer *cmode, doublereal *c__, integer *info, doublereal *work, integer *iwork, ftnlen uplo_len); /* Subroutine */ int dla_syrfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal * af, integer *ldaf, integer *ipiv, logical *colequ, doublereal *c__, doublereal *b, integer *ldb, doublereal *y, integer *ldy, doublereal * berr_out__, integer *n_norms__, doublereal *errs_n__, doublereal * errs_c__, doublereal *res, doublereal *ayb, doublereal *dy, doublereal *y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *ignore_cwise__, integer *info, ftnlen uplo_len); doublereal dla_syrpvgrw__(char *uplo, integer *n, integer *info, doublereal * a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, doublereal *work, ftnlen uplo_len); /* Subroutine */ int dla_wwaddw__(integer *n, doublereal *x, doublereal *y, doublereal *w); /* Subroutine */ int dlabad_(doublereal *small, doublereal *large); /* Subroutine */ int dlabrd_(integer *m, integer *n, integer *nb, doublereal * a, integer *lda, doublereal *d__, doublereal *e, doublereal *tauq, doublereal *taup, doublereal *x, integer *ldx, doublereal *y, integer *ldy); /* Subroutine */ int dlacn2_(integer *n, doublereal *v, doublereal *x, integer *isgn, doublereal *est, integer *kase, integer *isave); /* Subroutine */ int dlacon_(integer *n, doublereal *v, doublereal *x, integer *isgn, doublereal *est, integer *kase); /* Subroutine */ int dlacpy_(char *uplo, integer *m, integer *n, doublereal * a, integer *lda, doublereal *b, integer *ldb); /* Subroutine */ int dladiv_(doublereal *a, doublereal *b, doublereal *c__, doublereal *d__, doublereal *p, doublereal *q); /* Subroutine */ int dlae2_(doublereal *a, doublereal *b, doublereal *c__, doublereal *rt1, doublereal *rt2); /* Subroutine */ int dlaebz_(integer *ijob, integer *nitmax, integer *n, integer *mmax, integer *minp, integer *nbmin, doublereal *abstol, doublereal *reltol, doublereal *pivmin, doublereal *d__, doublereal * e, doublereal *e2, integer *nval, doublereal *ab, doublereal *c__, integer *mout, integer *nab, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlaed0_(integer *icompq, integer *qsiz, integer *n, doublereal *d__, doublereal *e, doublereal *q, integer *ldq, doublereal *qstore, integer *ldqs, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlaed1_(integer *n, doublereal *d__, doublereal *q, integer *ldq, integer *indxq, doublereal *rho, integer *cutpnt, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlaed2_(integer *k, integer *n, integer *n1, doublereal * d__, doublereal *q, integer *ldq, integer *indxq, doublereal *rho, doublereal *z__, doublereal *dlamda, doublereal *w, doublereal *q2, integer *indx, integer *indxc, integer *indxp, integer *coltyp, integer *info); /* Subroutine */ int dlaed3_(integer *k, integer *n, integer *n1, doublereal * d__, doublereal *q, integer *ldq, doublereal *rho, doublereal *dlamda, doublereal *q2, integer *indx, integer *ctot, doublereal *w, doublereal *s, integer *info); /* Subroutine */ int dlaed4_(integer *n, integer *i__, doublereal *d__, doublereal *z__, doublereal *delta, doublereal *rho, doublereal *dlam, integer *info); /* Subroutine */ int dlaed5_(integer *i__, doublereal *d__, doublereal *z__, doublereal *delta, doublereal *rho, doublereal *dlam); /* Subroutine */ int dlaed6_(integer *kniter, logical *orgati, doublereal * rho, doublereal *d__, doublereal *z__, doublereal *finit, doublereal * tau, integer *info); /* Subroutine */ int dlaed7_(integer *icompq, integer *n, integer *qsiz, integer *tlvls, integer *curlvl, integer *curpbm, doublereal *d__, doublereal *q, integer *ldq, integer *indxq, doublereal *rho, integer *cutpnt, doublereal *qstore, integer *qptr, integer *prmptr, integer * perm, integer *givptr, integer *givcol, doublereal *givnum, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlaed8_(integer *icompq, integer *k, integer *n, integer *qsiz, doublereal *d__, doublereal *q, integer *ldq, integer *indxq, doublereal *rho, integer *cutpnt, doublereal *z__, doublereal *dlamda, doublereal *q2, integer *ldq2, doublereal *w, integer *perm, integer *givptr, integer *givcol, doublereal *givnum, integer *indxp, integer *indx, integer *info); /* Subroutine */ int dlaed9_(integer *k, integer *kstart, integer *kstop, integer *n, doublereal *d__, doublereal *q, integer *ldq, doublereal * rho, doublereal *dlamda, doublereal *w, doublereal *s, integer *lds, integer *info); /* Subroutine */ int dlaeda_(integer *n, integer *tlvls, integer *curlvl, integer *curpbm, integer *prmptr, integer *perm, integer *givptr, integer *givcol, doublereal *givnum, doublereal *q, integer *qptr, doublereal *z__, doublereal *ztemp, integer *info); /* Subroutine */ int dlaein_(logical *rightv, logical *noinit, integer *n, doublereal *h__, integer *ldh, doublereal *wr, doublereal *wi, doublereal *vr, doublereal *vi, doublereal *b, integer *ldb, doublereal *work, doublereal *eps3, doublereal *smlnum, doublereal * bignum, integer *info); /* Subroutine */ int dlaev2_(doublereal *a, doublereal *b, doublereal *c__, doublereal *rt1, doublereal *rt2, doublereal *cs1, doublereal *sn1); /* Subroutine */ int dlaexc_(logical *wantq, integer *n, doublereal *t, integer *ldt, doublereal *q, integer *ldq, integer *j1, integer *n1, integer *n2, doublereal *work, integer *info); /* Subroutine */ int dlag2_(doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *safmin, doublereal *scale1, doublereal * scale2, doublereal *wr1, doublereal *wr2, doublereal *wi); /* Subroutine */ int dlag2s_(integer *m, integer *n, doublereal *a, integer * lda, real *sa, integer *ldsa, integer *info); /* Subroutine */ int dlags2_(logical *upper, doublereal *a1, doublereal *a2, doublereal *a3, doublereal *b1, doublereal *b2, doublereal *b3, doublereal *csu, doublereal *snu, doublereal *csv, doublereal *snv, doublereal *csq, doublereal *snq); /* Subroutine */ int dlagtf_(integer *n, doublereal *a, doublereal *lambda, doublereal *b, doublereal *c__, doublereal *tol, doublereal *d__, integer *in, integer *info); /* Subroutine */ int dlagtm_(char *trans, integer *n, integer *nrhs, doublereal *alpha, doublereal *dl, doublereal *d__, doublereal *du, doublereal *x, integer *ldx, doublereal *beta, doublereal *b, integer *ldb); /* Subroutine */ int dlagts_(integer *job, integer *n, doublereal *a, doublereal *b, doublereal *c__, doublereal *d__, integer *in, doublereal *y, doublereal *tol, integer *info); /* Subroutine */ int dlagv2_(doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar, doublereal *alphai, doublereal * beta, doublereal *csl, doublereal *snl, doublereal *csr, doublereal * snr); /* Subroutine */ int dlahqr_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal *wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, integer *info); /* Subroutine */ int dlahr2_(integer *n, integer *k, integer *nb, doublereal * a, integer *lda, doublereal *tau, doublereal *t, integer *ldt, doublereal *y, integer *ldy); /* Subroutine */ int dlahrd_(integer *n, integer *k, integer *nb, doublereal * a, integer *lda, doublereal *tau, doublereal *t, integer *ldt, doublereal *y, integer *ldy); /* Subroutine */ int dlaic1_(integer *job, integer *j, doublereal *x, doublereal *sest, doublereal *w, doublereal *gamma, doublereal * sestpr, doublereal *s, doublereal *c__); logical dlaisnan_(doublereal *din1, doublereal *din2); /* Subroutine */ int dlaln2_(logical *ltrans, integer *na, integer *nw, doublereal *smin, doublereal *ca, doublereal *a, integer *lda, doublereal *d1, doublereal *d2, doublereal *b, integer *ldb, doublereal *wr, doublereal *wi, doublereal *x, integer *ldx, doublereal *scale, doublereal *xnorm, integer *info); /* Subroutine */ int dlals0_(integer *icompq, integer *nl, integer *nr, integer *sqre, integer *nrhs, doublereal *b, integer *ldb, doublereal *bx, integer *ldbx, integer *perm, integer *givptr, integer *givcol, integer *ldgcol, doublereal *givnum, integer *ldgnum, doublereal * poles, doublereal *difl, doublereal *difr, doublereal *z__, integer * k, doublereal *c__, doublereal *s, doublereal *work, integer *info); /* Subroutine */ int dlalsa_(integer *icompq, integer *smlsiz, integer *n, integer *nrhs, doublereal *b, integer *ldb, doublereal *bx, integer * ldbx, doublereal *u, integer *ldu, doublereal *vt, integer *k, doublereal *difl, doublereal *difr, doublereal *z__, doublereal * poles, integer *givptr, integer *givcol, integer *ldgcol, integer * perm, doublereal *givnum, doublereal *c__, doublereal *s, doublereal * work, integer *iwork, integer *info); /* Subroutine */ int dlalsd_(char *uplo, integer *smlsiz, integer *n, integer *nrhs, doublereal *d__, doublereal *e, doublereal *b, integer *ldb, doublereal *rcond, integer *rank, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlamrg_(integer *n1, integer *n2, doublereal *a, integer *dtrd1, integer *dtrd2, integer *index); integer dlaneg_(integer *n, doublereal *d__, doublereal *lld, doublereal * sigma, doublereal *pivmin, integer *r__); doublereal dlangb_(char *norm, integer *n, integer *kl, integer *ku, doublereal *ab, integer *ldab, doublereal *work); doublereal dlange_(char *norm, integer *m, integer *n, doublereal *a, integer *lda, doublereal *work); doublereal dlangt_(char *norm, integer *n, doublereal *dl, doublereal *d__, doublereal *du); doublereal dlanhs_(char *norm, integer *n, doublereal *a, integer *lda, doublereal *work); doublereal dlansb_(char *norm, char *uplo, integer *n, integer *k, doublereal *ab, integer *ldab, doublereal *work); doublereal dlansf_(char *norm, char *transr, char *uplo, integer *n, doublereal *a, doublereal *work); doublereal dlansp_(char *norm, char *uplo, integer *n, doublereal *ap, doublereal *work); doublereal dlanst_(char *norm, integer *n, doublereal *d__, doublereal *e); doublereal dlansy_(char *norm, char *uplo, integer *n, doublereal *a, integer *lda, doublereal *work); doublereal dlantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, doublereal *ab, integer *ldab, doublereal *work); doublereal dlantp_(char *norm, char *uplo, char *diag, integer *n, doublereal *ap, doublereal *work); doublereal dlantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, doublereal *a, integer *lda, doublereal *work); /* Subroutine */ int dlanv2_(doublereal *a, doublereal *b, doublereal *c__, doublereal *d__, doublereal *rt1r, doublereal *rt1i, doublereal *rt2r, doublereal *rt2i, doublereal *cs, doublereal *sn); /* Subroutine */ int dlapll_(integer *n, doublereal *x, integer *incx, doublereal *y, integer *incy, doublereal *ssmin); /* Subroutine */ int dlapmt_(logical *forwrd, integer *m, integer *n, doublereal *x, integer *ldx, integer *k); doublereal dlapy2_(doublereal *x, doublereal *y); doublereal dlapy3_(doublereal *x, doublereal *y, doublereal *z__); /* Subroutine */ int dlaqgb_(integer *m, integer *n, integer *kl, integer *ku, doublereal *ab, integer *ldab, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, char *equed); /* Subroutine */ int dlaqge_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, char *equed); /* Subroutine */ int dlaqp2_(integer *m, integer *n, integer *offset, doublereal *a, integer *lda, integer *jpvt, doublereal *tau, doublereal *vn1, doublereal *vn2, doublereal *work); /* Subroutine */ int dlaqps_(integer *m, integer *n, integer *offset, integer *nb, integer *kb, doublereal *a, integer *lda, integer *jpvt, doublereal *tau, doublereal *vn1, doublereal *vn2, doublereal *auxv, doublereal *f, integer *ldf); /* Subroutine */ int dlaqr0_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal *wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dlaqr1_(integer *n, doublereal *h__, integer *ldh, doublereal *sr1, doublereal *si1, doublereal *sr2, doublereal *si2, doublereal *v); /* Subroutine */ int dlaqr2_(logical *wantt, logical *wantz, integer *n, integer *ktop, integer *kbot, integer *nw, doublereal *h__, integer * ldh, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, integer *ns, integer *nd, doublereal *sr, doublereal *si, doublereal * v, integer *ldv, integer *nh, doublereal *t, integer *ldt, integer * nv, doublereal *wv, integer *ldwv, doublereal *work, integer *lwork); /* Subroutine */ int dlaqr3_(logical *wantt, logical *wantz, integer *n, integer *ktop, integer *kbot, integer *nw, doublereal *h__, integer * ldh, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, integer *ns, integer *nd, doublereal *sr, doublereal *si, doublereal * v, integer *ldv, integer *nh, doublereal *t, integer *ldt, integer * nv, doublereal *wv, integer *ldwv, doublereal *work, integer *lwork); /* Subroutine */ int dlaqr4_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal *wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dlaqr5_(logical *wantt, logical *wantz, integer *kacc22, integer *n, integer *ktop, integer *kbot, integer *nshfts, doublereal *sr, doublereal *si, doublereal *h__, integer *ldh, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, doublereal *v, integer * ldv, doublereal *u, integer *ldu, integer *nv, doublereal *wv, integer *ldwv, integer *nh, doublereal *wh, integer *ldwh); /* Subroutine */ int dlaqsb_(char *uplo, integer *n, integer *kd, doublereal * ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int dlaqsp_(char *uplo, integer *n, doublereal *ap, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int dlaqsy_(char *uplo, integer *n, doublereal *a, integer * lda, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int dlaqtr_(logical *ltran, logical *lreal, integer *n, doublereal *t, integer *ldt, doublereal *b, doublereal *w, doublereal *scale, doublereal *x, doublereal *work, integer *info); /* Subroutine */ int dlar1v_(integer *n, integer *b1, integer *bn, doublereal *lambda, doublereal *d__, doublereal *l, doublereal *ld, doublereal * lld, doublereal *pivmin, doublereal *gaptol, doublereal *z__, logical *wantnc, integer *negcnt, doublereal *ztz, doublereal *mingma, integer *r__, integer *isuppz, doublereal *nrminv, doublereal *resid, doublereal *rqcorr, doublereal *work); /* Subroutine */ int dlar2v_(integer *n, doublereal *x, doublereal *y, doublereal *z__, integer *incx, doublereal *c__, doublereal *s, integer *incc); /* Subroutine */ int dlarf_(char *side, integer *m, integer *n, doublereal *v, integer *incv, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work); /* Subroutine */ int dlarfb_(char *side, char *trans, char *direct, char * storev, integer *m, integer *n, integer *k, doublereal *v, integer * ldv, doublereal *t, integer *ldt, doublereal *c__, integer *ldc, doublereal *work, integer *ldwork); /* Subroutine */ int dlarfg_(integer *n, doublereal *alpha, doublereal *x, integer *incx, doublereal *tau); /* Subroutine */ int dlarfp_(integer *n, doublereal *alpha, doublereal *x, integer *incx, doublereal *tau); /* Subroutine */ int dlarft_(char *direct, char *storev, integer *n, integer * k, doublereal *v, integer *ldv, doublereal *tau, doublereal *t, integer *ldt); /* Subroutine */ int dlarfx_(char *side, integer *m, integer *n, doublereal * v, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work); /* Subroutine */ int dlargv_(integer *n, doublereal *x, integer *incx, doublereal *y, integer *incy, doublereal *c__, integer *incc); /* Subroutine */ int dlarnv_(integer *idist, integer *iseed, integer *n, doublereal *x); /* Subroutine */ int dlarra_(integer *n, doublereal *d__, doublereal *e, doublereal *e2, doublereal *spltol, doublereal *tnrm, integer *nsplit, integer *isplit, integer *info); /* Subroutine */ int dlarrb_(integer *n, doublereal *d__, doublereal *lld, integer *ifirst, integer *ilast, doublereal *rtol1, doublereal *rtol2, integer *offset, doublereal *w, doublereal *wgap, doublereal *werr, doublereal *work, integer *iwork, doublereal *pivmin, doublereal * spdiam, integer *twist, integer *info); /* Subroutine */ int dlarrc_(char *jobt, integer *n, doublereal *vl, doublereal *vu, doublereal *d__, doublereal *e, doublereal *pivmin, integer *eigcnt, integer *lcnt, integer *rcnt, integer *info); /* Subroutine */ int dlarrd_(char *range, char *order, integer *n, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *gers, doublereal *reltol, doublereal *d__, doublereal *e, doublereal *e2, doublereal *pivmin, integer *nsplit, integer *isplit, integer *m, doublereal *w, doublereal *werr, doublereal *wl, doublereal *wu, integer *iblock, integer *indexw, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlarre_(char *range, integer *n, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *d__, doublereal *e, doublereal *e2, doublereal *rtol1, doublereal *rtol2, doublereal * spltol, integer *nsplit, integer *isplit, integer *m, doublereal *w, doublereal *werr, doublereal *wgap, integer *iblock, integer *indexw, doublereal *gers, doublereal *pivmin, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dlarrf_(integer *n, doublereal *d__, doublereal *l, doublereal *ld, integer *clstrt, integer *clend, doublereal *w, doublereal *wgap, doublereal *werr, doublereal *spdiam, doublereal * clgapl, doublereal *clgapr, doublereal *pivmin, doublereal *sigma, doublereal *dplus, doublereal *lplus, doublereal *work, integer *info); /* Subroutine */ int dlarrj_(integer *n, doublereal *d__, doublereal *e2, integer *ifirst, integer *ilast, doublereal *rtol, integer *offset, doublereal *w, doublereal *werr, doublereal *work, integer *iwork, doublereal *pivmin, doublereal *spdiam, integer *info); /* Subroutine */ int dlarrk_(integer *n, integer *iw, doublereal *gl, doublereal *gu, doublereal *d__, doublereal *e2, doublereal *pivmin, doublereal *reltol, doublereal *w, doublereal *werr, integer *info); /* Subroutine */ int dlarrr_(integer *n, doublereal *d__, doublereal *e, integer *info); /* Subroutine */ int dlarrv_(integer *n, doublereal *vl, doublereal *vu, doublereal *d__, doublereal *l, doublereal *pivmin, integer *isplit, integer *m, integer *dol, integer *dou, doublereal *minrgp, doublereal *rtol1, doublereal *rtol2, doublereal *w, doublereal *werr, doublereal *wgap, integer *iblock, integer *indexw, doublereal *gers, doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlarscl2_(integer *m, integer *n, doublereal *d__, doublereal *x, integer *ldx); /* Subroutine */ int dlartg_(doublereal *f, doublereal *g, doublereal *cs, doublereal *sn, doublereal *r__); /* Subroutine */ int dlartv_(integer *n, doublereal *x, integer *incx, doublereal *y, integer *incy, doublereal *c__, doublereal *s, integer *incc); /* Subroutine */ int dlaruv_(integer *iseed, integer *n, doublereal *x); /* Subroutine */ int dlarz_(char *side, integer *m, integer *n, integer *l, doublereal *v, integer *incv, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work); /* Subroutine */ int dlarzb_(char *side, char *trans, char *direct, char * storev, integer *m, integer *n, integer *k, integer *l, doublereal *v, integer *ldv, doublereal *t, integer *ldt, doublereal *c__, integer * ldc, doublereal *work, integer *ldwork); /* Subroutine */ int dlarzt_(char *direct, char *storev, integer *n, integer * k, doublereal *v, integer *ldv, doublereal *tau, doublereal *t, integer *ldt); /* Subroutine */ int dlas2_(doublereal *f, doublereal *g, doublereal *h__, doublereal *ssmin, doublereal *ssmax); /* Subroutine */ int dlascl_(char *type__, integer *kl, integer *ku, doublereal *cfrom, doublereal *cto, integer *m, integer *n, doublereal *a, integer *lda, integer *info); /* Subroutine */ int dlascl2_(integer *m, integer *n, doublereal *d__, doublereal *x, integer *ldx); /* Subroutine */ int dlasd0_(integer *n, integer *sqre, doublereal *d__, doublereal *e, doublereal *u, integer *ldu, doublereal *vt, integer * ldvt, integer *smlsiz, integer *iwork, doublereal *work, integer * info); /* Subroutine */ int dlasd1_(integer *nl, integer *nr, integer *sqre, doublereal *d__, doublereal *alpha, doublereal *beta, doublereal *u, integer *ldu, doublereal *vt, integer *ldvt, integer *idxq, integer * iwork, doublereal *work, integer *info); /* Subroutine */ int dlasd2_(integer *nl, integer *nr, integer *sqre, integer *k, doublereal *d__, doublereal *z__, doublereal *alpha, doublereal * beta, doublereal *u, integer *ldu, doublereal *vt, integer *ldvt, doublereal *dsigma, doublereal *u2, integer *ldu2, doublereal *vt2, integer *ldvt2, integer *idxp, integer *idx, integer *idxc, integer * idxq, integer *coltyp, integer *info); /* Subroutine */ int dlasd3_(integer *nl, integer *nr, integer *sqre, integer *k, doublereal *d__, doublereal *q, integer *ldq, doublereal *dsigma, doublereal *u, integer *ldu, doublereal *u2, integer *ldu2, doublereal *vt, integer *ldvt, doublereal *vt2, integer *ldvt2, integer *idxc, integer *ctot, doublereal *z__, integer *info); /* Subroutine */ int dlasd4_(integer *n, integer *i__, doublereal *d__, doublereal *z__, doublereal *delta, doublereal *rho, doublereal * sigma, doublereal *work, integer *info); /* Subroutine */ int dlasd5_(integer *i__, doublereal *d__, doublereal *z__, doublereal *delta, doublereal *rho, doublereal *dsigma, doublereal * work); /* Subroutine */ int dlasd6_(integer *icompq, integer *nl, integer *nr, integer *sqre, doublereal *d__, doublereal *vf, doublereal *vl, doublereal *alpha, doublereal *beta, integer *idxq, integer *perm, integer *givptr, integer *givcol, integer *ldgcol, doublereal *givnum, integer *ldgnum, doublereal *poles, doublereal *difl, doublereal * difr, doublereal *z__, integer *k, doublereal *c__, doublereal *s, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlasd7_(integer *icompq, integer *nl, integer *nr, integer *sqre, integer *k, doublereal *d__, doublereal *z__, doublereal *zw, doublereal *vf, doublereal *vfw, doublereal *vl, doublereal *vlw, doublereal *alpha, doublereal *beta, doublereal * dsigma, integer *idx, integer *idxp, integer *idxq, integer *perm, integer *givptr, integer *givcol, integer *ldgcol, doublereal *givnum, integer *ldgnum, doublereal *c__, doublereal *s, integer *info); /* Subroutine */ int dlasd8_(integer *icompq, integer *k, doublereal *d__, doublereal *z__, doublereal *vf, doublereal *vl, doublereal *difl, doublereal *difr, integer *lddifr, doublereal *dsigma, doublereal * work, integer *info); /* Subroutine */ int dlasda_(integer *icompq, integer *smlsiz, integer *n, integer *sqre, doublereal *d__, doublereal *e, doublereal *u, integer *ldu, doublereal *vt, integer *k, doublereal *difl, doublereal *difr, doublereal *z__, doublereal *poles, integer *givptr, integer *givcol, integer *ldgcol, integer *perm, doublereal *givnum, doublereal *c__, doublereal *s, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dlasdq_(char *uplo, integer *sqre, integer *n, integer * ncvt, integer *nru, integer *ncc, doublereal *d__, doublereal *e, doublereal *vt, integer *ldvt, doublereal *u, integer *ldu, doublereal *c__, integer *ldc, doublereal *work, integer *info); /* Subroutine */ int dlasdt_(integer *n, integer *lvl, integer *nd, integer * inode, integer *ndiml, integer *ndimr, integer *msub); /* Subroutine */ int dlaset_(char *uplo, integer *m, integer *n, doublereal * alpha, doublereal *beta, doublereal *a, integer *lda); /* Subroutine */ int dlasq1_(integer *n, doublereal *d__, doublereal *e, doublereal *work, integer *info); /* Subroutine */ int dlasq2_(integer *n, doublereal *z__, integer *info); /* Subroutine */ int dlasq3_(integer *i0, integer *n0, doublereal *z__, integer *pp, doublereal *dmin__, doublereal *sigma, doublereal *desig, doublereal *qmax, integer *nfail, integer *iter, integer *ndiv, logical *ieee, integer *ttype, doublereal *dmin1, doublereal *dmin2, doublereal *dn, doublereal *dn1, doublereal *dn2, doublereal *g, doublereal *tau); /* Subroutine */ int dlasq4_(integer *i0, integer *n0, doublereal *z__, integer *pp, integer *n0in, doublereal *dmin__, doublereal *dmin1, doublereal *dmin2, doublereal *dn, doublereal *dn1, doublereal *dn2, doublereal *tau, integer *ttype, doublereal *g); /* Subroutine */ int dlasq5_(integer *i0, integer *n0, doublereal *z__, integer *pp, doublereal *tau, doublereal *dmin__, doublereal *dmin1, doublereal *dmin2, doublereal *dn, doublereal *dnm1, doublereal *dnm2, logical *ieee); /* Subroutine */ int dlasq6_(integer *i0, integer *n0, doublereal *z__, integer *pp, doublereal *dmin__, doublereal *dmin1, doublereal *dmin2, doublereal *dn, doublereal *dnm1, doublereal *dnm2); /* Subroutine */ int dlasr_(char *side, char *pivot, char *direct, integer *m, integer *n, doublereal *c__, doublereal *s, doublereal *a, integer * lda); /* Subroutine */ int dlasrt_(char *id, integer *n, doublereal *d__, integer * info); /* Subroutine */ int dlassq_(integer *n, doublereal *x, integer *incx, doublereal *scale, doublereal *sumsq); /* Subroutine */ int dlasv2_(doublereal *f, doublereal *g, doublereal *h__, doublereal *ssmin, doublereal *ssmax, doublereal *snr, doublereal * csr, doublereal *snl, doublereal *csl); /* Subroutine */ int dlaswp_(integer *n, doublereal *a, integer *lda, integer *k1, integer *k2, integer *ipiv, integer *incx); /* Subroutine */ int dlasy2_(logical *ltranl, logical *ltranr, integer *isgn, integer *n1, integer *n2, doublereal *tl, integer *ldtl, doublereal * tr, integer *ldtr, doublereal *b, integer *ldb, doublereal *scale, doublereal *x, integer *ldx, doublereal *xnorm, integer *info); /* Subroutine */ int dlasyf_(char *uplo, integer *n, integer *nb, integer *kb, doublereal *a, integer *lda, integer *ipiv, doublereal *w, integer * ldw, integer *info); /* Subroutine */ int dlat2s_(char *uplo, integer *n, doublereal *a, integer * lda, real *sa, integer *ldsa, integer *info); /* Subroutine */ int dlatbs_(char *uplo, char *trans, char *diag, char * normin, integer *n, integer *kd, doublereal *ab, integer *ldab, doublereal *x, doublereal *scale, doublereal *cnorm, integer *info); /* Subroutine */ int dlatdf_(integer *ijob, integer *n, doublereal *z__, integer *ldz, doublereal *rhs, doublereal *rdsum, doublereal *rdscal, integer *ipiv, integer *jpiv); /* Subroutine */ int dlatps_(char *uplo, char *trans, char *diag, char * normin, integer *n, doublereal *ap, doublereal *x, doublereal *scale, doublereal *cnorm, integer *info); /* Subroutine */ int dlatrd_(char *uplo, integer *n, integer *nb, doublereal * a, integer *lda, doublereal *e, doublereal *tau, doublereal *w, integer *ldw); /* Subroutine */ int dlatrs_(char *uplo, char *trans, char *diag, char * normin, integer *n, doublereal *a, integer *lda, doublereal *x, doublereal *scale, doublereal *cnorm, integer *info); /* Subroutine */ int dlatrz_(integer *m, integer *n, integer *l, doublereal * a, integer *lda, doublereal *tau, doublereal *work); /* Subroutine */ int dlatzm_(char *side, integer *m, integer *n, doublereal * v, integer *incv, doublereal *tau, doublereal *c1, doublereal *c2, integer *ldc, doublereal *work); /* Subroutine */ int dlauu2_(char *uplo, integer *n, doublereal *a, integer * lda, integer *info); /* Subroutine */ int dlauum_(char *uplo, integer *n, doublereal *a, integer * lda, integer *info); /* Subroutine */ int dopgtr_(char *uplo, integer *n, doublereal *ap, doublereal *tau, doublereal *q, integer *ldq, doublereal *work, integer *info); /* Subroutine */ int dopmtr_(char *side, char *uplo, char *trans, integer *m, integer *n, doublereal *ap, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work, integer *info); /* Subroutine */ int dorg2l_(integer *m, integer *n, integer *k, doublereal * a, integer *lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dorg2r_(integer *m, integer *n, integer *k, doublereal * a, integer *lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dorgbr_(char *vect, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dorghr_(integer *n, integer *ilo, integer *ihi, doublereal *a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dorgl2_(integer *m, integer *n, integer *k, doublereal * a, integer *lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dorglq_(integer *m, integer *n, integer *k, doublereal * a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dorgql_(integer *m, integer *n, integer *k, doublereal * a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dorgqr_(integer *m, integer *n, integer *k, doublereal * a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dorgr2_(integer *m, integer *n, integer *k, doublereal * a, integer *lda, doublereal *tau, doublereal *work, integer *info); /* Subroutine */ int dorgrq_(integer *m, integer *n, integer *k, doublereal * a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dorgtr_(char *uplo, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dorm2l_(char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *info); /* Subroutine */ int dorm2r_(char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *info); /* Subroutine */ int dormbr_(char *vect, char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dormhr_(char *side, char *trans, integer *m, integer *n, integer *ilo, integer *ihi, doublereal *a, integer *lda, doublereal * tau, doublereal *c__, integer *ldc, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dorml2_(char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *info); /* Subroutine */ int dormlq_(char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dormql_(char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dormqr_(char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dormr2_(char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *info); /* Subroutine */ int dormr3_(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, doublereal *a, integer *lda, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work, integer *info); /* Subroutine */ int dormrq_(char *side, char *trans, integer *m, integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dormrz_(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, doublereal *a, integer *lda, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dormtr_(char *side, char *uplo, char *trans, integer *m, integer *n, doublereal *a, integer *lda, doublereal *tau, doublereal * c__, integer *ldc, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dpbcon_(char *uplo, integer *n, integer *kd, doublereal * ab, integer *ldab, doublereal *anorm, doublereal *rcond, doublereal * work, integer *iwork, integer *info); /* Subroutine */ int dpbequ_(char *uplo, integer *n, integer *kd, doublereal * ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax, integer *info); /* Subroutine */ int dpbrfs_(char *uplo, integer *n, integer *kd, integer * nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal * ferr, doublereal *berr, doublereal *work, integer *iwork, integer * info); /* Subroutine */ int dpbstf_(char *uplo, integer *n, integer *kd, doublereal * ab, integer *ldab, integer *info); /* Subroutine */ int dpbsv_(char *uplo, integer *n, integer *kd, integer * nrhs, doublereal *ab, integer *ldab, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dpbsvx_(char *fact, char *uplo, integer *n, integer *kd, integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, char *equed, doublereal *s, doublereal *b, integer * ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dpbtf2_(char *uplo, integer *n, integer *kd, doublereal * ab, integer *ldab, integer *info); /* Subroutine */ int dpbtrf_(char *uplo, integer *n, integer *kd, doublereal * ab, integer *ldab, integer *info); /* Subroutine */ int dpbtrs_(char *uplo, integer *n, integer *kd, integer * nrhs, doublereal *ab, integer *ldab, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dpftrf_(char *transr, char *uplo, integer *n, doublereal *a, integer *info); /* Subroutine */ int dpftri_(char *transr, char *uplo, integer *n, doublereal *a, integer *info); /* Subroutine */ int dpftrs_(char *transr, char *uplo, integer *n, integer * nrhs, doublereal *a, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dpocon_(char *uplo, integer *n, doublereal *a, integer * lda, doublereal *anorm, doublereal *rcond, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dpoequ_(integer *n, doublereal *a, integer *lda, doublereal *s, doublereal *scond, doublereal *amax, integer *info); /* Subroutine */ int dpoequb_(integer *n, doublereal *a, integer *lda, doublereal *s, doublereal *scond, doublereal *amax, integer *info); /* Subroutine */ int dporfs_(char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal * ferr, doublereal *berr, doublereal *work, integer *iwork, integer * info); /* Subroutine */ int dporfsx_(char *uplo, char *equed, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, doublereal *s, doublereal *b, integer *ldb, doublereal *x, integer * ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer * nparams, doublereal *params, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dposv_(char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dposvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, char *equed, doublereal *s, doublereal *b, integer *ldb, doublereal * x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal * berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dposvxx_(char *fact, char *uplo, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, char *equed, doublereal *s, doublereal *b, integer *ldb, doublereal * x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, doublereal * berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal * err_bnds_comp__, integer *nparams, doublereal *params, doublereal * work, integer *iwork, integer *info); /* Subroutine */ int dpotf2_(char *uplo, integer *n, doublereal *a, integer * lda, integer *info); /* Subroutine */ int dpotrf_(char *uplo, integer *n, doublereal *a, integer * lda, integer *info); /* Subroutine */ int dpotri_(char *uplo, integer *n, doublereal *a, integer * lda, integer *info); /* Subroutine */ int dpotrs_(char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, integer * info); /* Subroutine */ int dppcon_(char *uplo, integer *n, doublereal *ap, doublereal *anorm, doublereal *rcond, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dppequ_(char *uplo, integer *n, doublereal *ap, doublereal *s, doublereal *scond, doublereal *amax, integer *info); /* Subroutine */ int dpprfs_(char *uplo, integer *n, integer *nrhs, doublereal *ap, doublereal *afp, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dppsv_(char *uplo, integer *n, integer *nrhs, doublereal *ap, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dppsvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublereal *ap, doublereal *afp, char *equed, doublereal *s, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal * rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer * iwork, integer *info); /* Subroutine */ int dpptrf_(char *uplo, integer *n, doublereal *ap, integer * info); /* Subroutine */ int dpptri_(char *uplo, integer *n, doublereal *ap, integer * info); /* Subroutine */ int dpptrs_(char *uplo, integer *n, integer *nrhs, doublereal *ap, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dpstf2_(char *uplo, integer *n, doublereal *a, integer * lda, integer *piv, integer *rank, doublereal *tol, doublereal *work, integer *info); /* Subroutine */ int dpstrf_(char *uplo, integer *n, doublereal *a, integer * lda, integer *piv, integer *rank, doublereal *tol, doublereal *work, integer *info); /* Subroutine */ int dptcon_(integer *n, doublereal *d__, doublereal *e, doublereal *anorm, doublereal *rcond, doublereal *work, integer *info); /* Subroutine */ int dpteqr_(char *compz, integer *n, doublereal *d__, doublereal *e, doublereal *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int dptrfs_(integer *n, integer *nrhs, doublereal *d__, doublereal *e, doublereal *df, doublereal *ef, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *info); /* Subroutine */ int dptsv_(integer *n, integer *nrhs, doublereal *d__, doublereal *e, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dptsvx_(char *fact, integer *n, integer *nrhs, doublereal *d__, doublereal *e, doublereal *df, doublereal *ef, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal * rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer * info); /* Subroutine */ int dpttrf_(integer *n, doublereal *d__, doublereal *e, integer *info); /* Subroutine */ int dpttrs_(integer *n, integer *nrhs, doublereal *d__, doublereal *e, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dptts2_(integer *n, integer *nrhs, doublereal *d__, doublereal *e, doublereal *b, integer *ldb); /* Subroutine */ int drscl_(integer *n, doublereal *sa, doublereal *sx, integer *incx); /* Subroutine */ int dsbev_(char *jobz, char *uplo, integer *n, integer *kd, doublereal *ab, integer *ldab, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int dsbevd_(char *jobz, char *uplo, integer *n, integer *kd, doublereal *ab, integer *ldab, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dsbevx_(char *jobz, char *range, char *uplo, integer *n, integer *kd, doublereal *ab, integer *ldab, doublereal *q, integer * ldq, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int dsbgst_(char *vect, char *uplo, integer *n, integer *ka, integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer * ldbb, doublereal *x, integer *ldx, doublereal *work, integer *info); /* Subroutine */ int dsbgv_(char *jobz, char *uplo, integer *n, integer *ka, integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer * ldbb, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int dsbgvd_(char *jobz, char *uplo, integer *n, integer *ka, integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer * ldbb, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dsbgvx_(char *jobz, char *range, char *uplo, integer *n, integer *ka, integer *kb, doublereal *ab, integer *ldab, doublereal * bb, integer *ldbb, doublereal *q, integer *ldq, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int dsbtrd_(char *vect, char *uplo, integer *n, integer *kd, doublereal *ab, integer *ldab, doublereal *d__, doublereal *e, doublereal *q, integer *ldq, doublereal *work, integer *info); /* Subroutine */ int dsfrk_(char *transr, char *uplo, char *trans, integer *n, integer *k, doublereal *alpha, doublereal *a, integer *lda, doublereal *beta, doublereal *c__); /* Subroutine */ int dsgesv_(integer *n, integer *nrhs, doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *ldb, doublereal * x, integer *ldx, doublereal *work, real *swork, integer *iter, integer *info); /* Subroutine */ int dspcon_(char *uplo, integer *n, doublereal *ap, integer * ipiv, doublereal *anorm, doublereal *rcond, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dspev_(char *jobz, char *uplo, integer *n, doublereal * ap, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int dspevd_(char *jobz, char *uplo, integer *n, doublereal * ap, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dspevx_(char *jobz, char *range, char *uplo, integer *n, doublereal *ap, doublereal *vl, doublereal *vu, integer *il, integer * iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int dspgst_(integer *itype, char *uplo, integer *n, doublereal *ap, doublereal *bp, integer *info); /* Subroutine */ int dspgv_(integer *itype, char *jobz, char *uplo, integer * n, doublereal *ap, doublereal *bp, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int dspgvd_(integer *itype, char *jobz, char *uplo, integer * n, doublereal *ap, doublereal *bp, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dspgvx_(integer *itype, char *jobz, char *range, char * uplo, integer *n, doublereal *ap, doublereal *bp, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int dsposv_(char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal * x, integer *ldx, doublereal *work, real *swork, integer *iter, integer *info); /* Subroutine */ int dsprfs_(char *uplo, integer *n, integer *nrhs, doublereal *ap, doublereal *afp, integer *ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dspsv_(char *uplo, integer *n, integer *nrhs, doublereal *ap, integer *ipiv, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dspsvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublereal *ap, doublereal *afp, integer *ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dsptrd_(char *uplo, integer *n, doublereal *ap, doublereal *d__, doublereal *e, doublereal *tau, integer *info); /* Subroutine */ int dsptrf_(char *uplo, integer *n, doublereal *ap, integer * ipiv, integer *info); /* Subroutine */ int dsptri_(char *uplo, integer *n, doublereal *ap, integer * ipiv, doublereal *work, integer *info); /* Subroutine */ int dsptrs_(char *uplo, integer *n, integer *nrhs, doublereal *ap, integer *ipiv, doublereal *b, integer *ldb, integer * info); /* Subroutine */ int dstebz_(char *range, char *order, integer *n, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, doublereal *d__, doublereal *e, integer *m, integer *nsplit, doublereal *w, integer *iblock, integer *isplit, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dstedc_(char *compz, integer *n, doublereal *d__, doublereal *e, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dstegr_(char *jobz, char *range, integer *n, doublereal * d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dstein_(integer *n, doublereal *d__, doublereal *e, integer *m, doublereal *w, integer *iblock, integer *isplit, doublereal *z__, integer *ldz, doublereal *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int dstemr_(char *jobz, char *range, integer *n, doublereal * d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, integer *iu, integer *m, doublereal *w, doublereal *z__, integer *ldz, integer *nzc, integer *isuppz, logical *tryrac, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dsteqr_(char *compz, integer *n, doublereal *d__, doublereal *e, doublereal *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int dsterf_(integer *n, doublereal *d__, doublereal *e, integer *info); /* Subroutine */ int dstev_(char *jobz, integer *n, doublereal *d__, doublereal *e, doublereal *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int dstevd_(char *jobz, integer *n, doublereal *d__, doublereal *e, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dstevr_(char *jobz, char *range, integer *n, doublereal * d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dstevx_(char *jobz, char *range, integer *n, doublereal * d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int dsycon_(char *uplo, integer *n, doublereal *a, integer * lda, integer *ipiv, doublereal *anorm, doublereal *rcond, doublereal * work, integer *iwork, integer *info); /* Subroutine */ int dsyequb_(char *uplo, integer *n, doublereal *a, integer * lda, doublereal *s, doublereal *scond, doublereal *amax, doublereal * work, integer *info); /* Subroutine */ int dsyev_(char *jobz, char *uplo, integer *n, doublereal *a, integer *lda, doublereal *w, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dsyevd_(char *jobz, char *uplo, integer *n, doublereal * a, integer *lda, doublereal *w, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dsyevr_(char *jobz, char *range, char *uplo, integer *n, doublereal *a, integer *lda, doublereal *vl, doublereal *vu, integer * il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dsyevx_(char *jobz, char *range, char *uplo, integer *n, doublereal *a, integer *lda, doublereal *vl, doublereal *vu, integer * il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int dsygs2_(integer *itype, char *uplo, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, integer * info); /* Subroutine */ int dsygst_(integer *itype, char *uplo, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, integer * info); /* Subroutine */ int dsygv_(integer *itype, char *jobz, char *uplo, integer * n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *w, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dsygvd_(integer *itype, char *jobz, char *uplo, integer * n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *w, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dsygvx_(integer *itype, char *jobz, char *range, char * uplo, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, integer *lwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int dsyrfs_(char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer * ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dsyrfsx_(char *uplo, char *equed, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, doublereal *s, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *berr, integer * n_err_bnds__, doublereal *err_bnds_norm__, doublereal * err_bnds_comp__, integer *nparams, doublereal *params, doublereal * work, integer *iwork, integer *info); /* Subroutine */ int dsysv_(char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *ldb, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dsysvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, doublereal *b, integer *ldb, doublereal *x, integer * ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int dsysvxx_(char *fact, char *uplo, integer *n, integer * nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, char *equed, doublereal *s, doublereal *b, integer * ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal * rpvgrw, doublereal *berr, integer *n_err_bnds__, doublereal * err_bnds_norm__, doublereal *err_bnds_comp__, integer *nparams, doublereal *params, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dsytd2_(char *uplo, integer *n, doublereal *a, integer * lda, doublereal *d__, doublereal *e, doublereal *tau, integer *info); /* Subroutine */ int dsytf2_(char *uplo, integer *n, doublereal *a, integer * lda, integer *ipiv, integer *info); /* Subroutine */ int dsytrd_(char *uplo, integer *n, doublereal *a, integer * lda, doublereal *d__, doublereal *e, doublereal *tau, doublereal * work, integer *lwork, integer *info); /* Subroutine */ int dsytrf_(char *uplo, integer *n, doublereal *a, integer * lda, integer *ipiv, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dsytri_(char *uplo, integer *n, doublereal *a, integer * lda, integer *ipiv, doublereal *work, integer *info); /* Subroutine */ int dsytrs_(char *uplo, integer *n, integer *nrhs, doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer * ldb, integer *info); /* Subroutine */ int dtbcon_(char *norm, char *uplo, char *diag, integer *n, integer *kd, doublereal *ab, integer *ldab, doublereal *rcond, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dtbrfs_(char *uplo, char *trans, char *diag, integer *n, integer *kd, integer *nrhs, doublereal *ab, integer *ldab, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dtbtrs_(char *uplo, char *trans, char *diag, integer *n, integer *kd, integer *nrhs, doublereal *ab, integer *ldab, doublereal *b, integer *ldb, integer *info); /* Subroutine */ int dtfsm_(char *transr, char *side, char *uplo, char *trans, char *diag, integer *m, integer *n, doublereal *alpha, doublereal *a, doublereal *b, integer *ldb); /* Subroutine */ int dtftri_(char *transr, char *uplo, char *diag, integer *n, doublereal *a, integer *info); /* Subroutine */ int dtfttp_(char *transr, char *uplo, integer *n, doublereal *arf, doublereal *ap, integer *info); /* Subroutine */ int dtfttr_(char *transr, char *uplo, integer *n, doublereal *arf, doublereal *a, integer *lda, integer *info); /* Subroutine */ int dtgevc_(char *side, char *howmny, logical *select, integer *n, doublereal *s, integer *lds, doublereal *p, integer *ldp, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, integer *mm, integer *m, doublereal *work, integer *info); /* Subroutine */ int dtgex2_(logical *wantq, logical *wantz, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal * q, integer *ldq, doublereal *z__, integer *ldz, integer *j1, integer * n1, integer *n2, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dtgexc_(logical *wantq, logical *wantz, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal * q, integer *ldq, doublereal *z__, integer *ldz, integer *ifst, integer *ilst, doublereal *work, integer *lwork, integer *info); /* Subroutine */ int dtgsen_(integer *ijob, logical *wantq, logical *wantz, logical *select, integer *n, doublereal *a, integer *lda, doublereal * b, integer *ldb, doublereal *alphar, doublereal *alphai, doublereal * beta, doublereal *q, integer *ldq, doublereal *z__, integer *ldz, integer *m, doublereal *pl, doublereal *pr, doublereal *dif, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int dtgsja_(char *jobu, char *jobv, char *jobq, integer *m, integer *p, integer *n, integer *k, integer *l, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *tola, doublereal *tolb, doublereal *alpha, doublereal *beta, doublereal *u, integer *ldu, doublereal *v, integer *ldv, doublereal *q, integer * ldq, doublereal *work, integer *ncycle, integer *info); /* Subroutine */ int dtgsna_(char *job, char *howmny, logical *select, integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, doublereal *s, doublereal *dif, integer *mm, integer *m, doublereal * work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int dtgsy2_(char *trans, integer *ijob, integer *m, integer * n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *c__, integer *ldc, doublereal *d__, integer *ldd, doublereal *e, integer *lde, doublereal *f, integer *ldf, doublereal * scale, doublereal *rdsum, doublereal *rdscal, integer *iwork, integer *pq, integer *info); /* Subroutine */ int dtgsyl_(char *trans, integer *ijob, integer *m, integer * n, doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *c__, integer *ldc, doublereal *d__, integer *ldd, doublereal *e, integer *lde, doublereal *f, integer *ldf, doublereal * scale, doublereal *dif, doublereal *work, integer *lwork, integer * iwork, integer *info); /* Subroutine */ int dtpcon_(char *norm, char *uplo, char *diag, integer *n, doublereal *ap, doublereal *rcond, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dtprfs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, doublereal *ap, doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dtptri_(char *uplo, char *diag, integer *n, doublereal * ap, integer *info); /* Subroutine */ int dtptrs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, doublereal *ap, doublereal *b, integer *ldb, integer * info); /* Subroutine */ int dtpttf_(char *transr, char *uplo, integer *n, doublereal *ap, doublereal *arf, integer *info); /* Subroutine */ int dtpttr_(char *uplo, integer *n, doublereal *ap, doublereal *a, integer *lda, integer *info); /* Subroutine */ int dtrcon_(char *norm, char *uplo, char *diag, integer *n, doublereal *a, integer *lda, doublereal *rcond, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dtrevc_(char *side, char *howmny, logical *select, integer *n, doublereal *t, integer *ldt, doublereal *vl, integer * ldvl, doublereal *vr, integer *ldvr, integer *mm, integer *m, doublereal *work, integer *info); /* Subroutine */ int dtrexc_(char *compq, integer *n, doublereal *t, integer * ldt, doublereal *q, integer *ldq, integer *ifst, integer *ilst, doublereal *work, integer *info); /* Subroutine */ int dtrrfs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer * ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int dtrsen_(char *job, char *compq, logical *select, integer *n, doublereal *t, integer *ldt, doublereal *q, integer *ldq, doublereal *wr, doublereal *wi, integer *m, doublereal *s, doublereal *sep, doublereal *work, integer *lwork, integer *iwork, integer * liwork, integer *info); /* Subroutine */ int dtrsna_(char *job, char *howmny, logical *select, integer *n, doublereal *t, integer *ldt, doublereal *vl, integer * ldvl, doublereal *vr, integer *ldvr, doublereal *s, doublereal *sep, integer *mm, integer *m, doublereal *work, integer *ldwork, integer * iwork, integer *info); /* Subroutine */ int dtrsyl_(char *trana, char *tranb, integer *isgn, integer *m, integer *n, doublereal *a, integer *lda, doublereal *b, integer * ldb, doublereal *c__, integer *ldc, doublereal *scale, integer *info); /* Subroutine */ int dtrti2_(char *uplo, char *diag, integer *n, doublereal * a, integer *lda, integer *info); /* Subroutine */ int dtrtri_(char *uplo, char *diag, integer *n, doublereal * a, integer *lda, integer *info); /* Subroutine */ int dtrtrs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer * ldb, integer *info); /* Subroutine */ int dtrttf_(char *transr, char *uplo, integer *n, doublereal *a, integer *lda, doublereal *arf, integer *info); /* Subroutine */ int dtrttp_(char *uplo, integer *n, doublereal *a, integer * lda, doublereal *ap, integer *info); /* Subroutine */ int dtzrqf_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, integer *info); /* Subroutine */ int dtzrzf_(integer *m, integer *n, doublereal *a, integer * lda, doublereal *tau, doublereal *work, integer *lwork, integer *info); doublereal dzsum1_(integer *n, doublecomplex *cx, integer *incx); integer icmax1_(integer *n, complex *cx, integer *incx); integer ieeeck_(integer *ispec, real *zero, real *one); integer ilaclc_(integer *m, integer *n, complex *a, integer *lda); integer ilaclr_(integer *m, integer *n, complex *a, integer *lda); integer iladiag_(char *diag); integer iladlc_(integer *m, integer *n, doublereal *a, integer *lda); integer iladlr_(integer *m, integer *n, doublereal *a, integer *lda); integer ilaenv_(integer *ispec, char *name__, char *opts, integer *n1, integer *n2, integer *n3, integer *n4); integer ilaprec_(char *prec); integer ilaslc_(integer *m, integer *n, real *a, integer *lda); integer ilaslr_(integer *m, integer *n, real *a, integer *lda); integer ilatrans_(char *trans); integer ilauplo_(char *uplo); /* Subroutine */ int ilaver_(integer *vers_major__, integer *vers_minor__, integer *vers_patch__); integer ilazlc_(integer *m, integer *n, doublecomplex *a, integer *lda); integer ilazlr_(integer *m, integer *n, doublecomplex *a, integer *lda); integer iparmq_(integer *ispec, char *name__, char *opts, integer *n, integer *ilo, integer *ihi, integer *lwork); integer izmax1_(integer *n, doublecomplex *cx, integer *incx); logical lsamen_(integer *n, char *ca, char *cb); integer smaxloc_(real *a, integer *dimm); /* Subroutine */ int sbdsdc_(char *uplo, char *compq, integer *n, real *d__, real *e, real *u, integer *ldu, real *vt, integer *ldvt, real *q, integer *iq, real *work, integer *iwork, integer *info); /* Subroutine */ int sbdsqr_(char *uplo, integer *n, integer *ncvt, integer * nru, integer *ncc, real *d__, real *e, real *vt, integer *ldvt, real * u, integer *ldu, real *c__, integer *ldc, real *work, integer *info); doublereal scsum1_(integer *n, complex *cx, integer *incx); /* Subroutine */ int sdisna_(char *job, integer *m, integer *n, real *d__, real *sep, integer *info); /* Subroutine */ int sgbbrd_(char *vect, integer *m, integer *n, integer *ncc, integer *kl, integer *ku, real *ab, integer *ldab, real *d__, real * e, real *q, integer *ldq, real *pt, integer *ldpt, real *c__, integer *ldc, real *work, integer *info); /* Subroutine */ int sgbcon_(char *norm, integer *n, integer *kl, integer *ku, real *ab, integer *ldab, integer *ipiv, real *anorm, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int sgbequ_(integer *m, integer *n, integer *kl, integer *ku, real *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real * colcnd, real *amax, integer *info); /* Subroutine */ int sgbequb_(integer *m, integer *n, integer *kl, integer * ku, real *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer *info); /* Subroutine */ int sgbrfs_(char *trans, integer *n, integer *kl, integer * ku, integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real * ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int sgbrfsx_(char *trans, char *equed, integer *n, integer * kl, integer *ku, integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, integer *ipiv, real *r__, real *c__, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *berr, integer * n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer * nparams, real *params, real *work, integer *iwork, integer *info); /* Subroutine */ int sgbsv_(integer *n, integer *kl, integer *ku, integer * nrhs, real *ab, integer *ldab, integer *ipiv, real *b, integer *ldb, integer *info); /* Subroutine */ int sgbsvx_(char *fact, char *trans, integer *n, integer *kl, integer *ku, integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int sgbsvxx_(char *fact, char *trans, integer *n, integer * kl, integer *ku, integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real * rpvgrw, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *params, real *work, integer *iwork, integer *info); /* Subroutine */ int sgbtf2_(integer *m, integer *n, integer *kl, integer *ku, real *ab, integer *ldab, integer *ipiv, integer *info); /* Subroutine */ int sgbtrf_(integer *m, integer *n, integer *kl, integer *ku, real *ab, integer *ldab, integer *ipiv, integer *info); /* Subroutine */ int sgbtrs_(char *trans, integer *n, integer *kl, integer * ku, integer *nrhs, real *ab, integer *ldab, integer *ipiv, real *b, integer *ldb, integer *info); /* Subroutine */ int sgebak_(char *job, char *side, integer *n, integer *ilo, integer *ihi, real *scale, integer *m, real *v, integer *ldv, integer *info); /* Subroutine */ int sgebal_(char *job, integer *n, real *a, integer *lda, integer *ilo, integer *ihi, real *scale, integer *info); /* Subroutine */ int sgebd2_(integer *m, integer *n, real *a, integer *lda, real *d__, real *e, real *tauq, real *taup, real *work, integer *info); /* Subroutine */ int sgebrd_(integer *m, integer *n, real *a, integer *lda, real *d__, real *e, real *tauq, real *taup, real *work, integer * lwork, integer *info); /* Subroutine */ int sgecon_(char *norm, integer *n, real *a, integer *lda, real *anorm, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int sgeequ_(integer *m, integer *n, real *a, integer *lda, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer *info); /* Subroutine */ int sgeequb_(integer *m, integer *n, real *a, integer *lda, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer *info); /* Subroutine */ int sgees_(char *jobvs, char *sort, L_fp select, integer *n, real *a, integer *lda, integer *sdim, real *wr, real *wi, real *vs, integer *ldvs, real *work, integer *lwork, logical *bwork, integer * info); /* Subroutine */ int sgeesx_(char *jobvs, char *sort, L_fp select, char * sense, integer *n, real *a, integer *lda, integer *sdim, real *wr, real *wi, real *vs, integer *ldvs, real *rconde, real *rcondv, real * work, integer *lwork, integer *iwork, integer *liwork, logical *bwork, integer *info); /* Subroutine */ int sgeev_(char *jobvl, char *jobvr, integer *n, real *a, integer *lda, real *wr, real *wi, real *vl, integer *ldvl, real *vr, integer *ldvr, real *work, integer *lwork, integer *info); /* Subroutine */ int sgeevx_(char *balanc, char *jobvl, char *jobvr, char * sense, integer *n, real *a, integer *lda, real *wr, real *wi, real * vl, integer *ldvl, real *vr, integer *ldvr, integer *ilo, integer * ihi, real *scale, real *abnrm, real *rconde, real *rcondv, real *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int sgegs_(char *jobvsl, char *jobvsr, integer *n, real *a, integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real *beta, real *vsl, integer *ldvsl, real *vsr, integer *ldvsr, real * work, integer *lwork, integer *info); /* Subroutine */ int sgegv_(char *jobvl, char *jobvr, integer *n, real *a, integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real *beta, real *vl, integer *ldvl, real *vr, integer *ldvr, real *work, integer *lwork, integer *info); /* Subroutine */ int sgehd2_(integer *n, integer *ilo, integer *ihi, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sgehrd_(integer *n, integer *ilo, integer *ihi, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sgejsv_(char *joba, char *jobu, char *jobv, char *jobr, char *jobt, char *jobp, integer *m, integer *n, real *a, integer *lda, real *sva, real *u, integer *ldu, real *v, integer *ldv, real *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int sgelq2_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sgelqf_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sgels_(char *trans, integer *m, integer *n, integer * nrhs, real *a, integer *lda, real *b, integer *ldb, real *work, integer *lwork, integer *info); /* Subroutine */ int sgelsd_(integer *m, integer *n, integer *nrhs, real *a, integer *lda, real *b, integer *ldb, real *s, real *rcond, integer * rank, real *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int sgelss_(integer *m, integer *n, integer *nrhs, real *a, integer *lda, real *b, integer *ldb, real *s, real *rcond, integer * rank, real *work, integer *lwork, integer *info); /* Subroutine */ int sgelsx_(integer *m, integer *n, integer *nrhs, real *a, integer *lda, real *b, integer *ldb, integer *jpvt, real *rcond, integer *rank, real *work, integer *info); /* Subroutine */ int sgelsy_(integer *m, integer *n, integer *nrhs, real *a, integer *lda, real *b, integer *ldb, integer *jpvt, real *rcond, integer *rank, real *work, integer *lwork, integer *info); /* Subroutine */ int sgeql2_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sgeqlf_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sgeqp3_(integer *m, integer *n, real *a, integer *lda, integer *jpvt, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sgeqpf_(integer *m, integer *n, real *a, integer *lda, integer *jpvt, real *tau, real *work, integer *info); /* Subroutine */ int sgeqr2_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sgeqrf_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sgerfs_(char *trans, integer *n, integer *nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real * work, integer *iwork, integer *info); /* Subroutine */ int sgerfsx_(char *trans, char *equed, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, real *r__, real *c__, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *params, real *work, integer *iwork, integer *info); /* Subroutine */ int sgerq2_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sgerqf_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sgesc2_(integer *n, real *a, integer *lda, real *rhs, integer *ipiv, integer *jpiv, real *scale); /* Subroutine */ int sgesdd_(char *jobz, integer *m, integer *n, real *a, integer *lda, real *s, real *u, integer *ldu, real *vt, integer *ldvt, real *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int sgesv_(integer *n, integer *nrhs, real *a, integer *lda, integer *ipiv, real *b, integer *ldb, integer *info); /* Subroutine */ int sgesvd_(char *jobu, char *jobvt, integer *m, integer *n, real *a, integer *lda, real *s, real *u, integer *ldu, real *vt, integer *ldvt, real *work, integer *lwork, integer *info); /* Subroutine */ int sgesvj_(char *joba, char *jobu, char *jobv, integer *m, integer *n, real *a, integer *lda, real *sva, integer *mv, real *v, integer *ldv, real *work, integer *lwork, integer *info); /* Subroutine */ int sgesvx_(char *fact, char *trans, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, char *equed, real *r__, real *c__, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int sgesvxx_(char *fact, char *trans, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, char *equed, real *r__, real *c__, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, integer * n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer * nparams, real *params, real *work, integer *iwork, integer *info); /* Subroutine */ int sgetc2_(integer *n, real *a, integer *lda, integer *ipiv, integer *jpiv, integer *info); /* Subroutine */ int sgetf2_(integer *m, integer *n, real *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int sgetrf_(integer *m, integer *n, real *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int sgetri_(integer *n, real *a, integer *lda, integer *ipiv, real *work, integer *lwork, integer *info); /* Subroutine */ int sgetrs_(char *trans, integer *n, integer *nrhs, real *a, integer *lda, integer *ipiv, real *b, integer *ldb, integer *info); /* Subroutine */ int sggbak_(char *job, char *side, integer *n, integer *ilo, integer *ihi, real *lscale, real *rscale, integer *m, real *v, integer *ldv, integer *info); /* Subroutine */ int sggbal_(char *job, integer *n, real *a, integer *lda, real *b, integer *ldb, integer *ilo, integer *ihi, real *lscale, real *rscale, real *work, integer *info); /* Subroutine */ int sgges_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, integer *n, real *a, integer *lda, real *b, integer *ldb, integer *sdim, real *alphar, real *alphai, real *beta, real *vsl, integer *ldvsl, real *vsr, integer *ldvsr, real *work, integer *lwork, logical *bwork, integer *info); /* Subroutine */ int sggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, char *sense, integer *n, real *a, integer *lda, real *b, integer *ldb, integer *sdim, real *alphar, real *alphai, real *beta, real *vsl, integer *ldvsl, real *vsr, integer *ldvsr, real *rconde, real *rcondv, real *work, integer *lwork, integer *iwork, integer * liwork, logical *bwork, integer *info); /* Subroutine */ int sggev_(char *jobvl, char *jobvr, integer *n, real *a, integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real *beta, real *vl, integer *ldvl, real *vr, integer *ldvr, real *work, integer *lwork, integer *info); /* Subroutine */ int sggevx_(char *balanc, char *jobvl, char *jobvr, char * sense, integer *n, real *a, integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real *beta, real *vl, integer *ldvl, real *vr, integer *ldvr, integer *ilo, integer *ihi, real *lscale, real *rscale, real *abnrm, real *bbnrm, real *rconde, real *rcondv, real *work, integer *lwork, integer *iwork, logical *bwork, integer *info); /* Subroutine */ int sggglm_(integer *n, integer *m, integer *p, real *a, integer *lda, real *b, integer *ldb, real *d__, real *x, real *y, real *work, integer *lwork, integer *info); /* Subroutine */ int sgghrd_(char *compq, char *compz, integer *n, integer * ilo, integer *ihi, real *a, integer *lda, real *b, integer *ldb, real *q, integer *ldq, real *z__, integer *ldz, integer *info); /* Subroutine */ int sgglse_(integer *m, integer *n, integer *p, real *a, integer *lda, real *b, integer *ldb, real *c__, real *d__, real *x, real *work, integer *lwork, integer *info); /* Subroutine */ int sggqrf_(integer *n, integer *m, integer *p, real *a, integer *lda, real *taua, real *b, integer *ldb, real *taub, real * work, integer *lwork, integer *info); /* Subroutine */ int sggrqf_(integer *m, integer *p, integer *n, real *a, integer *lda, real *taua, real *b, integer *ldb, real *taub, real * work, integer *lwork, integer *info); /* Subroutine */ int sggsvd_(char *jobu, char *jobv, char *jobq, integer *m, integer *n, integer *p, integer *k, integer *l, real *a, integer *lda, real *b, integer *ldb, real *alpha, real *beta, real *u, integer * ldu, real *v, integer *ldv, real *q, integer *ldq, real *work, integer *iwork, integer *info); /* Subroutine */ int sggsvp_(char *jobu, char *jobv, char *jobq, integer *m, integer *p, integer *n, real *a, integer *lda, real *b, integer *ldb, real *tola, real *tolb, integer *k, integer *l, real *u, integer *ldu, real *v, integer *ldv, real *q, integer *ldq, integer *iwork, real * tau, real *work, integer *info); /* Subroutine */ int sgsvj0_(char *jobv, integer *m, integer *n, real *a, integer *lda, real *d__, real *sva, integer *mv, real *v, integer * ldv, real *eps, real *sfmin, real *tol, integer *nsweep, real *work, integer *lwork, integer *info); /* Subroutine */ int sgsvj1_(char *jobv, integer *m, integer *n, integer *n1, real *a, integer *lda, real *d__, real *sva, integer *mv, real *v, integer *ldv, real *eps, real *sfmin, real *tol, integer *nsweep, real *work, integer *lwork, integer *info); /* Subroutine */ int sgtcon_(char *norm, integer *n, real *dl, real *d__, real *du, real *du2, integer *ipiv, real *anorm, real *rcond, real * work, integer *iwork, integer *info); /* Subroutine */ int sgtrfs_(char *trans, integer *n, integer *nrhs, real *dl, real *d__, real *du, real *dlf, real *df, real *duf, real *du2, integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real * ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int sgtsv_(integer *n, integer *nrhs, real *dl, real *d__, real *du, real *b, integer *ldb, integer *info); /* Subroutine */ int sgtsvx_(char *fact, char *trans, integer *n, integer * nrhs, real *dl, real *d__, real *du, real *dlf, real *df, real *duf, real *du2, integer *ipiv, real *b, integer *ldb, real *x, integer * ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int sgttrf_(integer *n, real *dl, real *d__, real *du, real * du2, integer *ipiv, integer *info); /* Subroutine */ int sgttrs_(char *trans, integer *n, integer *nrhs, real *dl, real *d__, real *du, real *du2, integer *ipiv, real *b, integer *ldb, integer *info); /* Subroutine */ int sgtts2_(integer *itrans, integer *n, integer *nrhs, real *dl, real *d__, real *du, real *du2, integer *ipiv, real *b, integer * ldb); /* Subroutine */ int shgeqz_(char *job, char *compq, char *compz, integer *n, integer *ilo, integer *ihi, real *h__, integer *ldh, real *t, integer *ldt, real *alphar, real *alphai, real *beta, real *q, integer *ldq, real *z__, integer *ldz, real *work, integer *lwork, integer *info); /* Subroutine */ int shsein_(char *side, char *eigsrc, char *initv, logical * select, integer *n, real *h__, integer *ldh, real *wr, real *wi, real *vl, integer *ldvl, real *vr, integer *ldvr, integer *mm, integer *m, real *work, integer *ifaill, integer *ifailr, integer *info); /* Subroutine */ int shseqr_(char *job, char *compz, integer *n, integer *ilo, integer *ihi, real *h__, integer *ldh, real *wr, real *wi, real *z__, integer *ldz, real *work, integer *lwork, integer *info); logical sisnan_(real *sin__); /* Subroutine */ int sla_gbamv__(integer *trans, integer *m, integer *n, integer *kl, integer *ku, real *alpha, real *ab, integer *ldab, real * x, integer *incx, real *beta, real *y, integer *incy); doublereal sla_gbrcond__(char *trans, integer *n, integer *kl, integer *ku, real *ab, integer *ldab, real *afb, integer *ldafb, integer *ipiv, integer *cmode, real *c__, integer *info, real *work, integer *iwork, ftnlen trans_len); /* Subroutine */ int sla_gbrfsx_extended__(integer *prec_type__, integer * trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, integer *ipiv, logical *colequ, real *c__, real *b, integer *ldb, real *y, integer * ldy, real *berr_out__, integer *n_norms__, real *errs_n__, real * errs_c__, real *res, real *ayb, real *dy, real *y_tail__, real *rcond, integer *ithresh, real *rthresh, real *dz_ub__, logical * ignore_cwise__, integer *info); doublereal sla_gbrpvgrw__(integer *n, integer *kl, integer *ku, integer * ncols, real *ab, integer *ldab, real *afb, integer *ldafb); /* Subroutine */ int sla_geamv__(integer *trans, integer *m, integer *n, real *alpha, real *a, integer *lda, real *x, integer *incx, real *beta, real *y, integer *incy); doublereal sla_gercond__(char *trans, integer *n, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, integer *cmode, real *c__, integer *info, real *work, integer *iwork, ftnlen trans_len); /* Subroutine */ int sla_gerfsx_extended__(integer *prec_type__, integer * trans_type__, integer *n, integer *nrhs, real *a, integer *lda, real * af, integer *ldaf, integer *ipiv, logical *colequ, real *c__, real *b, integer *ldb, real *y, integer *ldy, real *berr_out__, integer * n_norms__, real *errs_n__, real *errs_c__, real *res, real *ayb, real *dy, real *y_tail__, real *rcond, integer *ithresh, real *rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info); /* Subroutine */ int sla_lin_berr__(integer *n, integer *nz, integer *nrhs, real *res, real *ayb, real *berr); doublereal sla_porcond__(char *uplo, integer *n, real *a, integer *lda, real * af, integer *ldaf, integer *cmode, real *c__, integer *info, real * work, integer *iwork, ftnlen uplo_len); /* Subroutine */ int sla_porfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, real *a, integer *lda, real *af, integer * ldaf, logical *colequ, real *c__, real *b, integer *ldb, real *y, integer *ldy, real *berr_out__, integer *n_norms__, real *errs_n__, real *errs_c__, real *res, real *ayb, real *dy, real *y_tail__, real * rcond, integer *ithresh, real *rthresh, real *dz_ub__, logical * ignore_cwise__, integer *info, ftnlen uplo_len); doublereal sla_porpvgrw__(char *uplo, integer *ncols, real *a, integer *lda, real *af, integer *ldaf, real *work, ftnlen uplo_len); doublereal sla_rpvgrw__(integer *n, integer *ncols, real *a, integer *lda, real *af, integer *ldaf); /* Subroutine */ int sla_syamv__(integer *uplo, integer *n, real *alpha, real *a, integer *lda, real *x, integer *incx, real *beta, real *y, integer *incy); doublereal sla_syrcond__(char *uplo, integer *n, real *a, integer *lda, real * af, integer *ldaf, integer *ipiv, integer *cmode, real *c__, integer * info, real *work, integer *iwork, ftnlen uplo_len); /* Subroutine */ int sla_syrfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, real *a, integer *lda, real *af, integer * ldaf, integer *ipiv, logical *colequ, real *c__, real *b, integer * ldb, real *y, integer *ldy, real *berr_out__, integer *n_norms__, real *errs_n__, real *errs_c__, real *res, real *ayb, real *dy, real * y_tail__, real *rcond, integer *ithresh, real *rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info, ftnlen uplo_len); doublereal sla_syrpvgrw__(char *uplo, integer *n, integer *info, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, real *work, ftnlen uplo_len); /* Subroutine */ int sla_wwaddw__(integer *n, real *x, real *y, real *w); /* Subroutine */ int slabad_(real *small, real *large); /* Subroutine */ int slabrd_(integer *m, integer *n, integer *nb, real *a, integer *lda, real *d__, real *e, real *tauq, real *taup, real *x, integer *ldx, real *y, integer *ldy); /* Subroutine */ int slacn2_(integer *n, real *v, real *x, integer *isgn, real *est, integer *kase, integer *isave); /* Subroutine */ int slacon_(integer *n, real *v, real *x, integer *isgn, real *est, integer *kase); /* Subroutine */ int slacpy_(char *uplo, integer *m, integer *n, real *a, integer *lda, real *b, integer *ldb); /* Subroutine */ int sladiv_(real *a, real *b, real *c__, real *d__, real *p, real *q); /* Subroutine */ int slae2_(real *a, real *b, real *c__, real *rt1, real *rt2); /* Subroutine */ int slaebz_(integer *ijob, integer *nitmax, integer *n, integer *mmax, integer *minp, integer *nbmin, real *abstol, real * reltol, real *pivmin, real *d__, real *e, real *e2, integer *nval, real *ab, real *c__, integer *mout, integer *nab, real *work, integer *iwork, integer *info); /* Subroutine */ int slaed0_(integer *icompq, integer *qsiz, integer *n, real *d__, real *e, real *q, integer *ldq, real *qstore, integer *ldqs, real *work, integer *iwork, integer *info); /* Subroutine */ int slaed1_(integer *n, real *d__, real *q, integer *ldq, integer *indxq, real *rho, integer *cutpnt, real *work, integer * iwork, integer *info); /* Subroutine */ int slaed2_(integer *k, integer *n, integer *n1, real *d__, real *q, integer *ldq, integer *indxq, real *rho, real *z__, real * dlamda, real *w, real *q2, integer *indx, integer *indxc, integer * indxp, integer *coltyp, integer *info); /* Subroutine */ int slaed3_(integer *k, integer *n, integer *n1, real *d__, real *q, integer *ldq, real *rho, real *dlamda, real *q2, integer * indx, integer *ctot, real *w, real *s, integer *info); /* Subroutine */ int slaed4_(integer *n, integer *i__, real *d__, real *z__, real *delta, real *rho, real *dlam, integer *info); /* Subroutine */ int slaed5_(integer *i__, real *d__, real *z__, real *delta, real *rho, real *dlam); /* Subroutine */ int slaed6_(integer *kniter, logical *orgati, real *rho, real *d__, real *z__, real *finit, real *tau, integer *info); /* Subroutine */ int slaed7_(integer *icompq, integer *n, integer *qsiz, integer *tlvls, integer *curlvl, integer *curpbm, real *d__, real *q, integer *ldq, integer *indxq, real *rho, integer *cutpnt, real * qstore, integer *qptr, integer *prmptr, integer *perm, integer * givptr, integer *givcol, real *givnum, real *work, integer *iwork, integer *info); /* Subroutine */ int slaed8_(integer *icompq, integer *k, integer *n, integer *qsiz, real *d__, real *q, integer *ldq, integer *indxq, real *rho, integer *cutpnt, real *z__, real *dlamda, real *q2, integer *ldq2, real *w, integer *perm, integer *givptr, integer *givcol, real * givnum, integer *indxp, integer *indx, integer *info); /* Subroutine */ int slaed9_(integer *k, integer *kstart, integer *kstop, integer *n, real *d__, real *q, integer *ldq, real *rho, real *dlamda, real *w, real *s, integer *lds, integer *info); /* Subroutine */ int slaeda_(integer *n, integer *tlvls, integer *curlvl, integer *curpbm, integer *prmptr, integer *perm, integer *givptr, integer *givcol, real *givnum, real *q, integer *qptr, real *z__, real *ztemp, integer *info); /* Subroutine */ int slaein_(logical *rightv, logical *noinit, integer *n, real *h__, integer *ldh, real *wr, real *wi, real *vr, real *vi, real *b, integer *ldb, real *work, real *eps3, real *smlnum, real *bignum, integer *info); /* Subroutine */ int slaev2_(real *a, real *b, real *c__, real *rt1, real * rt2, real *cs1, real *sn1); /* Subroutine */ int slaexc_(logical *wantq, integer *n, real *t, integer * ldt, real *q, integer *ldq, integer *j1, integer *n1, integer *n2, real *work, integer *info); /* Subroutine */ int slag2_(real *a, integer *lda, real *b, integer *ldb, real *safmin, real *scale1, real *scale2, real *wr1, real *wr2, real * wi); /* Subroutine */ int slag2d_(integer *m, integer *n, real *sa, integer *ldsa, doublereal *a, integer *lda, integer *info); /* Subroutine */ int slags2_(logical *upper, real *a1, real *a2, real *a3, real *b1, real *b2, real *b3, real *csu, real *snu, real *csv, real * snv, real *csq, real *snq); /* Subroutine */ int slagtf_(integer *n, real *a, real *lambda, real *b, real *c__, real *tol, real *d__, integer *in, integer *info); /* Subroutine */ int slagtm_(char *trans, integer *n, integer *nrhs, real * alpha, real *dl, real *d__, real *du, real *x, integer *ldx, real * beta, real *b, integer *ldb); /* Subroutine */ int slagts_(integer *job, integer *n, real *a, real *b, real *c__, real *d__, integer *in, real *y, real *tol, integer *info); /* Subroutine */ int slagv2_(real *a, integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real *beta, real *csl, real *snl, real * csr, real *snr); /* Subroutine */ int slahqr_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, real *h__, integer *ldh, real *wr, real * wi, integer *iloz, integer *ihiz, real *z__, integer *ldz, integer * info); /* Subroutine */ int slahr2_(integer *n, integer *k, integer *nb, real *a, integer *lda, real *tau, real *t, integer *ldt, real *y, integer *ldy); /* Subroutine */ int slahrd_(integer *n, integer *k, integer *nb, real *a, integer *lda, real *tau, real *t, integer *ldt, real *y, integer *ldy); /* Subroutine */ int slaic1_(integer *job, integer *j, real *x, real *sest, real *w, real *gamma, real *sestpr, real *s, real *c__); logical slaisnan_(real *sin1, real *sin2); /* Subroutine */ int slaln2_(logical *ltrans, integer *na, integer *nw, real * smin, real *ca, real *a, integer *lda, real *d1, real *d2, real *b, integer *ldb, real *wr, real *wi, real *x, integer *ldx, real *scale, real *xnorm, integer *info); /* Subroutine */ int slals0_(integer *icompq, integer *nl, integer *nr, integer *sqre, integer *nrhs, real *b, integer *ldb, real *bx, integer *ldbx, integer *perm, integer *givptr, integer *givcol, integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real * difl, real *difr, real *z__, integer *k, real *c__, real *s, real * work, integer *info); /* Subroutine */ int slalsa_(integer *icompq, integer *smlsiz, integer *n, integer *nrhs, real *b, integer *ldb, real *bx, integer *ldbx, real * u, integer *ldu, real *vt, integer *k, real *difl, real *difr, real * z__, real *poles, integer *givptr, integer *givcol, integer *ldgcol, integer *perm, real *givnum, real *c__, real *s, real *work, integer * iwork, integer *info); /* Subroutine */ int slalsd_(char *uplo, integer *smlsiz, integer *n, integer *nrhs, real *d__, real *e, real *b, integer *ldb, real *rcond, integer *rank, real *work, integer *iwork, integer *info); /* Subroutine */ int slamrg_(integer *n1, integer *n2, real *a, integer * strd1, integer *strd2, integer *index); integer slaneg_(integer *n, real *d__, real *lld, real *sigma, real *pivmin, integer *r__); doublereal slangb_(char *norm, integer *n, integer *kl, integer *ku, real *ab, integer *ldab, real *work); doublereal slange_(char *norm, integer *m, integer *n, real *a, integer *lda, real *work); doublereal slangt_(char *norm, integer *n, real *dl, real *d__, real *du); doublereal slanhs_(char *norm, integer *n, real *a, integer *lda, real *work); doublereal slansb_(char *norm, char *uplo, integer *n, integer *k, real *ab, integer *ldab, real *work); doublereal slansf_(char *norm, char *transr, char *uplo, integer *n, real *a, real *work); doublereal slansp_(char *norm, char *uplo, integer *n, real *ap, real *work); doublereal slanst_(char *norm, integer *n, real *d__, real *e); doublereal slansy_(char *norm, char *uplo, integer *n, real *a, integer *lda, real *work); doublereal slantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, real *ab, integer *ldab, real *work); doublereal slantp_(char *norm, char *uplo, char *diag, integer *n, real *ap, real *work); doublereal slantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, real *a, integer *lda, real *work); /* Subroutine */ int slanv2_(real *a, real *b, real *c__, real *d__, real * rt1r, real *rt1i, real *rt2r, real *rt2i, real *cs, real *sn); /* Subroutine */ int slapll_(integer *n, real *x, integer *incx, real *y, integer *incy, real *ssmin); /* Subroutine */ int slapmt_(logical *forwrd, integer *m, integer *n, real *x, integer *ldx, integer *k); doublereal slapy2_(real *x, real *y); doublereal slapy3_(real *x, real *y, real *z__); /* Subroutine */ int slaqgb_(integer *m, integer *n, integer *kl, integer *ku, real *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real * colcnd, real *amax, char *equed); /* Subroutine */ int slaqge_(integer *m, integer *n, real *a, integer *lda, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, char * equed); /* Subroutine */ int slaqp2_(integer *m, integer *n, integer *offset, real *a, integer *lda, integer *jpvt, real *tau, real *vn1, real *vn2, real * work); /* Subroutine */ int slaqps_(integer *m, integer *n, integer *offset, integer *nb, integer *kb, real *a, integer *lda, integer *jpvt, real *tau, real *vn1, real *vn2, real *auxv, real *f, integer *ldf); /* Subroutine */ int slaqr0_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, real *h__, integer *ldh, real *wr, real * wi, integer *iloz, integer *ihiz, real *z__, integer *ldz, real *work, integer *lwork, integer *info); /* Subroutine */ int slaqr1_(integer *n, real *h__, integer *ldh, real *sr1, real *si1, real *sr2, real *si2, real *v); /* Subroutine */ int slaqr2_(logical *wantt, logical *wantz, integer *n, integer *ktop, integer *kbot, integer *nw, real *h__, integer *ldh, integer *iloz, integer *ihiz, real *z__, integer *ldz, integer *ns, integer *nd, real *sr, real *si, real *v, integer *ldv, integer *nh, real *t, integer *ldt, integer *nv, real *wv, integer *ldwv, real * work, integer *lwork); /* Subroutine */ int slaqr3_(logical *wantt, logical *wantz, integer *n, integer *ktop, integer *kbot, integer *nw, real *h__, integer *ldh, integer *iloz, integer *ihiz, real *z__, integer *ldz, integer *ns, integer *nd, real *sr, real *si, real *v, integer *ldv, integer *nh, real *t, integer *ldt, integer *nv, real *wv, integer *ldwv, real * work, integer *lwork); /* Subroutine */ int slaqr4_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, real *h__, integer *ldh, real *wr, real * wi, integer *iloz, integer *ihiz, real *z__, integer *ldz, real *work, integer *lwork, integer *info); /* Subroutine */ int slaqr5_(logical *wantt, logical *wantz, integer *kacc22, integer *n, integer *ktop, integer *kbot, integer *nshfts, real *sr, real *si, real *h__, integer *ldh, integer *iloz, integer *ihiz, real *z__, integer *ldz, real *v, integer *ldv, real *u, integer *ldu, integer *nv, real *wv, integer *ldwv, integer *nh, real *wh, integer * ldwh); /* Subroutine */ int slaqsb_(char *uplo, integer *n, integer *kd, real *ab, integer *ldab, real *s, real *scond, real *amax, char *equed); /* Subroutine */ int slaqsp_(char *uplo, integer *n, real *ap, real *s, real * scond, real *amax, char *equed); /* Subroutine */ int slaqsy_(char *uplo, integer *n, real *a, integer *lda, real *s, real *scond, real *amax, char *equed); /* Subroutine */ int slaqtr_(logical *ltran, logical *lreal, integer *n, real *t, integer *ldt, real *b, real *w, real *scale, real *x, real *work, integer *info); /* Subroutine */ int slar1v_(integer *n, integer *b1, integer *bn, real * lambda, real *d__, real *l, real *ld, real *lld, real *pivmin, real * gaptol, real *z__, logical *wantnc, integer *negcnt, real *ztz, real * mingma, integer *r__, integer *isuppz, real *nrminv, real *resid, real *rqcorr, real *work); /* Subroutine */ int slar2v_(integer *n, real *x, real *y, real *z__, integer *incx, real *c__, real *s, integer *incc); /* Subroutine */ int slarf_(char *side, integer *m, integer *n, real *v, integer *incv, real *tau, real *c__, integer *ldc, real *work); /* Subroutine */ int slarfb_(char *side, char *trans, char *direct, char * storev, integer *m, integer *n, integer *k, real *v, integer *ldv, real *t, integer *ldt, real *c__, integer *ldc, real *work, integer * ldwork); /* Subroutine */ int slarfg_(integer *n, real *alpha, real *x, integer *incx, real *tau); /* Subroutine */ int slarfp_(integer *n, real *alpha, real *x, integer *incx, real *tau); /* Subroutine */ int slarft_(char *direct, char *storev, integer *n, integer * k, real *v, integer *ldv, real *tau, real *t, integer *ldt); /* Subroutine */ int slarfx_(char *side, integer *m, integer *n, real *v, real *tau, real *c__, integer *ldc, real *work); /* Subroutine */ int slargv_(integer *n, real *x, integer *incx, real *y, integer *incy, real *c__, integer *incc); /* Subroutine */ int slarnv_(integer *idist, integer *iseed, integer *n, real *x); /* Subroutine */ int slarra_(integer *n, real *d__, real *e, real *e2, real * spltol, real *tnrm, integer *nsplit, integer *isplit, integer *info); /* Subroutine */ int slarrb_(integer *n, real *d__, real *lld, integer * ifirst, integer *ilast, real *rtol1, real *rtol2, integer *offset, real *w, real *wgap, real *werr, real *work, integer *iwork, real * pivmin, real *spdiam, integer *twist, integer *info); /* Subroutine */ int slarrc_(char *jobt, integer *n, real *vl, real *vu, real *d__, real *e, real *pivmin, integer *eigcnt, integer *lcnt, integer * rcnt, integer *info); /* Subroutine */ int slarrd_(char *range, char *order, integer *n, real *vl, real *vu, integer *il, integer *iu, real *gers, real *reltol, real * d__, real *e, real *e2, real *pivmin, integer *nsplit, integer * isplit, integer *m, real *w, real *werr, real *wl, real *wu, integer * iblock, integer *indexw, real *work, integer *iwork, integer *info); /* Subroutine */ int slarre_(char *range, integer *n, real *vl, real *vu, integer *il, integer *iu, real *d__, real *e, real *e2, real *rtol1, real *rtol2, real *spltol, integer *nsplit, integer *isplit, integer * m, real *w, real *werr, real *wgap, integer *iblock, integer *indexw, real *gers, real *pivmin, real *work, integer *iwork, integer *info); /* Subroutine */ int slarrf_(integer *n, real *d__, real *l, real *ld, integer *clstrt, integer *clend, real *w, real *wgap, real *werr, real *spdiam, real *clgapl, real *clgapr, real *pivmin, real *sigma, real *dplus, real *lplus, real *work, integer *info); /* Subroutine */ int slarrj_(integer *n, real *d__, real *e2, integer *ifirst, integer *ilast, real *rtol, integer *offset, real *w, real *werr, real *work, integer *iwork, real *pivmin, real *spdiam, integer *info); /* Subroutine */ int slarrk_(integer *n, integer *iw, real *gl, real *gu, real *d__, real *e2, real *pivmin, real *reltol, real *w, real *werr, integer *info); /* Subroutine */ int slarrr_(integer *n, real *d__, real *e, integer *info); /* Subroutine */ int slarrv_(integer *n, real *vl, real *vu, real *d__, real * l, real *pivmin, integer *isplit, integer *m, integer *dol, integer * dou, real *minrgp, real *rtol1, real *rtol2, real *w, real *werr, real *wgap, integer *iblock, integer *indexw, real *gers, real *z__, integer *ldz, integer *isuppz, real *work, integer *iwork, integer * info); /* Subroutine */ int slarscl2_(integer *m, integer *n, real *d__, real *x, integer *ldx); /* Subroutine */ int slartg_(real *f, real *g, real *cs, real *sn, real *r__); /* Subroutine */ int slartv_(integer *n, real *x, integer *incx, real *y, integer *incy, real *c__, real *s, integer *incc); /* Subroutine */ int slaruv_(integer *iseed, integer *n, real *x); /* Subroutine */ int slarz_(char *side, integer *m, integer *n, integer *l, real *v, integer *incv, real *tau, real *c__, integer *ldc, real * work); /* Subroutine */ int slarzb_(char *side, char *trans, char *direct, char * storev, integer *m, integer *n, integer *k, integer *l, real *v, integer *ldv, real *t, integer *ldt, real *c__, integer *ldc, real * work, integer *ldwork); /* Subroutine */ int slarzt_(char *direct, char *storev, integer *n, integer * k, real *v, integer *ldv, real *tau, real *t, integer *ldt); /* Subroutine */ int slas2_(real *f, real *g, real *h__, real *ssmin, real * ssmax); /* Subroutine */ int slascl_(char *type__, integer *kl, integer *ku, real * cfrom, real *cto, integer *m, integer *n, real *a, integer *lda, integer *info); /* Subroutine */ int slascl2_(integer *m, integer *n, real *d__, real *x, integer *ldx); /* Subroutine */ int slasd0_(integer *n, integer *sqre, real *d__, real *e, real *u, integer *ldu, real *vt, integer *ldvt, integer *smlsiz, integer *iwork, real *work, integer *info); /* Subroutine */ int slasd1_(integer *nl, integer *nr, integer *sqre, real * d__, real *alpha, real *beta, real *u, integer *ldu, real *vt, integer *ldvt, integer *idxq, integer *iwork, real *work, integer * info); /* Subroutine */ int slasd2_(integer *nl, integer *nr, integer *sqre, integer *k, real *d__, real *z__, real *alpha, real *beta, real *u, integer * ldu, real *vt, integer *ldvt, real *dsigma, real *u2, integer *ldu2, real *vt2, integer *ldvt2, integer *idxp, integer *idx, integer *idxc, integer *idxq, integer *coltyp, integer *info); /* Subroutine */ int slasd3_(integer *nl, integer *nr, integer *sqre, integer *k, real *d__, real *q, integer *ldq, real *dsigma, real *u, integer * ldu, real *u2, integer *ldu2, real *vt, integer *ldvt, real *vt2, integer *ldvt2, integer *idxc, integer *ctot, real *z__, integer * info); /* Subroutine */ int slasd4_(integer *n, integer *i__, real *d__, real *z__, real *delta, real *rho, real *sigma, real *work, integer *info); /* Subroutine */ int slasd5_(integer *i__, real *d__, real *z__, real *delta, real *rho, real *dsigma, real *work); /* Subroutine */ int slasd6_(integer *icompq, integer *nl, integer *nr, integer *sqre, real *d__, real *vf, real *vl, real *alpha, real *beta, integer *idxq, integer *perm, integer *givptr, integer *givcol, integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real * difl, real *difr, real *z__, integer *k, real *c__, real *s, real * work, integer *iwork, integer *info); /* Subroutine */ int slasd7_(integer *icompq, integer *nl, integer *nr, integer *sqre, integer *k, real *d__, real *z__, real *zw, real *vf, real *vfw, real *vl, real *vlw, real *alpha, real *beta, real *dsigma, integer *idx, integer *idxp, integer *idxq, integer *perm, integer * givptr, integer *givcol, integer *ldgcol, real *givnum, integer * ldgnum, real *c__, real *s, integer *info); /* Subroutine */ int slasd8_(integer *icompq, integer *k, real *d__, real * z__, real *vf, real *vl, real *difl, real *difr, integer *lddifr, real *dsigma, real *work, integer *info); /* Subroutine */ int slasda_(integer *icompq, integer *smlsiz, integer *n, integer *sqre, real *d__, real *e, real *u, integer *ldu, real *vt, integer *k, real *difl, real *difr, real *z__, real *poles, integer * givptr, integer *givcol, integer *ldgcol, integer *perm, real *givnum, real *c__, real *s, real *work, integer *iwork, integer *info); /* Subroutine */ int slasdq_(char *uplo, integer *sqre, integer *n, integer * ncvt, integer *nru, integer *ncc, real *d__, real *e, real *vt, integer *ldvt, real *u, integer *ldu, real *c__, integer *ldc, real * work, integer *info); /* Subroutine */ int slasdt_(integer *n, integer *lvl, integer *nd, integer * inode, integer *ndiml, integer *ndimr, integer *msub); /* Subroutine */ int slaset_(char *uplo, integer *m, integer *n, real *alpha, real *beta, real *a, integer *lda); /* Subroutine */ int slasq1_(integer *n, real *d__, real *e, real *work, integer *info); /* Subroutine */ int slasq2_(integer *n, real *z__, integer *info); /* Subroutine */ int slasq3_(integer *i0, integer *n0, real *z__, integer *pp, real *dmin__, real *sigma, real *desig, real *qmax, integer *nfail, integer *iter, integer *ndiv, logical *ieee, integer *ttype, real * dmin1, real *dmin2, real *dn, real *dn1, real *dn2, real *g, real * tau); /* Subroutine */ int slasq4_(integer *i0, integer *n0, real *z__, integer *pp, integer *n0in, real *dmin__, real *dmin1, real *dmin2, real *dn, real *dn1, real *dn2, real *tau, integer *ttype, real *g); /* Subroutine */ int slasq5_(integer *i0, integer *n0, real *z__, integer *pp, real *tau, real *dmin__, real *dmin1, real *dmin2, real *dn, real * dnm1, real *dnm2, logical *ieee); /* Subroutine */ int slasq6_(integer *i0, integer *n0, real *z__, integer *pp, real *dmin__, real *dmin1, real *dmin2, real *dn, real *dnm1, real * dnm2); /* Subroutine */ int slasr_(char *side, char *pivot, char *direct, integer *m, integer *n, real *c__, real *s, real *a, integer *lda); /* Subroutine */ int slasrt_(char *id, integer *n, real *d__, integer *info); /* Subroutine */ int slassq_(integer *n, real *x, integer *incx, real *scale, real *sumsq); /* Subroutine */ int slasv2_(real *f, real *g, real *h__, real *ssmin, real * ssmax, real *snr, real *csr, real *snl, real *csl); /* Subroutine */ int slaswp_(integer *n, real *a, integer *lda, integer *k1, integer *k2, integer *ipiv, integer *incx); /* Subroutine */ int slasy2_(logical *ltranl, logical *ltranr, integer *isgn, integer *n1, integer *n2, real *tl, integer *ldtl, real *tr, integer * ldtr, real *b, integer *ldb, real *scale, real *x, integer *ldx, real *xnorm, integer *info); /* Subroutine */ int slasyf_(char *uplo, integer *n, integer *nb, integer *kb, real *a, integer *lda, integer *ipiv, real *w, integer *ldw, integer *info); /* Subroutine */ int slatbs_(char *uplo, char *trans, char *diag, char * normin, integer *n, integer *kd, real *ab, integer *ldab, real *x, real *scale, real *cnorm, integer *info); /* Subroutine */ int slatdf_(integer *ijob, integer *n, real *z__, integer * ldz, real *rhs, real *rdsum, real *rdscal, integer *ipiv, integer * jpiv); /* Subroutine */ int slatps_(char *uplo, char *trans, char *diag, char * normin, integer *n, real *ap, real *x, real *scale, real *cnorm, integer *info); /* Subroutine */ int slatrd_(char *uplo, integer *n, integer *nb, real *a, integer *lda, real *e, real *tau, real *w, integer *ldw); /* Subroutine */ int slatrs_(char *uplo, char *trans, char *diag, char * normin, integer *n, real *a, integer *lda, real *x, real *scale, real *cnorm, integer *info); /* Subroutine */ int slatrz_(integer *m, integer *n, integer *l, real *a, integer *lda, real *tau, real *work); /* Subroutine */ int slatzm_(char *side, integer *m, integer *n, real *v, integer *incv, real *tau, real *c1, real *c2, integer *ldc, real * work); /* Subroutine */ int slauu2_(char *uplo, integer *n, real *a, integer *lda, integer *info); /* Subroutine */ int slauum_(char *uplo, integer *n, real *a, integer *lda, integer *info); /* Subroutine */ int sopgtr_(char *uplo, integer *n, real *ap, real *tau, real *q, integer *ldq, real *work, integer *info); /* Subroutine */ int sopmtr_(char *side, char *uplo, char *trans, integer *m, integer *n, real *ap, real *tau, real *c__, integer *ldc, real *work, integer *info); /* Subroutine */ int sorg2l_(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sorg2r_(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sorgbr_(char *vect, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sorghr_(integer *n, integer *ilo, integer *ihi, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sorgl2_(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sorglq_(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sorgql_(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sorgqr_(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sorgr2_(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *info); /* Subroutine */ int sorgrq_(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sorgtr_(char *uplo, integer *n, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int sorm2l_(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *info); /* Subroutine */ int sorm2r_(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *info); /* Subroutine */ int sormbr_(char *vect, char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *lwork, integer *info); /* Subroutine */ int sormhr_(char *side, char *trans, integer *m, integer *n, integer *ilo, integer *ihi, real *a, integer *lda, real *tau, real * c__, integer *ldc, real *work, integer *lwork, integer *info); /* Subroutine */ int sorml2_(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *info); /* Subroutine */ int sormlq_(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *lwork, integer *info); /* Subroutine */ int sormql_(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *lwork, integer *info); /* Subroutine */ int sormqr_(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *lwork, integer *info); /* Subroutine */ int sormr2_(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *info); /* Subroutine */ int sormr3_(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *info); /* Subroutine */ int sormrq_(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *lwork, integer *info); /* Subroutine */ int sormrz_(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *lwork, integer *info); /* Subroutine */ int sormtr_(char *side, char *uplo, char *trans, integer *m, integer *n, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *lwork, integer *info); /* Subroutine */ int spbcon_(char *uplo, integer *n, integer *kd, real *ab, integer *ldab, real *anorm, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int spbequ_(char *uplo, integer *n, integer *kd, real *ab, integer *ldab, real *s, real *scond, real *amax, integer *info); /* Subroutine */ int spbrfs_(char *uplo, integer *n, integer *kd, integer * nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real * work, integer *iwork, integer *info); /* Subroutine */ int spbstf_(char *uplo, integer *n, integer *kd, real *ab, integer *ldab, integer *info); /* Subroutine */ int spbsv_(char *uplo, integer *n, integer *kd, integer * nrhs, real *ab, integer *ldab, real *b, integer *ldb, integer *info); /* Subroutine */ int spbsvx_(char *fact, char *uplo, integer *n, integer *kd, integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, char *equed, real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int spbtf2_(char *uplo, integer *n, integer *kd, real *ab, integer *ldab, integer *info); /* Subroutine */ int spbtrf_(char *uplo, integer *n, integer *kd, real *ab, integer *ldab, integer *info); /* Subroutine */ int spbtrs_(char *uplo, integer *n, integer *kd, integer * nrhs, real *ab, integer *ldab, real *b, integer *ldb, integer *info); /* Subroutine */ int spftrf_(char *transr, char *uplo, integer *n, real *a, integer *info); /* Subroutine */ int spftri_(char *transr, char *uplo, integer *n, real *a, integer *info); /* Subroutine */ int spftrs_(char *transr, char *uplo, integer *n, integer * nrhs, real *a, real *b, integer *ldb, integer *info); /* Subroutine */ int spocon_(char *uplo, integer *n, real *a, integer *lda, real *anorm, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int spoequ_(integer *n, real *a, integer *lda, real *s, real *scond, real *amax, integer *info); /* Subroutine */ int spoequb_(integer *n, real *a, integer *lda, real *s, real *scond, real *amax, integer *info); /* Subroutine */ int sporfs_(char *uplo, integer *n, integer *nrhs, real *a, integer *lda, real *af, integer *ldaf, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int sporfsx_(char *uplo, char *equed, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, real *s, real * b, integer *ldb, real *x, integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *params, real *work, integer *iwork, integer * info); /* Subroutine */ int sposv_(char *uplo, integer *n, integer *nrhs, real *a, integer *lda, real *b, integer *ldb, integer *info); /* Subroutine */ int sposvx_(char *fact, char *uplo, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, char *equed, real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int sposvxx_(char *fact, char *uplo, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, char *equed, real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, integer *n_err_bnds__, real * err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real * params, real *work, integer *iwork, integer *info); /* Subroutine */ int spotf2_(char *uplo, integer *n, real *a, integer *lda, integer *info); /* Subroutine */ int spotrf_(char *uplo, integer *n, real *a, integer *lda, integer *info); /* Subroutine */ int spotri_(char *uplo, integer *n, real *a, integer *lda, integer *info); /* Subroutine */ int spotrs_(char *uplo, integer *n, integer *nrhs, real *a, integer *lda, real *b, integer *ldb, integer *info); /* Subroutine */ int sppcon_(char *uplo, integer *n, real *ap, real *anorm, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int sppequ_(char *uplo, integer *n, real *ap, real *s, real * scond, real *amax, integer *info); /* Subroutine */ int spprfs_(char *uplo, integer *n, integer *nrhs, real *ap, real *afp, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int sppsv_(char *uplo, integer *n, integer *nrhs, real *ap, real *b, integer *ldb, integer *info); /* Subroutine */ int sppsvx_(char *fact, char *uplo, integer *n, integer * nrhs, real *ap, real *afp, char *equed, real *s, real *b, integer * ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int spptrf_(char *uplo, integer *n, real *ap, integer *info); /* Subroutine */ int spptri_(char *uplo, integer *n, real *ap, integer *info); /* Subroutine */ int spptrs_(char *uplo, integer *n, integer *nrhs, real *ap, real *b, integer *ldb, integer *info); /* Subroutine */ int spstf2_(char *uplo, integer *n, real *a, integer *lda, integer *piv, integer *rank, real *tol, real *work, integer *info); /* Subroutine */ int spstrf_(char *uplo, integer *n, real *a, integer *lda, integer *piv, integer *rank, real *tol, real *work, integer *info); /* Subroutine */ int sptcon_(integer *n, real *d__, real *e, real *anorm, real *rcond, real *work, integer *info); /* Subroutine */ int spteqr_(char *compz, integer *n, real *d__, real *e, real *z__, integer *ldz, real *work, integer *info); /* Subroutine */ int sptrfs_(integer *n, integer *nrhs, real *d__, real *e, real *df, real *ef, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *work, integer *info); /* Subroutine */ int sptsv_(integer *n, integer *nrhs, real *d__, real *e, real *b, integer *ldb, integer *info); /* Subroutine */ int sptsvx_(char *fact, integer *n, integer *nrhs, real *d__, real *e, real *df, real *ef, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, integer *info); /* Subroutine */ int spttrf_(integer *n, real *d__, real *e, integer *info); /* Subroutine */ int spttrs_(integer *n, integer *nrhs, real *d__, real *e, real *b, integer *ldb, integer *info); /* Subroutine */ int sptts2_(integer *n, integer *nrhs, real *d__, real *e, real *b, integer *ldb); /* Subroutine */ int srscl_(integer *n, real *sa, real *sx, integer *incx); /* Subroutine */ int ssbev_(char *jobz, char *uplo, integer *n, integer *kd, real *ab, integer *ldab, real *w, real *z__, integer *ldz, real *work, integer *info); /* Subroutine */ int ssbevd_(char *jobz, char *uplo, integer *n, integer *kd, real *ab, integer *ldab, real *w, real *z__, integer *ldz, real *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int ssbevx_(char *jobz, char *range, char *uplo, integer *n, integer *kd, real *ab, integer *ldab, real *q, integer *ldq, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real * w, real *z__, integer *ldz, real *work, integer *iwork, integer * ifail, integer *info); /* Subroutine */ int ssbgst_(char *vect, char *uplo, integer *n, integer *ka, integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real * x, integer *ldx, real *work, integer *info); /* Subroutine */ int ssbgv_(char *jobz, char *uplo, integer *n, integer *ka, integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real * w, real *z__, integer *ldz, real *work, integer *info); /* Subroutine */ int ssbgvd_(char *jobz, char *uplo, integer *n, integer *ka, integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real * w, real *z__, integer *ldz, real *work, integer *lwork, integer * iwork, integer *liwork, integer *info); /* Subroutine */ int ssbgvx_(char *jobz, char *range, char *uplo, integer *n, integer *ka, integer *kb, real *ab, integer *ldab, real *bb, integer * ldbb, real *q, integer *ldq, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, real *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int ssbtrd_(char *vect, char *uplo, integer *n, integer *kd, real *ab, integer *ldab, real *d__, real *e, real *q, integer *ldq, real *work, integer *info); /* Subroutine */ int ssfrk_(char *transr, char *uplo, char *trans, integer *n, integer *k, real *alpha, real *a, integer *lda, real *beta, real * c__); /* Subroutine */ int sspcon_(char *uplo, integer *n, real *ap, integer *ipiv, real *anorm, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int sspev_(char *jobz, char *uplo, integer *n, real *ap, real *w, real *z__, integer *ldz, real *work, integer *info); /* Subroutine */ int sspevd_(char *jobz, char *uplo, integer *n, real *ap, real *w, real *z__, integer *ldz, real *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int sspevx_(char *jobz, char *range, char *uplo, integer *n, real *ap, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, real *work, integer * iwork, integer *ifail, integer *info); /* Subroutine */ int sspgst_(integer *itype, char *uplo, integer *n, real *ap, real *bp, integer *info); /* Subroutine */ int sspgv_(integer *itype, char *jobz, char *uplo, integer * n, real *ap, real *bp, real *w, real *z__, integer *ldz, real *work, integer *info); /* Subroutine */ int sspgvd_(integer *itype, char *jobz, char *uplo, integer * n, real *ap, real *bp, real *w, real *z__, integer *ldz, real *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int sspgvx_(integer *itype, char *jobz, char *range, char * uplo, integer *n, real *ap, real *bp, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer * ldz, real *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int ssprfs_(char *uplo, integer *n, integer *nrhs, real *ap, real *afp, integer *ipiv, real *b, integer *ldb, real *x, integer * ldx, real *ferr, real *berr, real *work, integer *iwork, integer * info); /* Subroutine */ int sspsv_(char *uplo, integer *n, integer *nrhs, real *ap, integer *ipiv, real *b, integer *ldb, integer *info); /* Subroutine */ int sspsvx_(char *fact, char *uplo, integer *n, integer * nrhs, real *ap, real *afp, integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int ssptrd_(char *uplo, integer *n, real *ap, real *d__, real *e, real *tau, integer *info); /* Subroutine */ int ssptrf_(char *uplo, integer *n, real *ap, integer *ipiv, integer *info); /* Subroutine */ int ssptri_(char *uplo, integer *n, real *ap, integer *ipiv, real *work, integer *info); /* Subroutine */ int ssptrs_(char *uplo, integer *n, integer *nrhs, real *ap, integer *ipiv, real *b, integer *ldb, integer *info); /* Subroutine */ int sstebz_(char *range, char *order, integer *n, real *vl, real *vu, integer *il, integer *iu, real *abstol, real *d__, real *e, integer *m, integer *nsplit, real *w, integer *iblock, integer * isplit, real *work, integer *iwork, integer *info); /* Subroutine */ int sstedc_(char *compz, integer *n, real *d__, real *e, real *z__, integer *ldz, real *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int sstegr_(char *jobz, char *range, integer *n, real *d__, real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, integer *isuppz, real * work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int sstein_(integer *n, real *d__, real *e, integer *m, real *w, integer *iblock, integer *isplit, real *z__, integer *ldz, real * work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int sstemr_(char *jobz, char *range, integer *n, real *d__, real *e, real *vl, real *vu, integer *il, integer *iu, integer *m, real *w, real *z__, integer *ldz, integer *nzc, integer *isuppz, logical *tryrac, real *work, integer *lwork, integer *iwork, integer * liwork, integer *info); /* Subroutine */ int ssteqr_(char *compz, integer *n, real *d__, real *e, real *z__, integer *ldz, real *work, integer *info); /* Subroutine */ int ssterf_(integer *n, real *d__, real *e, integer *info); /* Subroutine */ int sstev_(char *jobz, integer *n, real *d__, real *e, real * z__, integer *ldz, real *work, integer *info); /* Subroutine */ int sstevd_(char *jobz, integer *n, real *d__, real *e, real *z__, integer *ldz, real *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int sstevr_(char *jobz, char *range, integer *n, real *d__, real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, integer *isuppz, real * work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int sstevx_(char *jobz, char *range, integer *n, real *d__, real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, real *work, integer * iwork, integer *ifail, integer *info); /* Subroutine */ int ssycon_(char *uplo, integer *n, real *a, integer *lda, integer *ipiv, real *anorm, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int ssyequb_(char *uplo, integer *n, real *a, integer *lda, real *s, real *scond, real *amax, real *work, integer *info); /* Subroutine */ int ssyev_(char *jobz, char *uplo, integer *n, real *a, integer *lda, real *w, real *work, integer *lwork, integer *info); /* Subroutine */ int ssyevd_(char *jobz, char *uplo, integer *n, real *a, integer *lda, real *w, real *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int ssyevr_(char *jobz, char *range, char *uplo, integer *n, real *a, integer *lda, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, integer * isuppz, real *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int ssyevx_(char *jobz, char *range, char *uplo, integer *n, real *a, integer *lda, real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, real * work, integer *lwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int ssygs2_(integer *itype, char *uplo, integer *n, real *a, integer *lda, real *b, integer *ldb, integer *info); /* Subroutine */ int ssygst_(integer *itype, char *uplo, integer *n, real *a, integer *lda, real *b, integer *ldb, integer *info); /* Subroutine */ int ssygv_(integer *itype, char *jobz, char *uplo, integer * n, real *a, integer *lda, real *b, integer *ldb, real *w, real *work, integer *lwork, integer *info); /* Subroutine */ int ssygvd_(integer *itype, char *jobz, char *uplo, integer * n, real *a, integer *lda, real *b, integer *ldb, real *w, real *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int ssygvx_(integer *itype, char *jobz, char *range, char * uplo, integer *n, real *a, integer *lda, real *b, integer *ldb, real * vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, real *work, integer *lwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int ssyrfs_(char *uplo, integer *n, integer *nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real * work, integer *iwork, integer *info); /* Subroutine */ int ssyrfsx_(char *uplo, char *equed, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real * err_bnds_comp__, integer *nparams, real *params, real *work, integer * iwork, integer *info); /* Subroutine */ int ssysv_(char *uplo, integer *n, integer *nrhs, real *a, integer *lda, integer *ipiv, real *b, integer *ldb, real *work, integer *lwork, integer *info); /* Subroutine */ int ssysvx_(char *fact, char *uplo, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, integer *lwork, integer *iwork, integer * info); /* Subroutine */ int ssysvxx_(char *fact, char *uplo, integer *n, integer * nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, char *equed, real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, integer *n_err_bnds__, real * err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real * params, real *work, integer *iwork, integer *info); /* Subroutine */ int ssytd2_(char *uplo, integer *n, real *a, integer *lda, real *d__, real *e, real *tau, integer *info); /* Subroutine */ int ssytf2_(char *uplo, integer *n, real *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int ssytrd_(char *uplo, integer *n, real *a, integer *lda, real *d__, real *e, real *tau, real *work, integer *lwork, integer * info); /* Subroutine */ int ssytrf_(char *uplo, integer *n, real *a, integer *lda, integer *ipiv, real *work, integer *lwork, integer *info); /* Subroutine */ int ssytri_(char *uplo, integer *n, real *a, integer *lda, integer *ipiv, real *work, integer *info); /* Subroutine */ int ssytrs_(char *uplo, integer *n, integer *nrhs, real *a, integer *lda, integer *ipiv, real *b, integer *ldb, integer *info); /* Subroutine */ int stbcon_(char *norm, char *uplo, char *diag, integer *n, integer *kd, real *ab, integer *ldab, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int stbrfs_(char *uplo, char *trans, char *diag, integer *n, integer *kd, integer *nrhs, real *ab, integer *ldab, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int stbtrs_(char *uplo, char *trans, char *diag, integer *n, integer *kd, integer *nrhs, real *ab, integer *ldab, real *b, integer *ldb, integer *info); /* Subroutine */ int stfsm_(char *transr, char *side, char *uplo, char *trans, char *diag, integer *m, integer *n, real *alpha, real *a, real *b, integer *ldb); /* Subroutine */ int stftri_(char *transr, char *uplo, char *diag, integer *n, real *a, integer *info); /* Subroutine */ int stfttp_(char *transr, char *uplo, integer *n, real *arf, real *ap, integer *info); /* Subroutine */ int stfttr_(char *transr, char *uplo, integer *n, real *arf, real *a, integer *lda, integer *info); /* Subroutine */ int stgevc_(char *side, char *howmny, logical *select, integer *n, real *s, integer *lds, real *p, integer *ldp, real *vl, integer *ldvl, real *vr, integer *ldvr, integer *mm, integer *m, real *work, integer *info); /* Subroutine */ int stgex2_(logical *wantq, logical *wantz, integer *n, real *a, integer *lda, real *b, integer *ldb, real *q, integer *ldq, real * z__, integer *ldz, integer *j1, integer *n1, integer *n2, real *work, integer *lwork, integer *info); /* Subroutine */ int stgexc_(logical *wantq, logical *wantz, integer *n, real *a, integer *lda, real *b, integer *ldb, real *q, integer *ldq, real * z__, integer *ldz, integer *ifst, integer *ilst, real *work, integer * lwork, integer *info); /* Subroutine */ int stgsen_(integer *ijob, logical *wantq, logical *wantz, logical *select, integer *n, real *a, integer *lda, real *b, integer * ldb, real *alphar, real *alphai, real *beta, real *q, integer *ldq, real *z__, integer *ldz, integer *m, real *pl, real *pr, real *dif, real *work, integer *lwork, integer *iwork, integer *liwork, integer * info); /* Subroutine */ int stgsja_(char *jobu, char *jobv, char *jobq, integer *m, integer *p, integer *n, integer *k, integer *l, real *a, integer *lda, real *b, integer *ldb, real *tola, real *tolb, real *alpha, real * beta, real *u, integer *ldu, real *v, integer *ldv, real *q, integer * ldq, real *work, integer *ncycle, integer *info); /* Subroutine */ int stgsna_(char *job, char *howmny, logical *select, integer *n, real *a, integer *lda, real *b, integer *ldb, real *vl, integer *ldvl, real *vr, integer *ldvr, real *s, real *dif, integer * mm, integer *m, real *work, integer *lwork, integer *iwork, integer * info); /* Subroutine */ int stgsy2_(char *trans, integer *ijob, integer *m, integer * n, real *a, integer *lda, real *b, integer *ldb, real *c__, integer * ldc, real *d__, integer *ldd, real *e, integer *lde, real *f, integer *ldf, real *scale, real *rdsum, real *rdscal, integer *iwork, integer *pq, integer *info); /* Subroutine */ int stgsyl_(char *trans, integer *ijob, integer *m, integer * n, real *a, integer *lda, real *b, integer *ldb, real *c__, integer * ldc, real *d__, integer *ldd, real *e, integer *lde, real *f, integer *ldf, real *scale, real *dif, real *work, integer *lwork, integer * iwork, integer *info); /* Subroutine */ int stpcon_(char *norm, char *uplo, char *diag, integer *n, real *ap, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int stprfs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, real *ap, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int stptri_(char *uplo, char *diag, integer *n, real *ap, integer *info); /* Subroutine */ int stptrs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, real *ap, real *b, integer *ldb, integer *info); /* Subroutine */ int stpttf_(char *transr, char *uplo, integer *n, real *ap, real *arf, integer *info); /* Subroutine */ int stpttr_(char *uplo, integer *n, real *ap, real *a, integer *lda, integer *info); /* Subroutine */ int strcon_(char *norm, char *uplo, char *diag, integer *n, real *a, integer *lda, real *rcond, real *work, integer *iwork, integer *info); /* Subroutine */ int strevc_(char *side, char *howmny, logical *select, integer *n, real *t, integer *ldt, real *vl, integer *ldvl, real *vr, integer *ldvr, integer *mm, integer *m, real *work, integer *info); /* Subroutine */ int strexc_(char *compq, integer *n, real *t, integer *ldt, real *q, integer *ldq, integer *ifst, integer *ilst, real *work, integer *info); /* Subroutine */ int strrfs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, real *a, integer *lda, real *b, integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *work, integer *iwork, integer *info); /* Subroutine */ int strsen_(char *job, char *compq, logical *select, integer *n, real *t, integer *ldt, real *q, integer *ldq, real *wr, real *wi, integer *m, real *s, real *sep, real *work, integer *lwork, integer * iwork, integer *liwork, integer *info); /* Subroutine */ int strsna_(char *job, char *howmny, logical *select, integer *n, real *t, integer *ldt, real *vl, integer *ldvl, real *vr, integer *ldvr, real *s, real *sep, integer *mm, integer *m, real * work, integer *ldwork, integer *iwork, integer *info); /* Subroutine */ int strsyl_(char *trana, char *tranb, integer *isgn, integer *m, integer *n, real *a, integer *lda, real *b, integer *ldb, real * c__, integer *ldc, real *scale, integer *info); /* Subroutine */ int strti2_(char *uplo, char *diag, integer *n, real *a, integer *lda, integer *info); /* Subroutine */ int strtri_(char *uplo, char *diag, integer *n, real *a, integer *lda, integer *info); /* Subroutine */ int strtrs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, real *a, integer *lda, real *b, integer *ldb, integer * info); /* Subroutine */ int strttf_(char *transr, char *uplo, integer *n, real *a, integer *lda, real *arf, integer *info); /* Subroutine */ int strttp_(char *uplo, integer *n, real *a, integer *lda, real *ap, integer *info); /* Subroutine */ int stzrqf_(integer *m, integer *n, real *a, integer *lda, real *tau, integer *info); /* Subroutine */ int stzrzf_(integer *m, integer *n, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info); /* Subroutine */ int xerbla_(char *srname, integer *info); /* Subroutine */ int xerbla_array__(char *srname_array__, integer * srname_len__, integer *info, ftnlen srname_array_len); /* Subroutine */ int zbdsqr_(char *uplo, integer *n, integer *ncvt, integer * nru, integer *ncc, doublereal *d__, doublereal *e, doublecomplex *vt, integer *ldvt, doublecomplex *u, integer *ldu, doublecomplex *c__, integer *ldc, doublereal *rwork, integer *info); /* Subroutine */ int zcgesv_(integer *n, integer *nrhs, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublecomplex *work, complex *swork, doublereal *rwork, integer *iter, integer *info); /* Subroutine */ int zcposv_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublecomplex *work, complex *swork, doublereal *rwork, integer *iter, integer *info); /* Subroutine */ int zdrscl_(integer *n, doublereal *sa, doublecomplex *sx, integer *incx); /* Subroutine */ int zgbbrd_(char *vect, integer *m, integer *n, integer *ncc, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, doublereal *d__, doublereal *e, doublecomplex *q, integer *ldq, doublecomplex *pt, integer *ldpt, doublecomplex *c__, integer *ldc, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zgbcon_(char *norm, integer *n, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *work, doublereal *rwork, integer * info); /* Subroutine */ int zgbequ_(integer *m, integer *n, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer * info); /* Subroutine */ int zgbequb_(integer *m, integer *n, integer *kl, integer * ku, doublecomplex *ab, integer *ldab, doublereal *r__, doublereal * c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *info); /* Subroutine */ int zgbrfs_(char *trans, integer *n, integer *kl, integer * ku, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex * afb, integer *ldafb, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zgbrfsx_(char *trans, char *equed, integer *n, integer * kl, integer *ku, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, integer *ipiv, doublereal *r__, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *berr, integer * n_err_bnds__, doublereal *err_bnds_norm__, doublereal * err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zgbsv_(integer *n, integer *kl, integer *ku, integer * nrhs, doublecomplex *ab, integer *ldab, integer *ipiv, doublecomplex * b, integer *ldb, integer *info); /* Subroutine */ int zgbsvx_(char *fact, char *trans, integer *n, integer *kl, integer *ku, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer * info); /* Subroutine */ int zgbsvxx_(char *fact, char *trans, integer *n, integer * kl, integer *ku, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zgbtf2_(integer *m, integer *n, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, integer *ipiv, integer *info); /* Subroutine */ int zgbtrf_(integer *m, integer *n, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, integer *ipiv, integer *info); /* Subroutine */ int zgbtrs_(char *trans, integer *n, integer *kl, integer * ku, integer *nrhs, doublecomplex *ab, integer *ldab, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zgebak_(char *job, char *side, integer *n, integer *ilo, integer *ihi, doublereal *scale, integer *m, doublecomplex *v, integer *ldv, integer *info); /* Subroutine */ int zgebal_(char *job, integer *n, doublecomplex *a, integer *lda, integer *ilo, integer *ihi, doublereal *scale, integer *info); /* Subroutine */ int zgebd2_(integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *d__, doublereal *e, doublecomplex *tauq, doublecomplex *taup, doublecomplex *work, integer *info); /* Subroutine */ int zgebrd_(integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *d__, doublereal *e, doublecomplex *tauq, doublecomplex *taup, doublecomplex *work, integer *lwork, integer * info); /* Subroutine */ int zgecon_(char *norm, integer *n, doublecomplex *a, integer *lda, doublereal *anorm, doublereal *rcond, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zgeequ_(integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *info); /* Subroutine */ int zgeequb_(integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *info); /* Subroutine */ int zgees_(char *jobvs, char *sort, L_fp select, integer *n, doublecomplex *a, integer *lda, integer *sdim, doublecomplex *w, doublecomplex *vs, integer *ldvs, doublecomplex *work, integer *lwork, doublereal *rwork, logical *bwork, integer *info); /* Subroutine */ int zgeesx_(char *jobvs, char *sort, L_fp select, char * sense, integer *n, doublecomplex *a, integer *lda, integer *sdim, doublecomplex *w, doublecomplex *vs, integer *ldvs, doublereal * rconde, doublereal *rcondv, doublecomplex *work, integer *lwork, doublereal *rwork, logical *bwork, integer *info); /* Subroutine */ int zgeev_(char *jobvl, char *jobvr, integer *n, doublecomplex *a, integer *lda, doublecomplex *w, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zgeevx_(char *balanc, char *jobvl, char *jobvr, char * sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *w, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, integer *ilo, integer *ihi, doublereal *scale, doublereal *abnrm, doublereal *rconde, doublereal *rcondv, doublecomplex *work, integer * lwork, doublereal *rwork, integer *info); /* Subroutine */ int zgegs_(char *jobvsl, char *jobvsr, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, integer *ldvsl, doublecomplex *vsr, integer *ldvsr, doublecomplex * work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zgegv_(char *jobvl, char *jobvr, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zgehd2_(integer *n, integer *ilo, integer *ihi, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *info); /* Subroutine */ int zgehrd_(integer *n, integer *ilo, integer *ihi, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *lwork, integer *info); /* Subroutine */ int zgelq2_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *info); /* Subroutine */ int zgelqf_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zgels_(char *trans, integer *m, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zgelsd_(integer *m, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *s, doublereal *rcond, integer *rank, doublecomplex *work, integer *lwork, doublereal *rwork, integer *iwork, integer *info); /* Subroutine */ int zgelss_(integer *m, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *s, doublereal *rcond, integer *rank, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zgelsx_(integer *m, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *jpvt, doublereal *rcond, integer *rank, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zgelsy_(integer *m, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *jpvt, doublereal *rcond, integer *rank, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zgeql2_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *info); /* Subroutine */ int zgeqlf_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zgeqp3_(integer *m, integer *n, doublecomplex *a, integer *lda, integer *jpvt, doublecomplex *tau, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zgeqpf_(integer *m, integer *n, doublecomplex *a, integer *lda, integer *jpvt, doublecomplex *tau, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zgeqr2_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *info); /* Subroutine */ int zgeqrf_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zgerfs_(char *trans, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zgerfsx_(char *trans, char *equed, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, doublereal *r__, doublereal *c__, doublecomplex * b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zgerq2_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *info); /* Subroutine */ int zgerqf_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zgesc2_(integer *n, doublecomplex *a, integer *lda, doublecomplex *rhs, integer *ipiv, integer *jpiv, doublereal *scale); /* Subroutine */ int zgesdd_(char *jobz, integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *s, doublecomplex *u, integer *ldu, doublecomplex *vt, integer *ldvt, doublecomplex *work, integer *lwork, doublereal *rwork, integer *iwork, integer *info); /* Subroutine */ int zgesv_(integer *n, integer *nrhs, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, integer * info); /* Subroutine */ int zgesvd_(char *jobu, char *jobvt, integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *s, doublecomplex *u, integer *ldu, doublecomplex *vt, integer *ldvt, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zgesvx_(char *fact, char *trans, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zgesvxx_(char *fact, char *trans, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, doublereal *berr, integer * n_err_bnds__, doublereal *err_bnds_norm__, doublereal * err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zgetc2_(integer *n, doublecomplex *a, integer *lda, integer *ipiv, integer *jpiv, integer *info); /* Subroutine */ int zgetf2_(integer *m, integer *n, doublecomplex *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int zgetrf_(integer *m, integer *n, doublecomplex *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int zgetri_(integer *n, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zgetrs_(char *trans, integer *n, integer *nrhs, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zggbak_(char *job, char *side, integer *n, integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, integer *m, doublecomplex *v, integer *ldv, integer *info); /* Subroutine */ int zggbal_(char *job, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, doublereal *work, integer * info); /* Subroutine */ int zgges_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *sdim, doublecomplex *alpha, doublecomplex * beta, doublecomplex *vsl, integer *ldvsl, doublecomplex *vsr, integer *ldvsr, doublecomplex *work, integer *lwork, doublereal *rwork, logical *bwork, integer *info); /* Subroutine */ int zggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, char *sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *sdim, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, integer *ldvsl, doublecomplex *vsr, integer *ldvsr, doublereal *rconde, doublereal * rcondv, doublecomplex *work, integer *lwork, doublereal *rwork, integer *iwork, integer *liwork, logical *bwork, integer *info); /* Subroutine */ int zggev_(char *jobvl, char *jobvr, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zggevx_(char *balanc, char *jobvl, char *jobvr, char * sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, doublereal *abnrm, doublereal *bbnrm, doublereal *rconde, doublereal * rcondv, doublecomplex *work, integer *lwork, doublereal *rwork, integer *iwork, logical *bwork, integer *info); /* Subroutine */ int zggglm_(integer *n, integer *m, integer *p, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *d__, doublecomplex *x, doublecomplex *y, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zgghrd_(char *compq, char *compz, integer *n, integer * ilo, integer *ihi, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *q, integer *ldq, doublecomplex *z__, integer *ldz, integer *info); /* Subroutine */ int zgglse_(integer *m, integer *n, integer *p, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *c__, doublecomplex *d__, doublecomplex *x, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zggqrf_(integer *n, integer *m, integer *p, doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b, integer *ldb, doublecomplex *taub, doublecomplex *work, integer * lwork, integer *info); /* Subroutine */ int zggrqf_(integer *m, integer *p, integer *n, doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b, integer *ldb, doublecomplex *taub, doublecomplex *work, integer * lwork, integer *info); /* Subroutine */ int zggsvd_(char *jobu, char *jobv, char *jobq, integer *m, integer *n, integer *p, integer *k, integer *l, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *alpha, doublereal *beta, doublecomplex *u, integer *ldu, doublecomplex *v, integer *ldv, doublecomplex *q, integer *ldq, doublecomplex *work, doublereal *rwork, integer *iwork, integer *info); /* Subroutine */ int zggsvp_(char *jobu, char *jobv, char *jobq, integer *m, integer *p, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *tola, doublereal *tolb, integer *k, integer *l, doublecomplex *u, integer *ldu, doublecomplex *v, integer *ldv, doublecomplex *q, integer *ldq, integer *iwork, doublereal * rwork, doublecomplex *tau, doublecomplex *work, integer *info); /* Subroutine */ int zgtcon_(char *norm, integer *n, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, doublecomplex *du2, integer * ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *work, integer *info); /* Subroutine */ int zgtrfs_(char *trans, integer *n, integer *nrhs, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, doublecomplex *dlf, doublecomplex *df, doublecomplex *duf, doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zgtsv_(integer *n, integer *nrhs, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zgtsvx_(char *fact, char *trans, integer *n, integer * nrhs, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, doublecomplex *dlf, doublecomplex *df, doublecomplex *duf, doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer * info); /* Subroutine */ int zgttrf_(integer *n, doublecomplex *dl, doublecomplex * d__, doublecomplex *du, doublecomplex *du2, integer *ipiv, integer * info); /* Subroutine */ int zgttrs_(char *trans, integer *n, integer *nrhs, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zgtts2_(integer *itrans, integer *n, integer *nrhs, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb); /* Subroutine */ int zhbev_(char *jobz, char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zhbevd_(char *jobz, char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork, integer *lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int zhbevx_(char *jobz, char *range, char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublecomplex *q, integer *ldq, doublereal *vl, doublereal *vu, integer *il, integer * iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal *rwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int zhbgst_(char *vect, char *uplo, integer *n, integer *ka, integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, integer *ldbb, doublecomplex *x, integer *ldx, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zhbgv_(char *jobz, char *uplo, integer *n, integer *ka, integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, integer *ldbb, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zhbgvd_(char *jobz, char *uplo, integer *n, integer *ka, integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, integer *ldbb, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork, integer * lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int zhbgvx_(char *jobz, char *range, char *uplo, integer *n, integer *ka, integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, integer *ldbb, doublecomplex *q, integer *ldq, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal * abstol, integer *m, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal *rwork, integer *iwork, integer * ifail, integer *info); /* Subroutine */ int zhbtrd_(char *vect, char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublereal *d__, doublereal *e, doublecomplex *q, integer *ldq, doublecomplex *work, integer *info); /* Subroutine */ int zhecon_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *work, integer *info); /* Subroutine */ int zheequb_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *s, doublereal *scond, doublereal *amax, doublecomplex *work, integer *info); /* Subroutine */ int zheev_(char *jobz, char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *w, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zheevd_(char *jobz, char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *w, doublecomplex *work, integer *lwork, doublereal *rwork, integer *lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int zheevr_(char *jobz, char *range, char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal * w, doublecomplex *z__, integer *ldz, integer *isuppz, doublecomplex * work, integer *lwork, doublereal *rwork, integer *lrwork, integer * iwork, integer *liwork, integer *info); /* Subroutine */ int zheevx_(char *jobz, char *range, char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal * w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer * lwork, doublereal *rwork, integer *iwork, integer *ifail, integer * info); /* Subroutine */ int zhegs2_(integer *itype, char *uplo, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zhegst_(integer *itype, char *uplo, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zhegv_(integer *itype, char *jobz, char *uplo, integer * n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *w, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zhegvd_(integer *itype, char *jobz, char *uplo, integer * n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *w, doublecomplex *work, integer *lwork, doublereal *rwork, integer *lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int zhegvx_(integer *itype, char *jobz, char *range, char * uplo, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *vl, doublereal *vu, integer *il, integer * iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int zherfs_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zherfsx_(char *uplo, char *equed, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal * err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zhesv_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zhesvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zhesvxx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, char *equed, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer * nparams, doublereal *params, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zhetd2_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *d__, doublereal *e, doublecomplex *tau, integer *info); /* Subroutine */ int zhetf2_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int zhetrd_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *d__, doublereal *e, doublecomplex *tau, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zhetrf_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zhetri_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *work, integer *info); /* Subroutine */ int zhetrs_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zhfrk_(char *transr, char *uplo, char *trans, integer *n, integer *k, doublereal *alpha, doublecomplex *a, integer *lda, doublereal *beta, doublecomplex *c__); /* Subroutine */ int zhgeqz_(char *job, char *compq, char *compz, integer *n, integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, doublecomplex *t, integer *ldt, doublecomplex *alpha, doublecomplex * beta, doublecomplex *q, integer *ldq, doublecomplex *z__, integer * ldz, doublecomplex *work, integer *lwork, doublereal *rwork, integer * info); /* Subroutine */ int zhpcon_(char *uplo, integer *n, doublecomplex *ap, integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex * work, integer *info); /* Subroutine */ int zhpev_(char *jobz, char *uplo, integer *n, doublecomplex *ap, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zhpevd_(char *jobz, char *uplo, integer *n, doublecomplex *ap, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork, integer * lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int zhpevx_(char *jobz, char *range, char *uplo, integer *n, doublecomplex *ap, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal * rwork, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int zhpgst_(integer *itype, char *uplo, integer *n, doublecomplex *ap, doublecomplex *bp, integer *info); /* Subroutine */ int zhpgv_(integer *itype, char *jobz, char *uplo, integer * n, doublecomplex *ap, doublecomplex *bp, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal *rwork, integer * info); /* Subroutine */ int zhpgvd_(integer *itype, char *jobz, char *uplo, integer * n, doublecomplex *ap, doublecomplex *bp, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, doublereal * rwork, integer *lrwork, integer *iwork, integer *liwork, integer * info); /* Subroutine */ int zhpgvx_(integer *itype, char *jobz, char *range, char * uplo, integer *n, doublecomplex *ap, doublecomplex *bp, doublereal * vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal *rwork, integer *iwork, integer * ifail, integer *info); /* Subroutine */ int zhprfs_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, doublecomplex *afp, integer *ipiv, doublecomplex * b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer * info); /* Subroutine */ int zhpsv_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zhpsvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *ap, doublecomplex *afp, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zhptrd_(char *uplo, integer *n, doublecomplex *ap, doublereal *d__, doublereal *e, doublecomplex *tau, integer *info); /* Subroutine */ int zhptrf_(char *uplo, integer *n, doublecomplex *ap, integer *ipiv, integer *info); /* Subroutine */ int zhptri_(char *uplo, integer *n, doublecomplex *ap, integer *ipiv, doublecomplex *work, integer *info); /* Subroutine */ int zhptrs_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zhsein_(char *side, char *eigsrc, char *initv, logical * select, integer *n, doublecomplex *h__, integer *ldh, doublecomplex * w, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, integer *mm, integer *m, doublecomplex *work, doublereal *rwork, integer *ifaill, integer *ifailr, integer *info); /* Subroutine */ int zhseqr_(char *job, char *compz, integer *n, integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, doublecomplex *w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zla_gbamv__(integer *trans, integer *m, integer *n, integer *kl, integer *ku, doublereal *alpha, doublecomplex *ab, integer *ldab, doublecomplex *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); doublereal zla_gbrcond_c__(char *trans, integer *n, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, integer *ipiv, doublereal *c__, logical *capply, integer *info, doublecomplex *work, doublereal *rwork, ftnlen trans_len); doublereal zla_gbrcond_x__(char *trans, integer *n, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, integer *ipiv, doublecomplex *x, integer *info, doublecomplex *work, doublereal *rwork, ftnlen trans_len); /* Subroutine */ int zla_gbrfsx_extended__(integer *prec_type__, integer * trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, integer *ipiv, logical *colequ, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *y, integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal *errs_n__, doublereal *errs_c__, doublecomplex *res, doublereal *ayb, doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *ignore_cwise__, integer *info); doublereal zla_gbrpvgrw__(integer *n, integer *kl, integer *ku, integer * ncols, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer * ldafb); /* Subroutine */ int zla_geamv__(integer *trans, integer *m, integer *n, doublereal *alpha, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); doublereal zla_gercond_c__(char *trans, integer *n, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublereal * c__, logical *capply, integer *info, doublecomplex *work, doublereal * rwork, ftnlen trans_len); doublereal zla_gercond_x__(char *trans, integer *n, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex * x, integer *info, doublecomplex *work, doublereal *rwork, ftnlen trans_len); /* Subroutine */ int zla_gerfsx_extended__(integer *prec_type__, integer * trans_type__, integer *n, integer *nrhs, doublecomplex *a, integer * lda, doublecomplex *af, integer *ldaf, integer *ipiv, logical *colequ, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *y, integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal * errs_n__, doublereal *errs_c__, doublecomplex *res, doublereal *ayb, doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical * ignore_cwise__, integer *info); /* Subroutine */ int zla_heamv__(integer *uplo, integer *n, doublereal *alpha, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); doublereal zla_hercond_c__(char *uplo, integer *n, doublecomplex *a, integer * lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublereal *c__, logical *capply, integer *info, doublecomplex *work, doublereal * rwork, ftnlen uplo_len); doublereal zla_hercond_x__(char *uplo, integer *n, doublecomplex *a, integer * lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex * x, integer *info, doublecomplex *work, doublereal *rwork, ftnlen uplo_len); /* Subroutine */ int zla_herfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, logical *colequ, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *y, integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal * errs_n__, doublereal *errs_c__, doublecomplex *res, doublereal *ayb, doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical * ignore_cwise__, integer *info, ftnlen uplo_len); doublereal zla_herpvgrw__(char *uplo, integer *n, integer *info, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublereal *work, ftnlen uplo_len); /* Subroutine */ int zla_lin_berr__(integer *n, integer *nz, integer *nrhs, doublecomplex *res, doublereal *ayb, doublereal *berr); doublereal zla_porcond_c__(char *uplo, integer *n, doublecomplex *a, integer * lda, doublecomplex *af, integer *ldaf, doublereal *c__, logical * capply, integer *info, doublecomplex *work, doublereal *rwork, ftnlen uplo_len); doublereal zla_porcond_x__(char *uplo, integer *n, doublecomplex *a, integer * lda, doublecomplex *af, integer *ldaf, doublecomplex *x, integer * info, doublecomplex *work, doublereal *rwork, ftnlen uplo_len); /* Subroutine */ int zla_porfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, logical *colequ, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *y, integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal *errs_n__, doublereal *errs_c__, doublecomplex *res, doublereal *ayb, doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical * ignore_cwise__, integer *info, ftnlen uplo_len); doublereal zla_porpvgrw__(char *uplo, integer *ncols, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, doublereal *work, ftnlen uplo_len); doublereal zla_rpvgrw__(integer *n, integer *ncols, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf); /* Subroutine */ int zla_syamv__(integer *uplo, integer *n, doublereal *alpha, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, doublereal *beta, doublereal *y, integer *incy); doublereal zla_syrcond_c__(char *uplo, integer *n, doublecomplex *a, integer * lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublereal *c__, logical *capply, integer *info, doublecomplex *work, doublereal * rwork, ftnlen uplo_len); doublereal zla_syrcond_x__(char *uplo, integer *n, doublecomplex *a, integer * lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex * x, integer *info, doublecomplex *work, doublereal *rwork, ftnlen uplo_len); /* Subroutine */ int zla_syrfsx_extended__(integer *prec_type__, char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, logical *colequ, doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *y, integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal * errs_n__, doublereal *errs_c__, doublecomplex *res, doublereal *ayb, doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical * ignore_cwise__, integer *info, ftnlen uplo_len); doublereal zla_syrpvgrw__(char *uplo, integer *n, integer *info, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublereal *work, ftnlen uplo_len); /* Subroutine */ int zla_wwaddw__(integer *n, doublecomplex *x, doublecomplex *y, doublecomplex *w); /* Subroutine */ int zlabrd_(integer *m, integer *n, integer *nb, doublecomplex *a, integer *lda, doublereal *d__, doublereal *e, doublecomplex *tauq, doublecomplex *taup, doublecomplex *x, integer * ldx, doublecomplex *y, integer *ldy); /* Subroutine */ int zlacgv_(integer *n, doublecomplex *x, integer *incx); /* Subroutine */ int zlacn2_(integer *n, doublecomplex *v, doublecomplex *x, doublereal *est, integer *kase, integer *isave); /* Subroutine */ int zlacon_(integer *n, doublecomplex *v, doublecomplex *x, doublereal *est, integer *kase); /* Subroutine */ int zlacp2_(char *uplo, integer *m, integer *n, doublereal * a, integer *lda, doublecomplex *b, integer *ldb); /* Subroutine */ int zlacpy_(char *uplo, integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb); /* Subroutine */ int zlacrm_(integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *b, integer *ldb, doublecomplex *c__, integer *ldc, doublereal *rwork); /* Subroutine */ int zlacrt_(integer *n, doublecomplex *cx, integer *incx, doublecomplex *cy, integer *incy, doublecomplex *c__, doublecomplex * s); /* Double Complex */ VOID zladiv_(doublecomplex * ret_val, doublecomplex *x, doublecomplex *y); /* Subroutine */ int zlaed0_(integer *qsiz, integer *n, doublereal *d__, doublereal *e, doublecomplex *q, integer *ldq, doublecomplex *qstore, integer *ldqs, doublereal *rwork, integer *iwork, integer *info); /* Subroutine */ int zlaed7_(integer *n, integer *cutpnt, integer *qsiz, integer *tlvls, integer *curlvl, integer *curpbm, doublereal *d__, doublecomplex *q, integer *ldq, doublereal *rho, integer *indxq, doublereal *qstore, integer *qptr, integer *prmptr, integer *perm, integer *givptr, integer *givcol, doublereal *givnum, doublecomplex * work, doublereal *rwork, integer *iwork, integer *info); /* Subroutine */ int zlaed8_(integer *k, integer *n, integer *qsiz, doublecomplex *q, integer *ldq, doublereal *d__, doublereal *rho, integer *cutpnt, doublereal *z__, doublereal *dlamda, doublecomplex * q2, integer *ldq2, doublereal *w, integer *indxp, integer *indx, integer *indxq, integer *perm, integer *givptr, integer *givcol, doublereal *givnum, integer *info); /* Subroutine */ int zlaein_(logical *rightv, logical *noinit, integer *n, doublecomplex *h__, integer *ldh, doublecomplex *w, doublecomplex *v, doublecomplex *b, integer *ldb, doublereal *rwork, doublereal *eps3, doublereal *smlnum, integer *info); /* Subroutine */ int zlaesy_(doublecomplex *a, doublecomplex *b, doublecomplex *c__, doublecomplex *rt1, doublecomplex *rt2, doublecomplex *evscal, doublecomplex *cs1, doublecomplex *sn1); /* Subroutine */ int zlaev2_(doublecomplex *a, doublecomplex *b, doublecomplex *c__, doublereal *rt1, doublereal *rt2, doublereal *cs1, doublecomplex *sn1); /* Subroutine */ int zlag2c_(integer *m, integer *n, doublecomplex *a, integer *lda, complex *sa, integer *ldsa, integer *info); /* Subroutine */ int zlags2_(logical *upper, doublereal *a1, doublecomplex * a2, doublereal *a3, doublereal *b1, doublecomplex *b2, doublereal *b3, doublereal *csu, doublecomplex *snu, doublereal *csv, doublecomplex * snv, doublereal *csq, doublecomplex *snq); /* Subroutine */ int zlagtm_(char *trans, integer *n, integer *nrhs, doublereal *alpha, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, doublecomplex *x, integer *ldx, doublereal *beta, doublecomplex *b, integer *ldb); /* Subroutine */ int zlahef_(char *uplo, integer *n, integer *nb, integer *kb, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *w, integer *ldw, integer *info); /* Subroutine */ int zlahqr_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, doublecomplex *w, integer *iloz, integer *ihiz, doublecomplex *z__, integer *ldz, integer *info); /* Subroutine */ int zlahr2_(integer *n, integer *k, integer *nb, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *t, integer *ldt, doublecomplex *y, integer *ldy); /* Subroutine */ int zlahrd_(integer *n, integer *k, integer *nb, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *t, integer *ldt, doublecomplex *y, integer *ldy); /* Subroutine */ int zlaic1_(integer *job, integer *j, doublecomplex *x, doublereal *sest, doublecomplex *w, doublecomplex *gamma, doublereal * sestpr, doublecomplex *s, doublecomplex *c__); /* Subroutine */ int zlals0_(integer *icompq, integer *nl, integer *nr, integer *sqre, integer *nrhs, doublecomplex *b, integer *ldb, doublecomplex *bx, integer *ldbx, integer *perm, integer *givptr, integer *givcol, integer *ldgcol, doublereal *givnum, integer *ldgnum, doublereal *poles, doublereal *difl, doublereal *difr, doublereal * z__, integer *k, doublereal *c__, doublereal *s, doublereal *rwork, integer *info); /* Subroutine */ int zlalsa_(integer *icompq, integer *smlsiz, integer *n, integer *nrhs, doublecomplex *b, integer *ldb, doublecomplex *bx, integer *ldbx, doublereal *u, integer *ldu, doublereal *vt, integer * k, doublereal *difl, doublereal *difr, doublereal *z__, doublereal * poles, integer *givptr, integer *givcol, integer *ldgcol, integer * perm, doublereal *givnum, doublereal *c__, doublereal *s, doublereal * rwork, integer *iwork, integer *info); /* Subroutine */ int zlalsd_(char *uplo, integer *smlsiz, integer *n, integer *nrhs, doublereal *d__, doublereal *e, doublecomplex *b, integer *ldb, doublereal *rcond, integer *rank, doublecomplex *work, doublereal * rwork, integer *iwork, integer *info); doublereal zlangb_(char *norm, integer *n, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, doublereal *work); doublereal zlange_(char *norm, integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *work); doublereal zlangt_(char *norm, integer *n, doublecomplex *dl, doublecomplex * d__, doublecomplex *du); doublereal zlanhb_(char *norm, char *uplo, integer *n, integer *k, doublecomplex *ab, integer *ldab, doublereal *work); doublereal zlanhe_(char *norm, char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *work); doublereal zlanhf_(char *norm, char *transr, char *uplo, integer *n, doublecomplex *a, doublereal *work); doublereal zlanhp_(char *norm, char *uplo, integer *n, doublecomplex *ap, doublereal *work); doublereal zlanhs_(char *norm, integer *n, doublecomplex *a, integer *lda, doublereal *work); doublereal zlanht_(char *norm, integer *n, doublereal *d__, doublecomplex *e); doublereal zlansb_(char *norm, char *uplo, integer *n, integer *k, doublecomplex *ab, integer *ldab, doublereal *work); doublereal zlansp_(char *norm, char *uplo, integer *n, doublecomplex *ap, doublereal *work); doublereal zlansy_(char *norm, char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *work); doublereal zlantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, doublecomplex *ab, integer *ldab, doublereal *work); doublereal zlantp_(char *norm, char *uplo, char *diag, integer *n, doublecomplex *ap, doublereal *work); doublereal zlantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *work); /* Subroutine */ int zlapll_(integer *n, doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, doublereal *ssmin); /* Subroutine */ int zlapmt_(logical *forwrd, integer *m, integer *n, doublecomplex *x, integer *ldx, integer *k); /* Subroutine */ int zlaqgb_(integer *m, integer *n, integer *kl, integer *ku, doublecomplex *ab, integer *ldab, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, char *equed); /* Subroutine */ int zlaqge_(integer *m, integer *n, doublecomplex *a, integer *lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, char *equed); /* Subroutine */ int zlaqhb_(char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int zlaqhe_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int zlaqhp_(char *uplo, integer *n, doublecomplex *ap, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int zlaqp2_(integer *m, integer *n, integer *offset, doublecomplex *a, integer *lda, integer *jpvt, doublecomplex *tau, doublereal *vn1, doublereal *vn2, doublecomplex *work); /* Subroutine */ int zlaqps_(integer *m, integer *n, integer *offset, integer *nb, integer *kb, doublecomplex *a, integer *lda, integer *jpvt, doublecomplex *tau, doublereal *vn1, doublereal *vn2, doublecomplex * auxv, doublecomplex *f, integer *ldf); /* Subroutine */ int zlaqr0_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, doublecomplex *w, integer *iloz, integer *ihiz, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zlaqr1_(integer *n, doublecomplex *h__, integer *ldh, doublecomplex *s1, doublecomplex *s2, doublecomplex *v); /* Subroutine */ int zlaqr2_(logical *wantt, logical *wantz, integer *n, integer *ktop, integer *kbot, integer *nw, doublecomplex *h__, integer *ldh, integer *iloz, integer *ihiz, doublecomplex *z__, integer *ldz, integer *ns, integer *nd, doublecomplex *sh, doublecomplex *v, integer *ldv, integer *nh, doublecomplex *t, integer *ldt, integer *nv, doublecomplex *wv, integer *ldwv, doublecomplex *work, integer *lwork); /* Subroutine */ int zlaqr3_(logical *wantt, logical *wantz, integer *n, integer *ktop, integer *kbot, integer *nw, doublecomplex *h__, integer *ldh, integer *iloz, integer *ihiz, doublecomplex *z__, integer *ldz, integer *ns, integer *nd, doublecomplex *sh, doublecomplex *v, integer *ldv, integer *nh, doublecomplex *t, integer *ldt, integer *nv, doublecomplex *wv, integer *ldwv, doublecomplex *work, integer *lwork); /* Subroutine */ int zlaqr4_(logical *wantt, logical *wantz, integer *n, integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, doublecomplex *w, integer *iloz, integer *ihiz, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zlaqr5_(logical *wantt, logical *wantz, integer *kacc22, integer *n, integer *ktop, integer *kbot, integer *nshfts, doublecomplex *s, doublecomplex *h__, integer *ldh, integer *iloz, integer *ihiz, doublecomplex *z__, integer *ldz, doublecomplex *v, integer *ldv, doublecomplex *u, integer *ldu, integer *nv, doublecomplex *wv, integer *ldwv, integer *nh, doublecomplex *wh, integer *ldwh); /* Subroutine */ int zlaqsb_(char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int zlaqsp_(char *uplo, integer *n, doublecomplex *ap, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int zlaqsy_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *s, doublereal *scond, doublereal *amax, char *equed); /* Subroutine */ int zlar1v_(integer *n, integer *b1, integer *bn, doublereal *lambda, doublereal *d__, doublereal *l, doublereal *ld, doublereal * lld, doublereal *pivmin, doublereal *gaptol, doublecomplex *z__, logical *wantnc, integer *negcnt, doublereal *ztz, doublereal *mingma, integer *r__, integer *isuppz, doublereal *nrminv, doublereal *resid, doublereal *rqcorr, doublereal *work); /* Subroutine */ int zlar2v_(integer *n, doublecomplex *x, doublecomplex *y, doublecomplex *z__, integer *incx, doublereal *c__, doublecomplex *s, integer *incc); /* Subroutine */ int zlarcm_(integer *m, integer *n, doublereal *a, integer * lda, doublecomplex *b, integer *ldb, doublecomplex *c__, integer *ldc, doublereal *rwork); /* Subroutine */ int zlarf_(char *side, integer *m, integer *n, doublecomplex *v, integer *incv, doublecomplex *tau, doublecomplex *c__, integer * ldc, doublecomplex *work); /* Subroutine */ int zlarfb_(char *side, char *trans, char *direct, char * storev, integer *m, integer *n, integer *k, doublecomplex *v, integer *ldv, doublecomplex *t, integer *ldt, doublecomplex *c__, integer * ldc, doublecomplex *work, integer *ldwork); /* Subroutine */ int zlarfg_(integer *n, doublecomplex *alpha, doublecomplex * x, integer *incx, doublecomplex *tau); /* Subroutine */ int zlarfp_(integer *n, doublecomplex *alpha, doublecomplex * x, integer *incx, doublecomplex *tau); /* Subroutine */ int zlarft_(char *direct, char *storev, integer *n, integer * k, doublecomplex *v, integer *ldv, doublecomplex *tau, doublecomplex * t, integer *ldt); /* Subroutine */ int zlarfx_(char *side, integer *m, integer *n, doublecomplex *v, doublecomplex *tau, doublecomplex *c__, integer * ldc, doublecomplex *work); /* Subroutine */ int zlargv_(integer *n, doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, doublereal *c__, integer *incc); /* Subroutine */ int zlarnv_(integer *idist, integer *iseed, integer *n, doublecomplex *x); /* Subroutine */ int zlarrv_(integer *n, doublereal *vl, doublereal *vu, doublereal *d__, doublereal *l, doublereal *pivmin, integer *isplit, integer *m, integer *dol, integer *dou, doublereal *minrgp, doublereal *rtol1, doublereal *rtol2, doublereal *w, doublereal *werr, doublereal *wgap, integer *iblock, integer *indexw, doublereal *gers, doublecomplex *z__, integer *ldz, integer *isuppz, doublereal *work, integer *iwork, integer *info); /* Subroutine */ int zlarscl2_(integer *m, integer *n, doublereal *d__, doublecomplex *x, integer *ldx); /* Subroutine */ int zlartg_(doublecomplex *f, doublecomplex *g, doublereal * cs, doublecomplex *sn, doublecomplex *r__); /* Subroutine */ int zlartv_(integer *n, doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, doublereal *c__, doublecomplex *s, integer *incc); /* Subroutine */ int zlarz_(char *side, integer *m, integer *n, integer *l, doublecomplex *v, integer *incv, doublecomplex *tau, doublecomplex * c__, integer *ldc, doublecomplex *work); /* Subroutine */ int zlarzb_(char *side, char *trans, char *direct, char * storev, integer *m, integer *n, integer *k, integer *l, doublecomplex *v, integer *ldv, doublecomplex *t, integer *ldt, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *ldwork); /* Subroutine */ int zlarzt_(char *direct, char *storev, integer *n, integer * k, doublecomplex *v, integer *ldv, doublecomplex *tau, doublecomplex * t, integer *ldt); /* Subroutine */ int zlascl_(char *type__, integer *kl, integer *ku, doublereal *cfrom, doublereal *cto, integer *m, integer *n, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int zlascl2_(integer *m, integer *n, doublereal *d__, doublecomplex *x, integer *ldx); /* Subroutine */ int zlaset_(char *uplo, integer *m, integer *n, doublecomplex *alpha, doublecomplex *beta, doublecomplex *a, integer * lda); /* Subroutine */ int zlasr_(char *side, char *pivot, char *direct, integer *m, integer *n, doublereal *c__, doublereal *s, doublecomplex *a, integer *lda); /* Subroutine */ int zlassq_(integer *n, doublecomplex *x, integer *incx, doublereal *scale, doublereal *sumsq); /* Subroutine */ int zlaswp_(integer *n, doublecomplex *a, integer *lda, integer *k1, integer *k2, integer *ipiv, integer *incx); /* Subroutine */ int zlasyf_(char *uplo, integer *n, integer *nb, integer *kb, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *w, integer *ldw, integer *info); /* Subroutine */ int zlat2c_(char *uplo, integer *n, doublecomplex *a, integer *lda, complex *sa, integer *ldsa, integer *info); /* Subroutine */ int zlatbs_(char *uplo, char *trans, char *diag, char * normin, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublecomplex *x, doublereal *scale, doublereal *cnorm, integer *info); /* Subroutine */ int zlatdf_(integer *ijob, integer *n, doublecomplex *z__, integer *ldz, doublecomplex *rhs, doublereal *rdsum, doublereal * rdscal, integer *ipiv, integer *jpiv); /* Subroutine */ int zlatps_(char *uplo, char *trans, char *diag, char * normin, integer *n, doublecomplex *ap, doublecomplex *x, doublereal * scale, doublereal *cnorm, integer *info); /* Subroutine */ int zlatrd_(char *uplo, integer *n, integer *nb, doublecomplex *a, integer *lda, doublereal *e, doublecomplex *tau, doublecomplex *w, integer *ldw); /* Subroutine */ int zlatrs_(char *uplo, char *trans, char *diag, char * normin, integer *n, doublecomplex *a, integer *lda, doublecomplex *x, doublereal *scale, doublereal *cnorm, integer *info); /* Subroutine */ int zlatrz_(integer *m, integer *n, integer *l, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work); /* Subroutine */ int zlatzm_(char *side, integer *m, integer *n, doublecomplex *v, integer *incv, doublecomplex *tau, doublecomplex * c1, doublecomplex *c2, integer *ldc, doublecomplex *work); /* Subroutine */ int zlauu2_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int zlauum_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int zpbcon_(char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublereal *anorm, doublereal * rcond, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zpbequ_(char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax, integer *info); /* Subroutine */ int zpbrfs_(char *uplo, integer *n, integer *kd, integer * nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer * ldafb, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal * rwork, integer *info); /* Subroutine */ int zpbstf_(char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, integer *info); /* Subroutine */ int zpbsv_(char *uplo, integer *n, integer *kd, integer * nrhs, doublecomplex *ab, integer *ldab, doublecomplex *b, integer * ldb, integer *info); /* Subroutine */ int zpbsvx_(char *fact, char *uplo, integer *n, integer *kd, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, char *equed, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal * ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zpbtf2_(char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, integer *info); /* Subroutine */ int zpbtrf_(char *uplo, integer *n, integer *kd, doublecomplex *ab, integer *ldab, integer *info); /* Subroutine */ int zpbtrs_(char *uplo, integer *n, integer *kd, integer * nrhs, doublecomplex *ab, integer *ldab, doublecomplex *b, integer * ldb, integer *info); /* Subroutine */ int zpftrf_(char *transr, char *uplo, integer *n, doublecomplex *a, integer *info); /* Subroutine */ int zpftri_(char *transr, char *uplo, integer *n, doublecomplex *a, integer *info); /* Subroutine */ int zpftrs_(char *transr, char *uplo, integer *n, integer * nrhs, doublecomplex *a, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zpocon_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *anorm, doublereal *rcond, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zpoequ_(integer *n, doublecomplex *a, integer *lda, doublereal *s, doublereal *scond, doublereal *amax, integer *info); /* Subroutine */ int zpoequb_(integer *n, doublecomplex *a, integer *lda, doublereal *s, doublereal *scond, doublereal *amax, integer *info); /* Subroutine */ int zporfs_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal * rwork, integer *info); /* Subroutine */ int zporfsx_(char *uplo, char *equed, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *berr, integer * n_err_bnds__, doublereal *err_bnds_norm__, doublereal * err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zposv_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zposvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, char *equed, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer * info); /* Subroutine */ int zposvxx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, char *equed, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zpotf2_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int zpotrf_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int zpotri_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int zpotrs_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zppcon_(char *uplo, integer *n, doublecomplex *ap, doublereal *anorm, doublereal *rcond, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zppequ_(char *uplo, integer *n, doublecomplex *ap, doublereal *s, doublereal *scond, doublereal *amax, integer *info); /* Subroutine */ int zpprfs_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, doublecomplex *afp, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zppsv_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zppsvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *ap, doublecomplex *afp, char *equed, doublereal * s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zpptrf_(char *uplo, integer *n, doublecomplex *ap, integer *info); /* Subroutine */ int zpptri_(char *uplo, integer *n, doublecomplex *ap, integer *info); /* Subroutine */ int zpptrs_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zpstf2_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *piv, integer *rank, doublereal *tol, doublereal *work, integer *info); /* Subroutine */ int zpstrf_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *piv, integer *rank, doublereal *tol, doublereal *work, integer *info); /* Subroutine */ int zptcon_(integer *n, doublereal *d__, doublecomplex *e, doublereal *anorm, doublereal *rcond, doublereal *rwork, integer * info); /* Subroutine */ int zpteqr_(char *compz, integer *n, doublereal *d__, doublereal *e, doublecomplex *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int zptrfs_(char *uplo, integer *n, integer *nrhs, doublereal *d__, doublecomplex *e, doublereal *df, doublecomplex *ef, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal * rwork, integer *info); /* Subroutine */ int zptsv_(integer *n, integer *nrhs, doublereal *d__, doublecomplex *e, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zptsvx_(char *fact, integer *n, integer *nrhs, doublereal *d__, doublecomplex *e, doublereal *df, doublecomplex *ef, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zpttrf_(integer *n, doublereal *d__, doublecomplex *e, integer *info); /* Subroutine */ int zpttrs_(char *uplo, integer *n, integer *nrhs, doublereal *d__, doublecomplex *e, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zptts2_(integer *iuplo, integer *n, integer *nrhs, doublereal *d__, doublecomplex *e, doublecomplex *b, integer *ldb); /* Subroutine */ int zrot_(integer *n, doublecomplex *cx, integer *incx, doublecomplex *cy, integer *incy, doublereal *c__, doublecomplex *s); /* Subroutine */ int zspcon_(char *uplo, integer *n, doublecomplex *ap, integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex * work, integer *info); /* Subroutine */ int zspmv_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *ap, doublecomplex *x, integer *incx, doublecomplex * beta, doublecomplex *y, integer *incy); /* Subroutine */ int zspr_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *x, integer *incx, doublecomplex *ap); /* Subroutine */ int zsprfs_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, doublecomplex *afp, integer *ipiv, doublecomplex * b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer * info); /* Subroutine */ int zspsv_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zspsvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *ap, doublecomplex *afp, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zsptrf_(char *uplo, integer *n, doublecomplex *ap, integer *ipiv, integer *info); /* Subroutine */ int zsptri_(char *uplo, integer *n, doublecomplex *ap, integer *ipiv, doublecomplex *work, integer *info); /* Subroutine */ int zsptrs_(char *uplo, integer *n, integer *nrhs, doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int zstedc_(char *compz, integer *n, doublereal *d__, doublereal *e, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork, integer *lrwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int zstegr_(char *jobz, char *range, integer *n, doublereal * d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__, integer *ldz, integer *isuppz, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int zstein_(integer *n, doublereal *d__, doublereal *e, integer *m, doublereal *w, integer *iblock, integer *isplit, doublecomplex *z__, integer *ldz, doublereal *work, integer *iwork, integer *ifail, integer *info); /* Subroutine */ int zstemr_(char *jobz, char *range, integer *n, doublereal * d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, integer *iu, integer *m, doublereal *w, doublecomplex *z__, integer * ldz, integer *nzc, integer *isuppz, logical *tryrac, doublereal *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int zsteqr_(char *compz, integer *n, doublereal *d__, doublereal *e, doublecomplex *z__, integer *ldz, doublereal *work, integer *info); /* Subroutine */ int zsycon_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *work, integer *info); /* Subroutine */ int zsyequb_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublereal *s, doublereal *scond, doublereal *amax, doublecomplex *work, integer *info); /* Subroutine */ int zsymv_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, doublecomplex *beta, doublecomplex *y, integer *incy); /* Subroutine */ int zsyr_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *x, integer *incx, doublecomplex *a, integer *lda); /* Subroutine */ int zsyrfs_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zsyrfsx_(char *uplo, char *equed, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal * err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int zsysv_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zsysvx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info); /* Subroutine */ int zsysvxx_(char *fact, char *uplo, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, char *equed, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer * nparams, doublereal *params, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int zsytf2_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *ipiv, integer *info); /* Subroutine */ int zsytrf_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zsytri_(char *uplo, integer *n, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *work, integer *info); /* Subroutine */ int zsytrs_(char *uplo, integer *n, integer *nrhs, doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int ztbcon_(char *norm, char *uplo, char *diag, integer *n, integer *kd, doublecomplex *ab, integer *ldab, doublereal *rcond, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int ztbrfs_(char *uplo, char *trans, char *diag, integer *n, integer *kd, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal * rwork, integer *info); /* Subroutine */ int ztbtrs_(char *uplo, char *trans, char *diag, integer *n, integer *kd, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int ztfsm_(char *transr, char *side, char *uplo, char *trans, char *diag, integer *m, integer *n, doublecomplex *alpha, doublecomplex *a, doublecomplex *b, integer *ldb); /* Subroutine */ int ztftri_(char *transr, char *uplo, char *diag, integer *n, doublecomplex *a, integer *info); /* Subroutine */ int ztfttp_(char *transr, char *uplo, integer *n, doublecomplex *arf, doublecomplex *ap, integer *info); /* Subroutine */ int ztfttr_(char *transr, char *uplo, integer *n, doublecomplex *arf, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int ztgevc_(char *side, char *howmny, logical *select, integer *n, doublecomplex *s, integer *lds, doublecomplex *p, integer *ldp, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer * ldvr, integer *mm, integer *m, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int ztgex2_(logical *wantq, logical *wantz, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *q, integer *ldq, doublecomplex *z__, integer *ldz, integer *j1, integer *info); /* Subroutine */ int ztgexc_(logical *wantq, logical *wantz, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *q, integer *ldq, doublecomplex *z__, integer *ldz, integer *ifst, integer *ilst, integer *info); /* Subroutine */ int ztgsen_(integer *ijob, logical *wantq, logical *wantz, logical *select, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex * beta, doublecomplex *q, integer *ldq, doublecomplex *z__, integer * ldz, integer *m, doublereal *pl, doublereal *pr, doublereal *dif, doublecomplex *work, integer *lwork, integer *iwork, integer *liwork, integer *info); /* Subroutine */ int ztgsja_(char *jobu, char *jobv, char *jobq, integer *m, integer *p, integer *n, integer *k, integer *l, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *tola, doublereal *tolb, doublereal *alpha, doublereal *beta, doublecomplex * u, integer *ldu, doublecomplex *v, integer *ldv, doublecomplex *q, integer *ldq, doublecomplex *work, integer *ncycle, integer *info); /* Subroutine */ int ztgsna_(char *job, char *howmny, logical *select, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer * ldvr, doublereal *s, doublereal *dif, integer *mm, integer *m, doublecomplex *work, integer *lwork, integer *iwork, integer *info); /* Subroutine */ int ztgsy2_(char *trans, integer *ijob, integer *m, integer * n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *c__, integer *ldc, doublecomplex *d__, integer *ldd, doublecomplex *e, integer *lde, doublecomplex *f, integer *ldf, doublereal *scale, doublereal *rdsum, doublereal *rdscal, integer * info); /* Subroutine */ int ztgsyl_(char *trans, integer *ijob, integer *m, integer * n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *c__, integer *ldc, doublecomplex *d__, integer *ldd, doublecomplex *e, integer *lde, doublecomplex *f, integer *ldf, doublereal *scale, doublereal *dif, doublecomplex *work, integer * lwork, integer *iwork, integer *info); /* Subroutine */ int ztpcon_(char *norm, char *uplo, char *diag, integer *n, doublecomplex *ap, doublereal *rcond, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int ztprfs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, doublecomplex *ap, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int ztptri_(char *uplo, char *diag, integer *n, doublecomplex *ap, integer *info); /* Subroutine */ int ztptrs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, doublecomplex *ap, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int ztpttf_(char *transr, char *uplo, integer *n, doublecomplex *ap, doublecomplex *arf, integer *info); /* Subroutine */ int ztpttr_(char *uplo, integer *n, doublecomplex *ap, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int ztrcon_(char *norm, char *uplo, char *diag, integer *n, doublecomplex *a, integer *lda, doublereal *rcond, doublecomplex * work, doublereal *rwork, integer *info); /* Subroutine */ int ztrevc_(char *side, char *howmny, logical *select, integer *n, doublecomplex *t, integer *ldt, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, integer *mm, integer *m, doublecomplex *work, doublereal *rwork, integer *info); /* Subroutine */ int ztrexc_(char *compq, integer *n, doublecomplex *t, integer *ldt, doublecomplex *q, integer *ldq, integer *ifst, integer * ilst, integer *info); /* Subroutine */ int ztrrfs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, integer * info); /* Subroutine */ int ztrsen_(char *job, char *compq, logical *select, integer *n, doublecomplex *t, integer *ldt, doublecomplex *q, integer *ldq, doublecomplex *w, integer *m, doublereal *s, doublereal *sep, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int ztrsna_(char *job, char *howmny, logical *select, integer *n, doublecomplex *t, integer *ldt, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, doublereal *s, doublereal *sep, integer *mm, integer *m, doublecomplex *work, integer *ldwork, doublereal *rwork, integer *info); /* Subroutine */ int ztrsyl_(char *trana, char *tranb, integer *isgn, integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *c__, integer *ldc, doublereal *scale, integer *info); /* Subroutine */ int ztrti2_(char *uplo, char *diag, integer *n, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int ztrtri_(char *uplo, char *diag, integer *n, doublecomplex *a, integer *lda, integer *info); /* Subroutine */ int ztrtrs_(char *uplo, char *trans, char *diag, integer *n, integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *info); /* Subroutine */ int ztrttf_(char *transr, char *uplo, integer *n, doublecomplex *a, integer *lda, doublecomplex *arf, integer *info); /* Subroutine */ int ztrttp_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublecomplex *ap, integer *info); /* Subroutine */ int ztzrqf_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, integer *info); /* Subroutine */ int ztzrzf_(integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zung2l_(integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *info); /* Subroutine */ int zung2r_(integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *info); /* Subroutine */ int zungbr_(char *vect, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *lwork, integer *info); /* Subroutine */ int zunghr_(integer *n, integer *ilo, integer *ihi, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *lwork, integer *info); /* Subroutine */ int zungl2_(integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *info); /* Subroutine */ int zunglq_(integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *lwork, integer *info); /* Subroutine */ int zungql_(integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *lwork, integer *info); /* Subroutine */ int zungqr_(integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *lwork, integer *info); /* Subroutine */ int zungr2_(integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *info); /* Subroutine */ int zungrq_(integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex * work, integer *lwork, integer *info); /* Subroutine */ int zungtr_(char *uplo, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zunm2l_(char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info); /* Subroutine */ int zunm2r_(char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info); /* Subroutine */ int zunmbr_(char *vect, char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer * lwork, integer *info); /* Subroutine */ int zunmhr_(char *side, char *trans, integer *m, integer *n, integer *ilo, integer *ihi, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex * work, integer *lwork, integer *info); /* Subroutine */ int zunml2_(char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info); /* Subroutine */ int zunmlq_(char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zunmql_(char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zunmqr_(char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zunmr2_(char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info); /* Subroutine */ int zunmr3_(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer * info); /* Subroutine */ int zunmrq_(char *side, char *trans, integer *m, integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zunmrz_(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer * lwork, integer *info); /* Subroutine */ int zunmtr_(char *side, char *uplo, char *trans, integer *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, integer *info); /* Subroutine */ int zupgtr_(char *uplo, integer *n, doublecomplex *ap, doublecomplex *tau, doublecomplex *q, integer *ldq, doublecomplex * work, integer *info); /* Subroutine */ int zupmtr_(char *side, char *uplo, char *trans, integer *m, integer *n, doublecomplex *ap, doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info); /* Subroutine */ int dlamc1_(integer *beta, integer *t, logical *rnd, logical *ieee1); doublereal dsecnd_(); /* Subroutine */ int ilaver_(integer *vers_major__, integer *vers_minor__, integer *vers_patch__); logical lsame_(char *ca, char *cb); doublereal second_(); doublereal slamch_(char *cmach); /* Subroutine */ int slamc1_(integer *beta, integer *t, logical *rnd, logical *ieee1); /* Subroutine */ int slamc2_(integer *beta, integer *t, logical *rnd, real * eps, integer *emin, real *rmin, integer *emax, real *rmax); doublereal slamc3_(real *a, real *b); /* Subroutine */ int slamc4_(integer *emin, real *start, integer *base); /* Subroutine */ int slamc5_(integer *beta, integer *p, integer *emin, logical *ieee, integer *emax, real *rmax); doublereal dlamch_(char *cmach); /* Subroutine */ int dlamc1_(integer *beta, integer *t, logical *rnd, logical *ieee1); /* Subroutine */ int dlamc2_(integer *beta, integer *t, logical *rnd, doublereal *eps, integer *emin, doublereal *rmin, integer *emax, doublereal *rmax); doublereal dlamc3_(doublereal *a, doublereal *b); /* Subroutine */ int dlamc4_(integer *emin, doublereal *start, integer *base); /* Subroutine */ int dlamc5_(integer *beta, integer *p, integer *emin, logical *ieee, integer *emax, doublereal *rmax); integer ilaenv_(integer *ispec, char *name__, char *opts, integer *n1, integer *n2, integer *n3, integer *n4); #ifdef __cplusplus } #endif #endif /* __CLAPACK_H */ vmmlib-1.0/include/vmmlib/t3_hopm.hpp0000644000175000017500000003146411674116156017207 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * * the higher-order power method (HOPM) is also known as CP-ALS (ALS: alternating least squares) * CP stands for Candecomp/Parafac (1970) * references: * - Carroll & Chang, 1970: Analysis of Individual Differences in Multidimensional Scaling via an N-way generalization of ``Eckart--Young'' decompositions, Psychometrika. * - Harshman, 1970: Foundations of the PARAFAC procedure: Models and conditions for an 'explanatory' multi-modal factor analysis, UCLA Working Papers in Phonetics. * - De Lathauwer, De Moor, Vandewalle, 2000: A multilinear singular value decomposition, SIAM J. Matrix Anal. Appl. * - Kolda & Bader, 2009: Tensor Decompositions and Applications, SIAM Review. * - Bader & Kolda, 2006: Algorithm 862: Matlab tensor classes for fast algorithm prototyping. ACM Transactions on Mathematical Software. * */ #ifndef __VMML__T3_HOPM__HPP__ #define __VMML__T3_HOPM__HPP__ #include #include #include #include namespace vmml { template< size_t R, size_t I1, size_t I2, size_t I3, typename T = float > class t3_hopm { public: typedef tensor3< I1, I2, I3, T > t3_type; typedef vector< R, T > lambda_type; typedef matrix< I1, R, T > u1_type; typedef matrix< I2, R, T > u2_type; typedef matrix< I3, R, T > u3_type; typedef matrix< R, I1, T > u1_inv_type; typedef matrix< R, I2, T > u2_inv_type; typedef matrix< R, I3, T > u3_inv_type; typedef matrix< I1, I2*I3, T > u1_unfolded_type; typedef matrix< I2, I1*I3, T > u2_unfolded_type; typedef matrix< I3, I1*I2, T > u3_unfolded_type; typedef matrix< R, R , T > m_r2_type; typedef typename lambda_type::iterator lvalue_iterator; typedef typename lambda_type::const_iterator lvalue_const_iterator; typedef std::pair< T, size_t > lambda_pair_type; //higher-order power method (lathauwer et al., 2000b) template< typename T_init > static void als( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_, lambda_type& lambdas_, T_init init, const size_t max_iterations_ = 100 ); static void reconstruct( t3_type& data_, const u1_type& u1_, const u2_type& u2_, const u3_type& u3_, const lambda_type& lambdas_ ); //ktensor = kruskal tensor, i.e., lambda, U1, U2, U3 static double norm_ktensor( const u1_type& u1_, const u2_type& u2_, const u3_type& u3_, const lambda_type& lambdas_ ); // init functors struct init_hosvd { inline void operator()( const t3_type& data_, u2_type& u2_, u3_type& u3_ ) { t3_hosvd< R, R, R, I1, I2, I3, T >::apply_mode2( data_, u2_ ); t3_hosvd< R, R, R, I1, I2, I3, T >::apply_mode3( data_, u3_ ); } }; struct init_random { inline void operator()( const t3_type& data_, u2_type& u2_, u3_type& u3_ ) { srand( time(NULL) ); u2_.set_random(); u3_.set_random(); } }; //FIXME: check test on linux #if 0 struct init_dct { inline void operator()( const t3_type& data_, u2_type& u2_, u3_type& u3_ ) { u2_.set_dct(); u3_.set_dct(); } }; #endif protected: static void optimize_mode1( const t3_type& data_, u1_type& u1, const u2_type& u2_, const u3_type& u3_, lambda_type& lambdas_ ); static void optimize_mode2( const t3_type& data_, const u1_type& u1_, u2_type& u2_, const u3_type& u3_, lambda_type& lambdas_ ); static void optimize_mode3( const t3_type& data_, const u1_type& u1_, const u2_type& u2_, u3_type& u3_, lambda_type& lambdas_ ); template< size_t J, size_t K, size_t L > static void optimize( const matrix< J, K*L, T >& unfolding_, matrix< J, R, T >& uj_, const matrix< K, R, T >& uk_, const matrix< L, R, T >& ul_, vector< R, T>& lambdas_ ); static void sort_dec( u1_type& u1_, u2_type& u2_, u3_type& u3_, lambda_type& lambdas_ ); // comparison functor struct lambda_compare { inline bool operator()( const lambda_pair_type& a, const lambda_pair_type& b ) { return fabs( a.first ) > fabs( b.first ); } }; }; #define VMML_TEMPLATE_STRING template< size_t R, size_t I1, size_t I2, size_t I3, typename T > #define VMML_TEMPLATE_CLASSNAME t3_hopm< R, I1, I2, I3, T > VMML_TEMPLATE_STRING template< typename T_init> void VMML_TEMPLATE_CLASSNAME::als( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_, lambda_type& lambdas_, T_init init, const size_t max_iterations_ ) { t3_type* approximated_data = new t3_type; t3_type* residual_data = new t3_type; residual_data->zero(); double max_f_norm = data_.frobenius_norm(); double normresidual = 0; double norm1 = 0; double norm2 = 0; double norm3 = 0; double fit = 0; if (max_f_norm == 0 ) fit = 1; double fitchange = 1; double fitold = fit; double fitchange_tolerance = 1.0e-4; //intialize u1-u3 //inital guess not needed for u1 since it will be computed in the first optimization step init( data_, u2_, u3_ ); assert( u2_.is_valid() && u3_.is_valid() ); assert( lambdas_.is_valid() ); #if CP_LOG std::cout << "CP ALS: HOPM (for tensor3) " << std::endl; #endif size_t i = 0; while( (fitchange >= fitchange_tolerance) && ( i < max_iterations_ ) ) //do until converges { fitold = fit; optimize_mode1( data_, u1_, u2_, u3_, lambdas_ ); optimize_mode2( data_, u1_, u2_, u3_, lambdas_ ); optimize_mode3( data_, u1_, u2_, u3_, lambdas_ ); #if 0 //Reconstruct tensor and measure norm of approximation //slower version since cp reconstruction is slow reconstruct( *approximated_data, u1_, u2_, u3_, lambdas_ ); approx_norm = approximated_data->frobenius_norm(); *residual_data = data_ - *approximated_data; normresidual = residual_data->frobenius_norm(); #else //normresidual = sqrt( normX^2 + norm(P)^2 - 2 * innerprod(X,P) ); norm1 = data_.frobenius_norm(); norm1 *= norm1; norm2 = norm_ktensor( u1_, u2_, u3_, lambdas_); norm2 *= norm2; norm3 = 2* data_.tensor_inner_product( lambdas_, u1_, u2_, u3_ ); normresidual = sqrt(norm1 + norm2 - norm3); #endif fit = 1 - ( normresidual / max_f_norm ); fitchange = fabs(fitold - fit); #if CP_LOG std::cout << "iteration '" << i << "', fit: " << fit << ", fitdelta: " << fitchange << ", normresidual: " << normresidual << std::endl; #endif ++i; } // end ALS //sort lambdas by decreasing magnitude sort_dec( u1_, u2_, u3_, lambdas_ ); delete residual_data; delete approximated_data; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode1( const t3_type& data_, u1_type& u1_, const u2_type& u2_, const u3_type& u3_, lambda_type& lambdas_ ) { u1_unfolded_type* unfolding = new u1_unfolded_type; // -> u1 //data_.horizontal_unfolding_bwd( *unfolding ); //lathauwer data_.frontal_unfolding_fwd( *unfolding ); assert( u2_.is_valid() && u3_.is_valid() ); optimize( *unfolding, u1_, u2_, u3_, lambdas_ ); delete unfolding; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode2( const t3_type& data_, const u1_type& u1_, u2_type& u2_, const u3_type& u3_, lambda_type& lambdas_ ) { u2_unfolded_type* unfolding = new u2_unfolded_type; // -> u2 data_.frontal_unfolding_bwd( *unfolding ); //lathauwer //data_.horizontal_unfolding_fwd( *unfolding ); assert( u1_.is_valid() && u3_.is_valid() ); optimize( *unfolding, u2_, u1_, u3_, lambdas_ ); delete unfolding; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode3( const t3_type& data_, const u1_type& u1_, const u2_type& u2_, u3_type& u3_, lambda_type& lambdas_ ) { u3_unfolded_type* unfolding = new u3_unfolded_type; //-> u3 //data_.horizontal_unfolding_bwd( *unfolding );//lathauwer data_.lateral_unfolding_fwd( *unfolding ); assert( u1_.is_valid() && u2_.is_valid() ); optimize( *unfolding, u3_, u1_, u2_, lambdas_ ); delete unfolding; } VMML_TEMPLATE_STRING template< size_t J, size_t K, size_t L > void VMML_TEMPLATE_CLASSNAME::optimize( const matrix< J, K*L, T >& unfolding_, matrix< J, R, T >& uj_, const matrix< K, R, T >& uk_, const matrix< L, R, T >& ul_, vector< R, T>& lambdas_ ) { typedef matrix< K*L, R, T > krp_matrix_type; krp_matrix_type* krp_prod = new krp_matrix_type; assert( uk_.is_valid() && ul_.is_valid() ); ul_.khatri_rao_product( uk_, *krp_prod ); matrix< J, R, T >* u_new = new matrix< J, R, T >; blas_dgemm< J, K*L, R, T> blas_dgemm1; blas_dgemm1.compute( unfolding_, *krp_prod, *u_new ); //square matrix of U_l and U_k m_r2_type* uk_r = new m_r2_type; m_r2_type* ul_r = new m_r2_type; blas_dgemm< R, K, R, T> blas_dgemm2; blas_dgemm2.compute_t( uk_, *uk_r ); assert( uk_r->is_valid() ); blas_dgemm< R, L, R, T> blas_dgemm3; blas_dgemm3.compute_t( ul_, *ul_r ); assert( ul_r->is_valid() ); uk_r->multiply_piecewise( *ul_r ); assert( uk_r->is_valid() ); m_r2_type* pinv_t = new m_r2_type; compute_pseudoinverse< m_r2_type > compute_pinv; compute_pinv( *uk_r, *pinv_t ); blas_dgemm< J, R, R, T> blas_dgemm4; blas_dgemm4.compute_bt( *u_new, *pinv_t, uj_ ); assert( uj_.is_valid() ); *u_new = uj_; u_new->multiply_piecewise( *u_new ); //2 norm u_new->columnwise_sum( lambdas_ ); assert( lambdas_.is_valid() ); lambdas_.sqrt_elementwise(); lambda_type* tmp = new lambda_type; *tmp = lambdas_; tmp->reciprocal_safe(); assert( tmp->is_valid() ); m_r2_type* diag_lambdas = new m_r2_type; diag_lambdas->diag( *tmp ); matrix< J, R, T >* tmp_uj = new matrix< J, R, T >( uj_ ); blas_dgemm4.compute( *tmp_uj, *diag_lambdas, uj_ ); assert( uj_.is_valid() ); delete krp_prod; delete uk_r; delete ul_r; delete pinv_t; delete u_new; delete diag_lambdas; delete tmp; delete tmp_uj; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_, const u1_type& u1_, const u2_type& u2_, const u3_type& u3_, const lambda_type& lambdas_ ) { u1_inv_type* u1_t = new u1_inv_type; u2_inv_type* u2_t = new u2_inv_type; u3_inv_type* u3_t = new u3_inv_type; typedef matrix< R, I2 * I3, T > m_temp_type; m_temp_type* temp = new m_temp_type; u1_.transpose_to( *u1_t ); u2_.transpose_to( *u2_t ); u3_.transpose_to( *u3_t ); data_.reconstruct_CP( lambdas_, *u1_t, *u2_t, *u3_t, *temp ); delete temp; delete u1_t; delete u2_t; delete u3_t; } VMML_TEMPLATE_STRING double VMML_TEMPLATE_CLASSNAME::norm_ktensor( const u1_type& u1_, const u2_type& u2_, const u3_type& u3_, const lambda_type& lambdas_ ) { m_r2_type* coeff2_matrix = new m_r2_type; m_r2_type* cov_u1 = new m_r2_type; m_r2_type* cov_u2 = new m_r2_type; m_r2_type* cov_u3 = new m_r2_type; blas_dgemm< R, 1, R, T >* blas_l2 = new blas_dgemm< R, 1, R, T>; blas_l2->compute_vv_outer( lambdas_, lambdas_, *coeff2_matrix ); delete blas_l2; blas_dgemm< R, I1, R, T >* blas_u1cov = new blas_dgemm< R, I1, R, T>; blas_u1cov->compute_t( u1_, *cov_u1 ); delete blas_u1cov; blas_dgemm< R, I2, R, T >* blas_u2cov = new blas_dgemm< R, I2, R, T>; blas_u2cov->compute_t( u2_, *cov_u2 ); delete blas_u2cov; blas_dgemm< R, I3, R, T >* blas_u3cov = new blas_dgemm< R, I3, R, T>; blas_u3cov->compute_t( u3_, *cov_u3 ); delete blas_u3cov; coeff2_matrix->multiply_piecewise( *cov_u1 ); coeff2_matrix->multiply_piecewise( *cov_u2 ); coeff2_matrix->multiply_piecewise( *cov_u3 ); double nrm = coeff2_matrix->sum_elements(); delete coeff2_matrix; delete cov_u1; delete cov_u2; delete cov_u3; return sqrt( nrm); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::sort_dec( u1_type& u1_, u2_type& u2_, u3_type& u3_, lambda_type& lambdas_ ) { //keep copy of original matrices u1_type *orig_u1 = new u1_type( u1_ ); u2_type *orig_u2 = new u2_type( u2_ ); u3_type *orig_u3 = new u3_type( u3_ ); lambda_type sorted_lvalues; //(1) store permutations of the lambdas (According to larges magnitude std::vector< lambda_pair_type > lambda_permut; lvalue_const_iterator it = lambdas_.begin(), it_end = lambdas_.end(); size_t counter = 0; for( ; it != it_end; ++it, ++counter ) { lambda_permut.push_back( lambda_pair_type ( *it, counter ) ); } std::sort( lambda_permut.begin(), lambda_permut.end(), lambda_compare() ); //(2) sort the matrix vectors according to lambda permutations and set sorted lambdas typename std::vector< lambda_pair_type >::const_iterator it2 = lambda_permut.begin(), it2_end = lambda_permut.end(); lvalue_iterator lvalues_it = lambdas_.begin(); for( counter = 0; it2 != it2_end; ++it2, ++counter, ++lvalues_it ) { *lvalues_it = it2->first; u1_.set_column( counter, orig_u1->get_column( it2->second )); u2_.set_column( counter, orig_u2->get_column( it2->second )); u3_.set_column( counter, orig_u3->get_column( it2->second )); } delete orig_u1; delete orig_u2; delete orig_u3; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME }//end vmml namespace #endif vmmlib-1.0/include/vmmlib/aabb.hpp0000644000175000017500000001310511674116156016513 0ustar shevekshevek#ifndef __VMML__AXIS_ALIGNED_BOUNDING_BOX__HPP__ #define __VMML__AXIS_ALIGNED_BOUNDING_BOX__HPP__ #include namespace vmml { template< typename T > class AxisAlignedBoundingBox { public: AxisAlignedBoundingBox(); AxisAlignedBoundingBox( const vector< 3, T >& pMin, const vector< 3, T >& pMax ); AxisAlignedBoundingBox( const vector< 4, T >& sphere ); AxisAlignedBoundingBox( T cx, T cy, T cz, T size ); inline bool isIn( const vector< 3, T >& pos ); inline bool isIn2d( const vector< 3, T >& pos ); // only x and y components are checked inline bool isIn( const vector< 4, T >& sphere ); inline void set( const vector< 3, T >& pMin, const vector< 3, T >& pMax ); inline void set( T cx, T cy, T cz, T size ); inline void setMin( const vector< 3, T >& pMin ); inline void setMax( const vector< 3, T >& pMax ); inline const vector< 3, T >& getMin() const; inline const vector< 3, T >& getMax() const; inline void merge( const AxisAlignedBoundingBox< T >& aabb ); inline void setEmpty( bool empty = true ); inline bool isEmpty() const; inline void setDirty( bool dirty = true ); inline bool isDirty() const; vector< 3, T > getCenter() const; protected: vector< 3, T > _min; vector< 3, T > _max; bool _dirty; bool _empty; }; template< typename T > AxisAlignedBoundingBox< T >::AxisAlignedBoundingBox() : _dirty( false ) , _empty( true ) {} template< typename T > AxisAlignedBoundingBox< T >::AxisAlignedBoundingBox( const vector< 3, T >& pMin, const vector< 3, T >& pMax ) : _min( pMin ) , _max( pMax ) , _dirty( false ) , _empty( false ) {} template< typename T > AxisAlignedBoundingBox< T >::AxisAlignedBoundingBox( const vector< 4, T >& sphere ) : _dirty( false ) , _empty( false ) { _max = _min = sphere.getCenter(); _max += sphere.getRadius(); _min -= sphere.getRadius(); } template< typename T > AxisAlignedBoundingBox< T >::AxisAlignedBoundingBox( T cx, T cy, T cz, T size ) : _dirty( false ) , _empty( false ) { _max = _min = Vector3f( cx, cy, cz ); _max += size; _min -= size; } template< typename T > inline bool AxisAlignedBoundingBox< T >::isIn( const vector< 4, T >& sphere ) { if ( _empty ) return false; vector< 3, T > sv ( sphere.getCenter() ); sv += sphere.getRadius(); if ( sv.x() > _max.x() || sv.y() > _max.y() || sv.z() > _max.z() ) return false; sv -= sphere.getRadius() * 2.0f; if ( sv.x() < _min.x() || sv.y() < _min.y() || sv.z() < _min.z() ) return false; return true; } template< typename T > inline bool AxisAlignedBoundingBox< T >::isIn( const vector< 3, T >& pos ) { if ( _empty ) return false; if ( pos.x() > _max.x() || pos.y() > _max.y() || pos.z() > _max.z() || pos.x() < _min.x() || pos.y() < _min.y() || pos.z() < _min.z() ) { return false; } return true; } template< typename T > inline bool AxisAlignedBoundingBox< T >::isIn2d( const vector< 3, T >& pos ) { if ( _empty ) return false; if ( pos.x() > _max.x() || pos.y() > _max.y() || pos.x() < _min.x() || pos.y() < _min.y() ) { return false; } return true; } template< typename T > inline void AxisAlignedBoundingBox< T >::set( const vector< 3, T >& pMin, const vector< 3, T >& pMax ) { _min = pMin; _max = pMax; _empty = false; } template< typename T > inline void AxisAlignedBoundingBox< T >::set( T cx, T cy, T cz, T size ) { vector< 3, T > center( cx, cy, cz ); _min = center - size; _max = center + size; _empty = false; } template< typename T > inline void AxisAlignedBoundingBox< T >::setMin( const vector< 3, T >& pMin ) { _min = pMin; } template< typename T > inline void AxisAlignedBoundingBox< T >::setMax( const vector< 3, T >& pMax ) { _max = pMax; } template< typename T > inline const vector< 3, T >& AxisAlignedBoundingBox< T >::getMin() const { return _min; } template< typename T > inline const vector< 3, T >& AxisAlignedBoundingBox< T >::getMax() const { return _max; } template< typename T > vector< 3, T > AxisAlignedBoundingBox< T >::getCenter() const { return _min + ( ( _max - _min ) * 0.5f ); } template< typename T > void AxisAlignedBoundingBox< T >::merge( const AxisAlignedBoundingBox< T >& aabb ) { if ( aabb._empty ) return; // nothing to do if ( _empty ) { // copy non-empty aabb _min = aabb._min; _max = aabb._max; _empty = _dirty = false; return; } // else merge the two aabbs const vector< 3, T >& min = aabb.getMin(); const vector< 3, T >& max = aabb.getMax(); if ( min.x() < _min.x() ) _min.x() = min.x(); if ( min.y() < _min.y() ) _min.y() = min.y(); if ( min.z() < _min.z() ) _min.z() = min.z(); if ( max.x() > _max.x() ) _max.x() = max.x(); if ( max.y() > _max.y() ) _max.y() = max.y(); if ( max.z() > _max.z() ) _max.z() = max.z(); } template< typename T > inline void AxisAlignedBoundingBox< T >::setEmpty( bool empty ) { _empty = empty; } template< typename T > inline bool AxisAlignedBoundingBox< T >::isEmpty() const { return _empty; } template< typename T > inline void AxisAlignedBoundingBox< T >::setDirty( bool dirty ) { _dirty = dirty; } template< typename T > inline bool AxisAlignedBoundingBox< T >::isDirty() const { return _dirty; } typedef AxisAlignedBoundingBox< float > Aabbf; }; //namespace vmml #endif vmmlib-1.0/include/vmmlib/linear_least_squares.hpp0000644000175000017500000000531311674116156022035 0ustar shevekshevek#ifndef __VMML__LINEAR_LEAST_SQUARES__HPP__ #define __VMML__LINEAR_LEAST_SQUARES__HPP__ #include #include "matrix_mxn.hpp" namespace vmml { // beta_hat = ( Xt * X )^-1 * Xt * y; // beta_hat -> best-fit 'solutions' to a,b = [ a,b ]transposed. // TODO FIXME what about the constant??? struct linear_least_squares { template< size_t number_of_data_points, size_t number_of_unknowns, typename float_t > vmml::matrix_mxn< number_of_unknowns, 1, float_t > solve( std::vector< Vector3< float_t > >& data_points, float_t tolerance = 1e-9 ) { assert( data_points.size() >= number_of_data_points ); matrix_mxn< number_of_data_points, number_of_unknowns, float_t > X; matrix_mxn< number_of_data_points, 1, float_t > y; for( size_t nb_index = 0; nb_index < number_of_data_points; ++nb_index ) { float_t x = data_points[ nb_index ].x; for( size_t index = 0; index < number_of_unknowns; ++index ) { X[ nb_index ][ index ] = x; x *= x; } y[ nb_index ][ 0 ] = data_points[ nb_index ].y; } std::cout << X << std::endl; vmml::matrix_mxn< number_of_unknowns, number_of_data_points > Xt; X.transposeTo( Xt ); std::cout << Xt << std::endl; vmml::matrix_mxm< number_of_unknowns > XtX; XtX.mul( Xt, X ); vmml::matrix_mxm< number_of_unknowns > XtX_inverse; XtX.computeInverse( XtX_inverse, tolerance ); vmml::matrix_mxn< number_of_unknowns, number_of_data_points > XtX_inv_mul_Xt; XtX_inv_mul_Xt.mul( XtX_inverse, Xt ); vmml::matrix_mxn< number_of_unknowns, 1 > beta_hat; beta_hat.mul( XtX_inv_mul_Xt, y ); std::cout << beta_hat << std::endl; return beta_hat; } template< size_t number_of_data_points, size_t number_of_unknowns, typename float_t > vmml::matrix_mxn< number_of_unknowns, 1, float_t > solve_using_qr_decomposition( std::vector< Vector3< float_t > >& data_points, float_t tolerance = 1e-9 ) { assert( data_points.size() >= number_of_data_points ); matrix_mxn< number_of_data_points, number_of_unknowns, float_t > X; matrix_mxn< number_of_data_points, 1, float_t > y; // r = y - X * Beta // X = Q*R // Qt * r = Qt * y - ( Qt * Q ) R * Beta = // // | ( Qt * y )_n - R_n * Beta | | U | // | ( Qt * y )_m-n | = | L | // // S = rt * Q * Qt * r = rt * r // // S = Ut * U + Lt * L // // => R_n * BetaHat = ( Qt * y )_n // vmml::matrix_mxn< number_of_unknowns, 1 > beta_hat; return beta_hat; } template< size_t number_of_data_points, size_t number_of_unknowns, typename float_t > vmml::matrix_mxn< number_of_unknowns, 1, float_t > solve_using_svd( std::vector< Vector3< float_t > >& data_points, float_t tolerance = 1e-9 ) { } }; } // namespace vmml #endif vmmlib-1.0/include/vmmlib/t3_hooi.hpp0000644000175000017500000002453411674116156017202 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * * The higher-order orthogonal iteration (HOOI) is also known as Tucker-ALS (Tuck-ALS) * The t3_hooi implements a HOOI for a third-order tensor * references: * - Tucker, 1966: Some mathematical notes on three-mode factor analysis, Psychometrika. * - De Lathauwer, De Moor, Vandewalle, 2000a: A multilinear singular value decomposition, SIAM J. Matrix Anal. Appl. * - De Lathauwer, De Moor, Vandewalle, 2000b: On the Best rank-1 and Rank-(R_1, R_2, ..., R_N) Approximation and Applications of Higher-Order Tensors, SIAM J. Matrix Anal. Appl. * - Kolda & Bader, 2009: Tensor Decompositions and Applications, SIAM Review. * - Bader & Kolda, 2006: Algorithm 862: Matlab tensor classes for fast algorithm prototyping. ACM Transactions on Mathematical Software. * */ #ifndef __VMML__T3_HOOI__HPP__ #define __VMML__T3_HOOI__HPP__ #include namespace vmml { template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T = float > class t3_hooi { public: typedef tensor3< I1, I2, I3, T > t3_type; typedef tensor3< R1, R2, R3, T > t3_core_type; typedef matrix< I1, R1, T > u1_type; typedef matrix< I2, R2, T > u2_type; typedef matrix< I3, R3, T > u3_type; typedef matrix< R1, I1, T > u1_inv_type; typedef matrix< R2, I2, T > u2_inv_type; typedef matrix< R3, I3, T > u3_inv_type; /* higher-order orthogonal iteration (HOOI) is a truncated HOSVD decompositions, i.e., the HOSVD components are of lower-ranks. An optimal rank-reduction is performed with an alternating least-squares (ALS) algorithm, which minimizes the error between the approximated and orignal tensor based on the Frobenius norm see: De Lathauwer et al, 2000b; On the best rank-1 and rank-(RRR) approximation of higher-order tensors. the HOOI can be computed based on (a) n-mode PCA, i.e., an eigenvalue decomposition on the covariance matrix of every mode's matriciziation, and (b) by performing a 2D SVD on the matricization of every mode. Matrix matricization means that a tensor I1xI2xI3 is unfolded/sliced into one matrix with the dimensions I1xI2I3, which corresponds to a matrizitation alonge mode I1. */ template< typename T_init> static void als( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_, t3_core_type& core_, T_init init ); /* derive core implemented accodring to core = data x_1 U1_pinv x_2 U2_pinv x_3 U3_pinv, where x_1 ... x_3 are n-mode products and U1_pinv ... U3_pinv are inverted basis matrices the inversion is done with a matrix pseudoinverse computation */ static void derive_core( const t3_type& data_, const u1_type& u1_, const u2_type& u2_, const u3_type& u3_, t3_core_type& core_ ); //faster: but only if basis matrices are orthogonal static void derive_core_orthogonal_bases( const t3_type& data_, const u1_type& u1_, const u2_type& u2_, const u3_type& u3_, t3_core_type& core_ ); // init functors struct init_hosvd { inline void operator()( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_ ) { t3_hosvd< R1, R2, R3, I1, I2, I3, T >::apply_mode1( data_, u1_ ); t3_hosvd< R1, R2, R3, I1, I2, I3, T >::apply_mode2( data_, u2_ ); t3_hosvd< R1, R2, R3, I1, I2, I3, T >::apply_mode3( data_, u3_ ); } }; struct init_random { inline void operator()( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_ ) { srand( time(NULL) ); u1_.set_random(); u2_.set_random(); u3_.set_random(); u1_ /= u1_.frobenius_norm(); u2_ /= u2_.frobenius_norm(); u3_ /= u3_.frobenius_norm(); } }; protected: static void optimize_mode1( const t3_type& data_, const u2_type& u2_, const u3_type& u3_, tensor3< I1, R2, R3, T >& projection_ ); static void optimize_mode2( const t3_type& data_, const u1_type& u1_, const u3_type& u3_, tensor3< R1, I2, R3, T >& projection_ ); static void optimize_mode3( const t3_type& data_, const u1_type& u1_, const u2_type& u2_, tensor3< R1, R2, I3, T >& projection_ ); };//end class t3_hooi #define VMML_TEMPLATE_STRING template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T > #define VMML_TEMPLATE_CLASSNAME t3_hooi< R1, R2, R3, I1, I2, I3, T > VMML_TEMPLATE_STRING template< typename T_init> void VMML_TEMPLATE_CLASSNAME::als( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_, t3_core_type& core_, T_init init ) { //intialize basis matrices init( data_, u1_, u2_, u3_ ); //derve core from initialized matrices derive_core_orthogonal_bases( data_, u1_, u2_, u3_, core_ ); //compute best rank-(R1, R2, R3) approximation (Lathauwer et al., 2000b) t3_type approximated_data; approximated_data.full_tensor3_matrix_multiplication( core_, u1_, u2_, u3_); double f_norm = approximated_data.frobenius_norm(); double max_f_norm = data_.frobenius_norm(); double normresidual = sqrt( (max_f_norm * max_f_norm) - (f_norm * f_norm)); double fit = 0; if ( (max_f_norm != 0) && (max_f_norm > f_norm) ) { fit = 1 - (normresidual / max_f_norm); } else { fit = 1; } double fitchange = 1; double fitold = fit; double fitchange_tolerance = 1.0e-4; tensor3< I1, R2, R3, T > projection1; tensor3< R1, I2, R3, T > projection2; tensor3< R1, R2, I3, T > projection3; #if TUCKER_LOG std::cout << "HOOI ALS (for tensor3) " << std::endl << "initial fit: " << fit << ", " << "frobenius norm original: " << max_f_norm << std::endl; #endif size_t i = 0; size_t max_iterations = 10; while( (fitchange >= fitchange_tolerance) && (i < max_iterations) ) { fitold = fit; //optimize modes optimize_mode1( data_, u2_, u3_, projection1 ); t3_hosvd< R1, R2, R3, I1, R2, R3, T >::apply_mode1( projection1, u1_ ); optimize_mode2( data_, u1_, u3_, projection2 ); t3_hosvd< R1, R2, R3, R1, I2, R3, T >::apply_mode2( projection2, u2_ ); optimize_mode3( data_, u1_, u2_, projection3 ); t3_hosvd< R1, R2, R3, R1, R2, I3, T >::apply_mode3( projection3, u3_ ); core_.multiply_horizontal_bwd( projection3, transpose( u3_ ) ); f_norm = core_.frobenius_norm(); normresidual = sqrt( max_f_norm * max_f_norm - f_norm * f_norm); fit = 1 - (normresidual / max_f_norm); fitchange = fabs(fitold - fit); #if TUCKER_LOG std::cout << "iteration '" << i << "', fit: " << fit << ", fitdelta: " << fitchange << ", frobenius norm: " << f_norm << std::endl; #endif ++i; } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode1( const t3_type& data_, const u2_type& u2_, const u3_type& u3_, tensor3< I1, R2, R3, T >& projection_ ) { u2_inv_type* u2_inv = new u2_inv_type(); *u2_inv = transpose( u2_ ); u3_inv_type* u3_inv = new u3_inv_type(); *u3_inv = transpose( u3_ ); //backward cyclic matricization/unfolding (after Lathauwer et al., 2000a) tensor3< I1, R2, I3, T >* tmp = new tensor3< I1, R2, I3, T >(); tmp->multiply_frontal_bwd( data_, *u2_inv ); projection_.multiply_horizontal_bwd( *tmp, *u3_inv ); delete u2_inv; delete u3_inv; delete tmp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode2( const t3_type& data_, const u1_type& u1_, const u3_type& u3_, tensor3< R1, I2, R3, T >& projection_ ) { u1_inv_type* u1_inv = new u1_inv_type(); *u1_inv = transpose( u1_ ); u3_inv_type* u3_inv = new u3_inv_type(); *u3_inv = transpose( u3_ ); //backward cyclic matricization (after Lathauwer et al., 2000a) tensor3< R1, I2, I3, T >* tmp = new tensor3< R1, I2, I3, T >(); tmp->multiply_lateral_bwd( data_, *u1_inv ); projection_.multiply_horizontal_bwd( *tmp, *u3_inv ); delete u1_inv; delete u3_inv; delete tmp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode3( const t3_type& data_, const u1_type& u1_, const u2_type& u2_, tensor3< R1, R2, I3, T >& projection_ ) { u1_inv_type* u1_inv = new u1_inv_type(); *u1_inv = transpose( u1_ ); u2_inv_type* u2_inv = new u2_inv_type(); *u2_inv = transpose( u2_ ); //backward cyclic matricization (after Lathauwer et al., 2000a) tensor3< R1, I2, I3, T >* tmp = new tensor3< R1, I2, I3, T >(); tmp->multiply_lateral_bwd( data_, *u1_inv ); projection_.multiply_frontal_bwd( *tmp, *u2_inv ); delete u1_inv; delete u2_inv; delete tmp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::derive_core_orthogonal_bases( const t3_type& data_, const u1_type& u1_, const u2_type& u2_, const u3_type& u3_, t3_core_type& core_ ) { u1_inv_type* u1_inv = new u1_inv_type(); u2_inv_type* u2_inv = new u2_inv_type(); u3_inv_type* u3_inv = new u3_inv_type(); u1_.transpose_to( *u1_inv ); u2_.transpose_to( *u2_inv ); u3_.transpose_to( *u3_inv ); core_.full_tensor3_matrix_multiplication( data_, *u1_inv, *u2_inv, *u3_inv ); delete u1_inv; delete u2_inv; delete u3_inv; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::derive_core( const t3_type& data_, const u1_type& u1_, const u2_type& u2_, const u3_type& u3_, t3_core_type& core_ ) { #if 0 //compute pseudo inverse for matrices u1-u3 u1_comp_type u1_pinv_t ; u2_comp_type u2_pinv_t ; u3_comp_type u3_pinv_t ; compute_pseudoinverse< u1_type > compute_pinv_u1; compute_pinv_u1( *_u1_comp, u1_pinv_t ); compute_pseudoinverse< u2_type > compute_pinv_u2; compute_pinv_u2( *_u2_comp, u2_pinv_t ); compute_pseudoinverse< u3_type > compute_pinv_u3; compute_pinv_u3( *_u3_comp, u3_pinv_t ); u1_inv_type* u1_pinv = new u1_inv_type(); *u1_pinv = transpose( u1_pinv_t ); u2_inv_type* u2_pinv = new u2_inv_type(); *u2_pinv = transpose( u2_pinv_t ); u3_inv_type* u3_pinv = new u3_inv_type(); *u3_pinv = transpose( u3_pinv_t ); t3_comp_type data; datacast_from( data_ ); _core_comp.full_tensor3_matrix_multiplication( data, *u1_pinv, *u2_pinv, *u3_pinv ); delete u1_pinv; delete u2_pinv; delete u3_pinv; #else //previous version of compute core for( size_t r3 = 0; r3 < R3; ++r3 ) { for( size_t r1 = 0; r1 < R1; ++r1 ) { for( size_t r2 = 0; r2 < R2; ++r2 ) { float_t sum_i1_i2_i3 = 0.0; for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; ++i1 ) { for( size_t i2 = 0; i2 < I2; ++i2 ) { sum_i1_i2_i3 += u1_.at( i1, r1 ) * u2_.at( i2, r2 ) * u3_.at( i3, r3 ) * T(data_.at( i1, i2, i3 )); } } } core_.at( r1, r2, r3 ) = sum_i1_i2_i3; } } } #endif } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME }//end vmml namespace #endif vmmlib-1.0/include/vmmlib/t3_hosvd.hpp0000644000175000017500000002445111674116156017365 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * * The Tucker3 tensor class is consists of the same components (core tensor, basis matrices u1-u3) as the tucker3 model described in: * - Tucker, 1966: Some mathematical notes on three-mode factor analysis, Psychometrika. * - Kroonenberg & De Leeuw, 1980: Principal component analysis of three-mode data by means of alternating least squares algorithms. Psychometrika. (TUCKALS) * - De Lathauwer, De Moor, Vandewalle, 2000a: A multilinear singular value decomposition, SIAM J. Matrix Anal. Appl. * - Kolda & Bader, 2009: Tensor Decompositions and Applications, SIAM Review. * - Bader & Kolda, 2006: Algorithm 862: Matlab tensor classes for fast algorithm prototyping. ACM Transactions on Mathematical Software. * */ #ifndef __VMML__T3_HOSVD__HPP__ #define __VMML__T3_HOSVD__HPP__ #include #include #include #include enum hosvd_method { eigs_e, svd_e }; namespace vmml { template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T = float > class t3_hosvd { public: typedef double T_svd; typedef tensor3< I1, I2, I3, T > t3_type; typedef matrix< I1, R1, T > u1_type; typedef matrix< I2, R2, T > u2_type; typedef matrix< I3, R3, T > u3_type; typedef matrix< I1, I2*I3, T > u1_unfolded_type; typedef matrix< I2, I1*I3, T > u2_unfolded_type; typedef matrix< I3, I1*I2, T > u3_unfolded_type; typedef matrix< I1, I1, T > u1_cov_type; typedef matrix< I2, I2, T > u2_cov_type; typedef matrix< I3, I3, T > u3_cov_type; /* higher-order singular value decomposition (HOSVD) with full rank decomposition (also known as Tucker decomposition). see: De Lathauer et al, 2000a: A multilinear singular value decomposition. the hosvd can be computed (a) with n-mode PCA, i.e., an eigenvalue decomposition on the covariance matrix of every mode's matricization, and (b) by performing a 2D SVD on the matricization of every mode. Matrix matricization means that a tensor I1xI2xI3 is unfolded/sliced into one matrix with the dimensions I1xI2I3, which corresponds to a matrizitation alonge mode I1. other known names for HOSVD: n-mode SVD, 3-mode factor analysis (3MFA, tucker3), 3M-PCA, n-mode PCA, higher-order SVD */ static void apply_mode1( const t3_type& data_, u1_type& u1_, hosvd_method method_ = eigs_e ); static void apply_mode2( const t3_type& data_, u2_type& u2_, hosvd_method method_ = eigs_e ); static void apply_mode3( const t3_type& data_, u3_type& u3_, hosvd_method method_ = eigs_e ); static void apply_all( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_, hosvd_method method_ = eigs_e ); static void hosvd( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_ ); static void hoeigs( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_ ); protected: //hosvd template< size_t M, size_t N, size_t R > static void get_svd_u_red( const matrix< M, N, T >& data_, matrix< M, R, T >& u_ ); static void svd_mode1( const t3_type& data_, u1_type& u1_ ); static void svd_mode2( const t3_type& data_, u2_type& u2_ ); static void svd_mode3( const t3_type& data_, u3_type& u3_ ); //hosvd on eigenvalue decomposition = hoeigs template< size_t N, size_t R > static void get_eigs_u_red( const matrix< N, N, T >& data_, matrix< N, R, T >& u_ ); static void eigs_mode1( const t3_type& data_, u1_type& u1_ ); static void eigs_mode2( const t3_type& data_, u2_type& u2_ ); static void eigs_mode3( const t3_type& data_, u3_type& u3_ ); }; //end hosvd class #define VMML_TEMPLATE_STRING template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T > #define VMML_TEMPLATE_CLASSNAME t3_hosvd< R1, R2, R3, I1, I2, I3, T > VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::hosvd( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_ ) { svd_mode1( data_, u1_ ); svd_mode2( data_, u2_ ); svd_mode3( data_, u3_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::hoeigs( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_ ) { eigs_mode1( data_, u1_ ); eigs_mode2( data_, u2_ ); eigs_mode3( data_, u3_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::apply_all( const t3_type& data_, u1_type& u1_, u2_type& u2_, u3_type& u3_, hosvd_method method_ ) { apply_mode1( data_, u1_, method_ ); apply_mode2( data_, u2_, method_ ); apply_mode3( data_, u3_, method_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::apply_mode1( const t3_type& data_, u1_type& u1_, hosvd_method method_ ) { switch ( method_ ) { case 0: eigs_mode1( data_, u1_ ); break; case 1: svd_mode1( data_, u1_ ); break; default: eigs_mode1( data_, u1_ ); } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::apply_mode2( const t3_type& data_, u2_type& u2_, hosvd_method method_ ) { switch ( method_ ) { case 0: eigs_mode2( data_, u2_ ); break; case 1: svd_mode2( data_, u2_ ); break; default: eigs_mode2( data_, u2_ ); } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::apply_mode3( const t3_type& data_, u3_type& u3_, hosvd_method method_ ) { switch ( method_ ) { case 0: eigs_mode3( data_, u3_ ); break; case 1: svd_mode3( data_, u3_ ); break; default: eigs_mode3( data_, u3_ ); } } /* SVD along mode 1, 2, and 3*/ VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::svd_mode1( const t3_type& data_, u1_type& u1_ ) { u1_unfolded_type* u = new u1_unfolded_type; // -> u1 data_.lateral_unfolding_bwd( *u ); get_svd_u_red( *u, u1_ ); delete u; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::svd_mode2( const t3_type& data_, u2_type& u2_ ) { u2_unfolded_type* u = new u2_unfolded_type; // -> u2 data_.frontal_unfolding_bwd( *u ); get_svd_u_red( *u, u2_ ); delete u; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::svd_mode3( const t3_type& data_, u3_type& u3_ ) { u3_unfolded_type* u = new u3_unfolded_type; // -> u3 data_.horizontal_unfolding_bwd( *u ); get_svd_u_red( *u, u3_ ); delete u; } /* EIGS for mode 1, 2 and 3*/ VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::eigs_mode1( const t3_type& data_, u1_type& u1_ ) { //unfolding / matricization u1_unfolded_type* m_lateral = new u1_unfolded_type; // -> u1 data_.lateral_unfolding_bwd( *m_lateral ); //covariance matrix of unfolded data u1_cov_type* cov = new u1_cov_type; blas_dgemm< I1, I2*I3, I1, T>* blas_cov = new blas_dgemm< I1, I2*I3, I1, T>; blas_cov->compute( *m_lateral, *cov ); delete blas_cov; delete m_lateral; //compute x largest magnitude eigenvalues; x = R get_eigs_u_red( *cov, u1_ ); delete cov; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::eigs_mode2( const t3_type& data_, u2_type& u2_ ) { //unfolding / matricization u2_unfolded_type* m_frontal = new u2_unfolded_type; // -> u2 data_.frontal_unfolding_bwd( *m_frontal ); //covariance matrix of unfolded data u2_cov_type* cov = new u2_cov_type; blas_dgemm< I2, I1*I3, I2, T>* blas_cov = new blas_dgemm< I2, I1*I3, I2, T>; blas_cov->compute( *m_frontal, *cov ); delete blas_cov; delete m_frontal; //compute x largest magnitude eigenvalues; x = R get_eigs_u_red( *cov, u2_ ); delete cov; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::eigs_mode3( const t3_type& data_, u3_type& u3_) { //unfolding / matricization u3_unfolded_type* m_horizontal = new u3_unfolded_type; // -> u3 data_.horizontal_unfolding_bwd( *m_horizontal ); //covariance matrix of unfolded data u3_cov_type* cov = new u3_cov_type; blas_dgemm< I3, I1*I2, I3, T>* blas_cov = new blas_dgemm< I3, I1*I2, I3, T>; blas_cov->compute( *m_horizontal, *cov ); delete blas_cov; delete m_horizontal; //compute x largest magnitude eigenvalues; x = R get_eigs_u_red( *cov, u3_ ); delete cov; } /* helper methods for SVD and EIGS*/ VMML_TEMPLATE_STRING template< size_t N, size_t R > void VMML_TEMPLATE_CLASSNAME::get_eigs_u_red( const matrix< N, N, T >& data_, matrix< N, R, T >& u_ ) { typedef matrix< N, N, T_svd > cov_matrix_type; typedef vector< R, T_svd > eigval_type; typedef matrix< N, R, T_svd > eigvec_type; //typedef matrix< N, R, T_coeff > coeff_type; //compute x largest magnitude eigenvalues; x = R eigval_type* eigxvalues = new eigval_type; eigvec_type* eigxvectors = new eigvec_type; lapack_sym_eigs< N, T_svd > eigs; cov_matrix_type* data = new cov_matrix_type; data->cast_from( data_ ); if( eigs.compute_x( *data, *eigxvectors, *eigxvalues) ) { /*if( _is_quantify_coeff ){ coeff_type* evec_quant = new coeff_type; T min_value = 0; T max_value = 0; u_.cast_from( *eigxvectors ); u_.quantize( *evec_quant, min_value, max_value ); evec_quant->dequantize( u_, min_value, max_value ); delete evec_quant; } else */ if ( sizeof( T ) != 4 ){ u_.cast_from( *eigxvectors ); } else { u_ = *eigxvectors; } } else { u_.zero(); } delete eigxvalues; delete eigxvectors; delete data; } VMML_TEMPLATE_STRING template< size_t M, size_t N, size_t R > void VMML_TEMPLATE_CLASSNAME::get_svd_u_red( const matrix< M, N, T >& data_, matrix< M, R, T >& u_ ) { typedef matrix< M, N, T_svd > svd_m_type; //FIXME: typedef matrix< M, N, T_coeff > coeff_type; typedef matrix< M, N, T > m_type; typedef vector< N, T_svd > lambdas_type; svd_m_type* u_double = new svd_m_type; u_double->cast_from( data_ ); //FIXME:: coeff_type* u_quant = new coeff_type; m_type* u_out = new m_type; lambdas_type* lambdas = new lambdas_type; lapack_svd< M, N, T_svd >* svd = new lapack_svd< M, N, T_svd >(); if( svd->compute_and_overwrite_input( *u_double, *lambdas )) { /* if( _is_quantify_coeff ){ T min_value = 0; T max_value = 0; u_comp->cast_from( *u_double ); //FIXME: u_comp->quantize( *u_quant, min_value, max_value ); //FIXME: u_quant->dequantize( *u_internal, min_value, max_value ); } else */ if ( sizeof( T ) != 4 ){ u_out->cast_from( *u_double ); } else { *u_out = *u_double; } u_out->get_sub_matrix( u_ ); } else { u_.zero(); } delete lambdas; delete svd; delete u_double; //delete u_quant; delete u_out; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME }//end vmml namespace #endif vmmlib-1.0/include/vmmlib/tucker3_tensor_sustests.hpp0000644000175000017500000015547211674116156022573 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * @author Jonas Boesch * * The tucker3 tensor class is consists of the same components (core tensor, basis matrices u1-u3) as the tucker3 model described in: * - Tucker, “Some mathematical notes on three-mode factor analysis”, Psychometrika, vol. 31, no. 3, pp. 279–311., 1966 Sep. * - De Lathauwer L., De Moor B., Vandewalle J., ``A multilinear singular value decomposition'', * SIAM J. Matrix Anal. Appl., vol. 21, no. 4, Apr. 2000, pp. 1253-1278. * - De Lathauwer L., De Moor B., Vandewalle J., ``On the Best rank-1 and Rank-$(R_1, R_2, ..., R_N)$ Approximation and Applications of Higher-Order Tensors'', * SIAM J. Matrix Anal. Appl., vol. 21, no. 4, Apr. 2000, pp. 1324-1342. * - T. G. Kolda and B. W. Bader. Tensor Decompositions and Applications. * SIAM Review, Volume 51, Number 3, Pages 455-500, September 2009. * */ #ifndef __VMML__TUCKER3_TENSOR__HPP__ #define __VMML__TUCKER3_TENSOR__HPP__ #define CODE_ALL_U_MIN_MAX 1 #define HOT 16 #include //#include #include namespace vmml { template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value = float, typename T_coeff = double > class tucker3_tensor { public: typedef float T_internal; typedef double T_svd; typedef tucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > tucker3_type; typedef tensor3< I1, I2, I3, T_value > t3_type; typedef typename t3_type::iterator t3_iterator; typedef typename t3_type::const_iterator t3_const_iterator; typedef tensor3< I1, I2, I3, T_coeff > t3_coeff_type; typedef typename t3_coeff_type::iterator t3_coeff_iterator; typedef typename t3_coeff_type::const_iterator t3_coeff_const_iterator; typedef tensor3< R1, R2, R3, T_coeff > t3_core_type; typedef typename t3_core_type::iterator t3_core_iterator; typedef typename t3_core_type::const_iterator t3_core_const_iterator; typedef matrix< R1, R2, T_coeff > front_core_slice_type; //fwd: forward cylcling (after kiers et al., 2000) typedef matrix< I1, R1, T_coeff > u1_type; typedef typename u1_type::iterator u1_iterator; typedef typename u1_type::const_iterator u1_const_iterator; typedef matrix< I2, R2, T_coeff > u2_type; typedef typename u2_type::iterator u2_iterator; typedef typename u2_type::const_iterator u2_const_iterator; typedef matrix< I3, R3, T_coeff > u3_type; typedef typename u3_type::iterator u3_iterator; typedef typename u3_type::const_iterator u3_const_iterator; typedef tensor3< I1, I2, I3, T_internal > t3_comp_type; typedef typename t3_comp_type::iterator t3_comp_iterator; typedef typename t3_comp_type::const_iterator t3_comp_const_iterator; typedef tensor3< R1, R2, R3, T_internal > t3_core_comp_type; typedef matrix< I1, R1, T_internal > u1_comp_type; typedef matrix< I2, R2, T_internal > u2_comp_type; typedef matrix< I3, R3, T_internal > u3_comp_type; //8bit basis typedef matrix< I1, R1, unsigned char > u1_8_type; typedef matrix< I2, R2, unsigned char > u2_8_type; typedef matrix< I3, R3, unsigned char > u3_8_type; //matrix types for inverted (pseudo-inverted) u1-u3 typedef matrix< R1, I1, T_internal > u1_inv_type; typedef matrix< R2, I2, T_internal > u2_inv_type; typedef matrix< R3, I3, T_internal > u3_inv_type; typedef matrix< I1, I2*I3, T_internal > mode1_matricization_type; typedef matrix< I2, I1*I3, T_internal > mode2_matricization_type; typedef matrix< I3, I1*I2, T_internal > mode3_matricization_type; static const size_t SIZE = R1*R2*R3 + I1*R1 + I2*R2 + I3*R3; tucker3_tensor(); tucker3_tensor( t3_core_type& core ); tucker3_tensor( t3_core_type& core, u1_type& U1, u2_type& U2, u3_type& U3 ); tucker3_tensor( const tucker3_type& other ); ~tucker3_tensor(); void enable_quantify_coeff() { _is_quantify_coeff = true; }; void disable_quantify_coeff() { _is_quantify_coeff = false; } ; void enable_quantify_hot() { _is_quantify_hot = true; }; void disable_quantify_hot() { _is_quantify_hot = false; } ; void set_core( t3_core_type& core ) { _core = t3_core_type( core ); _core_comp.cast_from( core ); } ; void set_u1( u1_type& U1 ) { *_u1 = U1; _u1_comp->cast_from( U1 ); } ; void set_u2( u2_type& U2 ) { *_u2 = U2; _u1_comp->cast_from( U2 ); } ; void set_u3( u3_type& U3 ) { *_u3 = U3; _u1_comp->cast_from( U3 ); } ; void get_core( t3_core_type& data_ ) const { data_ = _core; } ; void get_u1( u1_type& U1 ) const { U1 = *_u1; } ; void get_u2( u2_type& U2 ) const { U2 = *_u2; } ; void get_u3( u3_type& U3 ) const { U3 = *_u3; } ; template< typename T > void export_to( std::vector< T >& data_ ); template< typename T > void import_from( const std::vector< T >& data_ ); //previous version, but works only with 16bit quantization void export_quantized_to( std::vector& data_out_ ); void import_quantized_from( const std::vector& data_in_ ); //use this version, works with a better quantization for the core tensor: //logarithmic quantization and separate high energy core vale void export_hot_quantized_to( std::vector& data_out_ ); void import_hot_quantized_from( const std::vector& data_in_ ); //get number of nonzeros for tensor decomposition size_t nnz() const; size_t nnz( const T_value& threshold ) const; size_t nnz_core() const; size_t size_core() const; size_t size() const { return SIZE; } ; void threshold_core( const size_t& nnz_core_, size_t& nnz_core_is_ ); void threshold_core( const T_coeff& threshold_value_, size_t& nnz_core_ ); void reconstruct( t3_type& data_, const T_internal& u_min_, const T_internal& u_max_, const T_internal& core_min_, const T_internal& core_max_ ); void reconstruct( t3_type& data_, const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_, const T_internal& core_min_, const T_internal& core_max_ ); void reconstruct_basis_8bit( t3_type& data_, const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_, const T_internal& core_min_, const T_internal& core_max_ ); void reconstruct( t3_type& data_ ); void decompose( const t3_type& data_ ); void decompose( const t3_type& data_, T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_, T_internal& core_min_, T_internal& core_max_ ); void decompose_basis_8bit( const t3_type& data_, T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_, T_internal& core_min_, T_internal& core_max_ ); void decompose( const t3_type& data_, T_internal& u_min_, T_internal& u_max_, T_internal& core_min_, T_internal& core_max_ ); void tucker_als( const t3_type& data_ ); /* higher-order singular value decomposition (HOSVD) with full rank decomposition (also known as Tucker decomposition). see: De Lathauer et al, 2000a: A multilinear singular value decomposition. the hosvd can be computed (a) with n-mode PCA, i.e., an eigenvalue decomposition on the covariance matrix of every mode's matricization, and (b) by performing a 2D SVD on the matricization of every mode. Matrix matricization means that a tensor I1xI2xI3 is unfolded/sliced into one matrix with the dimensions I1xI2I3, which corresponds to a matrizitation alonge mode I1. other known names for HOSVD: n-mode SVD, 3-mode factor analysis (3MFA, tucker3), 3M-PCA, n-mode PCA, higher-order SVD */ void hosvd( const t3_type& data_ ); void hosvd_on_eigs( const t3_type& data_ ); /* higher-order orthogonal iteration (HOOI) is a truncated HOSVD decompositions, i.e., the HOSVD components are of lower-ranks. An optimal rank-reduction is performed with an alternating least-squares (ALS) algorithm, which minimizes the error between the approximated and orignal tensor based on the Frobenius norm see: De Lathauwer et al, 2000b; On the best rank-1 and rank-(RRR) approximation of higher-order tensors. the HOOI can be computed based on (a) n-mode PCA, i.e., an eigenvalue decomposition on the covariance matrix of every mode's matriciziation, and (b) by performing a 2D SVD on the matricization of every mode. Matrix matricization means that a tensor I1xI2xI3 is unfolded/sliced into one matrix with the dimensions I1xI2I3, which corresponds to a matrizitation alonge mode I1. */ void hooi( const t3_type& data_ ); /* derive core implemented accodring to core = data x_1 U1_pinv x_2 U2_pinv x_3 U3_pinv, where x_1 ... x_3 are n-mode products and U1_pinv ... U3_pinv are inverted basis matrices the inversion is done with a matrix pseudoinverse computation */ void derive_core( const t3_type& data_ ); //faster: but only if basis matrices are orthogonal void derive_core_orthogonal_bases( const t3_type& data_ ); template< size_t K1, size_t K2, size_t K3> void reduce_ranks( const tucker3_tensor< K1, K2, K3, I1, I2, I3, T_value, T_coeff >& other ); //call TuckerJI.reduce_ranks(TuckerKI) K1 -> R1, K2 -> R2, K3 -> R3 template< size_t K1, size_t K2, size_t K3> void subsampling( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& factor ); template< size_t K1, size_t K2, size_t K3> void subsampling_on_average( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& factor ); template< size_t K1, size_t K2, size_t K3> void region_of_interest( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& start_index1, const size_t& end_index1, const size_t& start_index2, const size_t& end_index2, const size_t& start_index3, const size_t& end_index3); friend std::ostream& operator << ( std::ostream& os, const tucker3_type& t3 ) { t3_core_type core; t3.get_core( core ); u1_type* u1 = new u1_type; t3.get_u1( *u1 ); u2_type* u2 = new u2_type; t3.get_u2( *u2 ); u3_type* u3 = new u3_type; t3.get_u3( *u3 ); os << "U1: " << std::endl << *u1 << std::endl << "U2: " << std::endl << *u2 << std::endl << "U3: " << std::endl << *u3 << std::endl << "core: " << std::endl << core << std::endl; delete u1; delete u2; delete u3; return os; } protected: tucker3_type operator=( const tucker3_type& other ) { return (*this); }; void init_random( const t3_type& data_ ); template< size_t M, size_t N > void fill_random_2d( int seed, matrix< M, N, T_internal >& u ); template< size_t M, size_t N, size_t R, typename T > void get_svd_u_red( const matrix< M, N, T >& data_, matrix< M, R, T_internal >& u_ ) const; template< size_t J1, size_t J2, size_t J3, typename T > void hosvd_mode1( const tensor3& data_ ) const; template< size_t J1, size_t J2, size_t J3, typename T > void hosvd_mode2( const tensor3& data_ ) const; template< size_t J1, size_t J2, size_t J3, typename T > void hosvd_mode3( const tensor3& data_ ) const; void optimize_mode1( const t3_comp_type& data_, tensor3< I1, R2, R3, T_internal >& projection_ ) const; void optimize_mode2( const t3_comp_type& data_, tensor3< R1, I2, R3, T_internal >& projection_ ) const; void optimize_mode3( const t3_comp_type& data_, tensor3< R1, R2, I3, T_internal >& projection_ ) const; private: void cast_members(); void cast_comp_members(); void quantize_basis_matrices( T_internal& u_min_, T_internal& u_max_ ); void quantize_basis_matrices( T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_ ); void quantize_basis_matrices_8bit( T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_ ); void quantize_core( T_internal& core_min_, T_internal& core_max_ ); void dequantize_basis_matrices( const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_ ); void dequantize_basis_matrices_8bit( const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_ ); void dequantize_core( const T_internal& core_min_, const T_internal& core_max_ ); //t3_core_type* _core ; u1_type* _u1 ; u2_type* _u2 ; u3_type* _u3 ; t3_core_type _core ; //used only internally for computations to have a higher precision t3_core_comp_type _core_comp ; u1_comp_type* _u1_comp ; u2_comp_type* _u2_comp ; u3_comp_type* _u3_comp ; T_internal _hottest_core_value; //t3_core_comp_type _cold_core_comp; tensor3< R1, R2, R3, char> _signs; bool _is_quantify_coeff; bool _is_quantify_hot; //8bit basis matrices u1_8_type* _u1_8 ; u2_8_type* _u2_8 ; u3_8_type* _u3_8 ; //hot core corner/edge tensor3< HOT, HOT, HOT, unsigned short > _hot_core; tensor3< HOT, HOT, HOT, T_internal> _hot_core_comp; T_internal _hot_min; T_internal _hot_max; }; // class tucker3_tensor #define VMML_TEMPLATE_STRING template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value, typename T_coeff > #define VMML_TEMPLATE_CLASSNAME tucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( ) : _is_quantify_coeff( false ), _is_quantify_hot( false ), _hottest_core_value( 0 ) { _core.zero(); _u1 = new u1_type(); _u1->zero(); _u2 = new u2_type(); _u2->zero(); _u3 = new u3_type(); _u3->zero(); _core_comp.zero(); _u1_comp = new u1_comp_type(); _u1_comp->zero(); _u2_comp = new u2_comp_type(); _u2_comp->zero(); _u3_comp = new u3_comp_type(); _u3_comp->zero(); _signs.zero(); //_cold_core_comp.zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( t3_core_type& core ) : _is_quantify_coeff( false ), _is_quantify_hot( false ), _hottest_core_value( 0 ) { _core = core; _u1 = new u1_type(); _u1->zero(); _u2 = new u2_type(); _u2->zero(); _u3 = new u3_type(); _u3->zero(); _u1_comp = new u1_comp_type(); _u1_comp->zero(); _u2_comp = new u2_comp_type(); _u2_comp->zero(); _u3_comp = new u3_comp_type(); _u3_comp->zero(); _core_comp.cast_from( core ); _signs.zero(); //_cold_core_comp.zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( t3_core_type& core, u1_type& U1, u2_type& U2, u3_type& U3 ) : _is_quantify_coeff( false ), _is_quantify_hot( false ), _hottest_core_value( 0 ) { _core = core; _u1 = new u1_type( U1 ); _u2 = new u2_type( U2 ); _u3 = new u3_type( U3 ); _u1_comp = new u1_comp_type(); _u2_comp = new u2_comp_type(); _u3_comp = new u3_comp_type(); cast_comp_members(); _signs.zero(); //_cold_core_comp.zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( const tucker3_type& other ) : _is_quantify_coeff( false ), _is_quantify_hot( false ), _hottest_core_value( 0 ) { _u1 = new u1_type(); _u2 = new u2_type(); _u3 = new u3_type(); _u1_comp = new u1_comp_type(); _u2_comp = new u2_comp_type(); _u3_comp = new u3_comp_type(); other.get_core( _core ); other.get_u1( *_u1 ); other.get_u2( *_u2 ); other.get_u3( *_u3 ); cast_comp_members(); _signs.zero(); //_cold_core_comp.zero(); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::cast_members() { _u1->cast_from( *_u1_comp ); _u2->cast_from( *_u2_comp ); _u3->cast_from( *_u3_comp ); _core.cast_from( _core_comp); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::cast_comp_members() { _u1_comp->cast_from( *_u1 ); _u2_comp->cast_from( *_u2 ); _u3_comp->cast_from( *_u3 ); _core_comp.cast_from( _core); } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz_core() const { return _core_comp.nnz(); } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::size_core() const { return _core_comp.size(); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::quantize_basis_matrices(T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_ ) { _u1_comp->quantize( *_u1, u1_min_, u1_max_ ); _u2_comp->quantize( *_u2, u2_min_, u2_max_ ); _u3_comp->quantize( *_u3, u3_min_, u3_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::quantize_basis_matrices_8bit( T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_) { _u1_8 = new u1_8_type; _u2_8 = new u2_8_type; _u3_8 = new u3_8_type; _u1_comp->quantize( *_u1_8, u1_min_, u1_max_ ); _u2_comp->quantize( *_u2_8, u2_min_, u2_max_ ); _u3_comp->quantize( *_u3_8, u3_min_, u3_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::quantize_basis_matrices(T_internal& u_min_, T_internal& u_max_) { u_min_ = _u1_comp->get_min(); T_internal u2_min = _u2_comp->get_min(); T_internal u3_min = _u3_comp->get_min(); if ( u2_min < u_min_) { u_min_ = u2_min; } if ( u3_min < u_min_) { u_min_ = u3_min; } u_max_ = _u1_comp->get_max(); T_internal u2_max = _u2_comp->get_max(); T_internal u3_max = _u3_comp->get_max(); if ( u2_max > u_max_ ) { u_max_ = u2_max; } if ( u3_max > u_max_ ) { u_max_ = u3_max; } _u1_comp->quantize_to( *_u1, u_min_, u_max_ ); _u2_comp->quantize_to( *_u2, u_min_, u_max_ ); _u3_comp->quantize_to( *_u3, u_min_, u_max_ ); #if 0 std::cout << "quantized (1u): " << std::endl << "u1-u3: " << std::endl << *_u1 << std::endl << *_u1_comp << std::endl << *_u2 << std::endl << *_u2_comp << std::endl << *_u3 << std::endl << *_u3_comp << std::endl << " core " << std::endl << _core << std::endl << " core_comp " << std::endl << _core_comp << std::endl; #endif } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::quantize_core( T_internal& core_min_, T_internal& core_max_ ) { if ( _is_quantify_hot ) { T_coeff range = 127; #if 0 _hottest_core_value = _core_comp.at(0,0,0); _core_comp.at( 0, 0, 0 ) = 0; _core_comp.quantize_log( _core, _signs, core_min_, core_max_, range ); #else _hottest_core_value = _core_comp.at(0,0,0); std::cout << "hottest core value: " << _hottest_core_value << std::endl; _core_comp.at( 0, 0, 0 ) = 0; //hot core corner _core_comp.get_sub_tensor3( _hot_core_comp ); _hot_core_comp.quantize( _hot_core, _hot_min, _hot_max ); for( size_t i3 = 0; i3 < HOT; ++i3 ) { for( size_t i2 = 0; i2 < HOT; ++i2 ) { for( size_t i1 = 0; i1 < HOT; ++i1 ) { _core_comp.at( i1, i2, i3 ) = 0; } } } _core_comp.quantize_log( _core, _signs, core_min_, core_max_, range ); #endif } else { T_coeff range = 511; _core_comp.quantize_log( _core, _signs, core_min_, core_max_, range ); std::cout << "quant core logarithmic" << std::endl; //_core_comp.quantize( _core, core_min_, core_max_ ); } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::dequantize_basis_matrices_8bit( const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_ ) { _u1_8->dequantize( *_u1_comp, u1_min_, u1_max_ ); _u2_8->dequantize( *_u2_comp, u2_min_, u2_max_ ); _u3_8->dequantize( *_u3_comp, u3_min_, u3_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::dequantize_basis_matrices( const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_ ) { _u1->dequantize( *_u1_comp, u1_min_, u1_max_ ); _u2->dequantize( *_u2_comp, u2_min_, u2_max_ ); _u3->dequantize( *_u3_comp, u3_min_, u3_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::dequantize_core( const T_internal& core_min_, const T_internal& core_max_ ) { if ( _is_quantify_hot ) { _core.dequantize_log( _core_comp, _signs, core_min_, core_max_ ); #if 1 _hot_core.dequantize( _hot_core_comp, _hot_min, _hot_max ); for( size_t i3 = 0; i3 < HOT; ++i3 ) { for( size_t i2 = 0; i2 < HOT; ++i2 ) { for( size_t i1 = 0; i1 < HOT; ++i1 ) { _core_comp.at( i1, i2, i3 ) = _hot_core_comp.at( i1, i2, i3 ); _core.at( i1, i2, i3 ) = _hot_core_comp.at( i1, i2, i3 ); } } } #endif _core.at(0,0,0) = _hottest_core_value; _core_comp.at(0,0,0) = _hottest_core_value; } else { _core.dequantize_log( _core_comp, _signs, core_min_, core_max_ ); } } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::~tucker3_tensor( ) { delete _u1; delete _u2; delete _u3; delete _u1_comp; delete _u2_comp; delete _u3_comp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_, const T_internal& u_min_, const T_internal& u_max_, const T_internal& core_min_, const T_internal& core_max_ ) { dequantize_basis_matrices( u_min_, u_max_, u_min_, u_max_, u_min_, u_max_ ); dequantize_core( core_min_, core_max_ ); #if 0 std::cout << "dequantized (1u): " << std::endl << "u1-u3: " << std::endl << *_u1 << std::endl << *_u1_comp << std::endl << *_u2 << std::endl << *_u2_comp << std::endl << *_u3 << std::endl << *_u3_comp << std::endl << " core " << std::endl << _core << std::endl << " core_comp " << std::endl << _core_comp << std::endl; #endif reconstruct( data_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_, const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_, const T_internal& core_min_, const T_internal& core_max_ ) { dequantize_basis_matrices( u1_min_, u1_max_, u2_min_, u2_max_, u3_min_, u3_max_ ); dequantize_core( core_min_, core_max_ ); reconstruct( data_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct_basis_8bit( t3_type& data_, const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_, const T_internal& core_min_, const T_internal& core_max_ ) { dequantize_basis_matrices_8bit( u1_min_, u1_max_, u2_min_, u2_max_, u3_min_, u3_max_ ); dequantize_core( core_min_, core_max_ ); reconstruct( data_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_ ) { t3_comp_type data; data.cast_from( data_ ); data.full_tensor3_matrix_multiplication( _core_comp, *_u1_comp, *_u2_comp, *_u3_comp ); //convert reconstructed data, which is in type T_internal (double, float) to T_value (uint8 or uint16) if( (sizeof(T_value) == 1) || (sizeof(T_value) == 2) ){ data_.float_t_to_uint_t( data ); } else { data_.cast_from( data ); } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::threshold_core( const size_t& nnz_core_, size_t& nnz_core_is_ ) { nnz_core_is_ = _core_comp.nnz(); T_coeff threshold_value = 0.00001; while( nnz_core_is_ > nnz_core_ ) { _core_comp.threshold( threshold_value ); nnz_core_is_ = _core_comp.nnz(); //threshold value scheme if( threshold_value < 0.01) { threshold_value *= 10; } else if ( threshold_value < 0.2) { threshold_value += 0.05; } else if ( threshold_value < 1) { threshold_value += 0.25; } else if (threshold_value < 10 ) { threshold_value += 1; } else if (threshold_value < 50 ) { threshold_value += 10; } else if (threshold_value < 200 ) { threshold_value += 50; } else if (threshold_value < 500 ) { threshold_value += 100; } else if (threshold_value < 2000 ) { threshold_value += 500; } else if (threshold_value < 5000 ) { threshold_value += 3000; } else if (threshold_value >= 5000 ){ threshold_value += 5000; } } _core.cast_from( _core_comp); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::threshold_core( const T_coeff& threshold_value_, size_t& nnz_core_ ) { _core_comp.threshold( threshold_value_ ); nnz_core_ = _core_comp.nnz(); _core.cast_from( _core_comp); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::decompose( const t3_type& data_ ) { tucker_als( data_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::decompose( const t3_type& data_, T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_, T_internal& core_min_, T_internal& core_max_ ) { decompose( data_ ); quantize_basis_matrices( u1_min_, u1_max_, u2_min_, u2_max_, u3_min_, u3_max_ ); quantize_core(core_min_, core_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::decompose_basis_8bit( const t3_type& data_, T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_, T_internal& core_min_, T_internal& core_max_ ) { decompose( data_ ); quantize_basis_matrices_8bit( u1_min_, u1_max_, u2_min_, u2_max_, u3_min_, u3_max_ ); quantize_core(core_min_, core_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::decompose( const t3_type& data_, T_internal& u_min_, T_internal& u_max_, T_internal& core_min_, T_internal& core_max_ ) { decompose( data_ ); quantize_basis_matrices( u_min_, u_max_ ); quantize_core(core_min_, core_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::tucker_als( const t3_type& data_ ) { hooi( data_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::init_random( const t3_type& data_ ) { int seed = time(NULL); fill_random_2d(seed, *_u1_comp ); fill_random_2d(rand(), *_u2_comp ); fill_random_2d(rand(), *_u3_comp ); derive_core_orthogonal_bases(data_ ); cast_members(); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::hosvd( const t3_type& data_ ) { hosvd_mode1( data_ ); hosvd_mode2( data_ ); hosvd_mode3( data_ ); derive_core_orthogonal_bases(data_ ); cast_members(); } VMML_TEMPLATE_STRING template< size_t M, size_t N > void VMML_TEMPLATE_CLASSNAME::fill_random_2d( int seed, matrix< M, N, T_internal >& u) { double fillValue = 0.0f; srand(seed); for( size_t row = 0; row < M; ++row ) { for( size_t col = 0; col < N; ++col ) { fillValue = rand(); fillValue /= RAND_MAX; u.at( row, col ) = -1.0 + 2.0 * static_cast< double >( fillValue ) ; } } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::hooi( const t3_type& data_ ) { //intialize basis matrices hosvd( data_ ); t3_comp_type data; data.cast_from( data_ ); //compute best rank-(R1, R2, R3) approximation (Lathauwer et al., 2000b) t3_comp_type approximated_data; approximated_data.full_tensor3_matrix_multiplication( _core_comp, *_u1_comp, *_u2_comp, *_u3_comp ); double f_norm = approximated_data.frobenius_norm(); double max_f_norm = data.frobenius_norm(); double normresidual = sqrt( (max_f_norm * max_f_norm) - (f_norm * f_norm)); double fit = 0; if (max_f_norm != 0 ) { fit = 1 - (normresidual / max_f_norm); } else { fit = 1; } double fitchange = fit; double fitold = fit; double fitchange_tolerance = 1.0e-4; tensor3< I1, R2, R3, T_internal > projection1; tensor3< R1, I2, R3, T_internal > projection2; tensor3< R1, R2, I3, T_internal > projection3; #define TUCKER_LOG 1 #if TUCKER_LOG std::cout << "Tucker ALS: HOOI (for tensor3) " << std::endl << "initial fit: " << fit << ", " << "frobenius norm original: " << max_f_norm << std::endl; #endif size_t i = 0; size_t max_iterations = 10; while( (fitchange >= fitchange_tolerance) && (i < max_iterations) ) { fitold = fit; //optimize modes optimize_mode1( data, projection1 ); hosvd_mode1( projection1 ); optimize_mode2( data, projection2 ); hosvd_mode2( projection2 ); optimize_mode3( data, projection3 ); hosvd_mode3( projection3 ); _core_comp.multiply_horizontal_bwd( projection3, transpose( *_u3_comp ) ); f_norm = _core_comp.frobenius_norm(); normresidual = sqrt( max_f_norm * max_f_norm - f_norm * f_norm); fit = 1 - (normresidual / max_f_norm); fitchange = fabs(fitold - fit); #if TUCKER_LOG std::cout << "iteration '" << i << "', fit: " << fit << ", fitdelta: " << fitchange << ", frobenius norm: " << f_norm << std::endl; #endif ++i; } cast_members(); } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3, typename T > void VMML_TEMPLATE_CLASSNAME::hosvd_mode1( const tensor3& data_ ) const { matrix< J1, J2*J3, T >* u = new matrix< J1, J2*J3, T >(); // -> u1 data_.lateral_unfolding_bwd( *u ); get_svd_u_red( *u, *_u1_comp ); delete u; } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3, typename T > void VMML_TEMPLATE_CLASSNAME::hosvd_mode2( const tensor3& data_ ) const { matrix< J2, J1*J3, T >* u = new matrix< J2, J1*J3, T >(); // -> u1 data_.frontal_unfolding_bwd( *u ); get_svd_u_red( *u, *_u2_comp ); delete u; } VMML_TEMPLATE_STRING template< size_t J1, size_t J2, size_t J3, typename T > void VMML_TEMPLATE_CLASSNAME::hosvd_mode3( const tensor3& data_ ) const { matrix< J3, J1*J2, T >* u = new matrix< J3, J1*J2, T >(); // -> u1 data_.horizontal_unfolding_bwd( *u ); get_svd_u_red( *u, *_u3_comp ); delete u; } VMML_TEMPLATE_STRING template< size_t M, size_t N, size_t R, typename T > void VMML_TEMPLATE_CLASSNAME::get_svd_u_red( const matrix< M, N, T >& data_, matrix< M, R, T_internal >& u_ ) const { matrix< M, N, T_svd >* u_double = new matrix< M, N, T_svd >(); u_double->cast_from( data_ ); matrix< M, N, T_coeff >* u_quant = new matrix< M, N, T_coeff >(); matrix< M, N, T_internal >* u_internal = new matrix< M, N, T_internal >(); vector< N, T_svd >* lambdas = new vector< N, T_svd >(); lapack_svd< M, N, T_svd >* svd = new lapack_svd< M, N, T_svd >(); if( svd->compute_and_overwrite_input( *u_double, *lambdas )) { if( _is_quantify_coeff || _is_quantify_hot ){ T_internal min_value = 0; T_internal max_value = 0; u_internal->cast_from( *u_double ); u_internal->quantize( *u_quant, min_value, max_value ); u_quant->dequantize( *u_internal, min_value, max_value ); } else if ( sizeof( T_internal ) != 4 ){ u_internal->cast_from( *u_double ); } else { *u_internal = *u_double; } u_internal->get_sub_matrix( u_ ); } else { u_.zero(); } delete lambdas; delete svd; delete u_double; delete u_quant; delete u_internal; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode1( const t3_comp_type& data_, tensor3< I1, R2, R3, T_internal >& projection_ ) const { u2_inv_type* u2_inv = new u2_inv_type(); *u2_inv = transpose( *_u2_comp ); u3_inv_type* u3_inv = new u3_inv_type(); *u3_inv = transpose( *_u3_comp ); //backward cyclic matricization/unfolding (after Lathauwer et al., 2000a) tensor3< I1, R2, I3, T_internal >* tmp = new tensor3< I1, R2, I3, T_internal >(); tmp->multiply_frontal_bwd( data_, *u2_inv ); projection_.multiply_horizontal_bwd( *tmp, *u3_inv ); delete u2_inv; delete u3_inv; delete tmp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode2( const t3_comp_type& data_, tensor3< R1, I2, R3, T_internal >& projection_ ) const { u1_inv_type* u1_inv = new u1_inv_type(); *u1_inv = transpose( *_u1_comp ); u3_inv_type* u3_inv = new u3_inv_type(); *u3_inv = transpose( *_u3_comp ); //backward cyclic matricization (after Lathauwer et al., 2000a) tensor3< R1, I2, I3, T_internal >* tmp = new tensor3< R1, I2, I3, T_internal >(); tmp->multiply_lateral_bwd( data_, *u1_inv ); projection_.multiply_horizontal_bwd( *tmp, *u3_inv ); delete u1_inv; delete u3_inv; delete tmp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::optimize_mode3( const t3_comp_type& data_, tensor3< R1, R2, I3, T_internal >& projection_ ) const { u1_inv_type* u1_inv = new u1_inv_type(); *u1_inv = transpose( *_u1_comp ); u2_inv_type* u2_inv = new u2_inv_type(); *u2_inv = transpose( *_u2_comp ); //backward cyclic matricization (after Lathauwer et al., 2000a) tensor3< R1, I2, I3, T_internal >* tmp = new tensor3< R1, I2, I3, T_internal >(); tmp->multiply_lateral_bwd( data_, *u1_inv ); projection_.multiply_frontal_bwd( *tmp, *u2_inv ); delete u1_inv; delete u2_inv; delete tmp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::derive_core_orthogonal_bases( const t3_type& data_ ) { u1_inv_type * u1_inv = new u1_inv_type(); *u1_inv = transpose( *_u1_comp ); u2_inv_type* u2_inv = new u2_inv_type(); *u2_inv = transpose( *_u2_comp ); u3_inv_type* u3_inv = new u3_inv_type(); *u3_inv = transpose( *_u3_comp ); t3_comp_type data; data.cast_from( data_ ); _core_comp.full_tensor3_matrix_multiplication( data, *u1_inv, *u2_inv, *u3_inv ); _core.cast_from( _core_comp ); delete u1_inv; delete u2_inv; delete u3_inv; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::derive_core( const t3_type& data_ ) { #if 0 //compute pseudo inverse for matrices u1-u3 u1_comp_type u1_pinv_t ; u2_comp_type u2_pinv_t ; u3_comp_type u3_pinv_t ; compute_pseudoinverse< u1_type > compute_pinv_u1; compute_pinv_u1( *_u1_comp, u1_pinv_t ); compute_pseudoinverse< u2_type > compute_pinv_u2; compute_pinv_u2( *_u2_comp, u2_pinv_t ); compute_pseudoinverse< u3_type > compute_pinv_u3; compute_pinv_u3( *_u3_comp, u3_pinv_t ); u1_inv_type* u1_pinv = new u1_inv_type(); *u1_pinv = transpose( u1_pinv_t ); u2_inv_type* u2_pinv = new u2_inv_type(); *u2_pinv = transpose( u2_pinv_t ); u3_inv_type* u3_pinv = new u3_inv_type(); *u3_pinv = transpose( u3_pinv_t ); t3_comp_type data; datacast_from( data_ ); _core_comp.full_tensor3_matrix_multiplication( data, *u1_pinv, *u2_pinv, *u3_pinv ); delete u1_pinv; delete u2_pinv; delete u3_pinv; #else //previous version of compute core for( size_t r3 = 0; r3 < R3; ++r3 ) { for( size_t r1 = 0; r1 < R1; ++r1 ) { for( size_t r2 = 0; r2 < R2; ++r2 ) { float_t sum_i1_i2_i3 = 0.0; for( size_t i3 = 0; i3 < I3; ++i3 ) { for( size_t i1 = 0; i1 < I1; ++i1 ) { for( size_t i2 = 0; i2 < I2; ++i2 ) { sum_i1_i2_i3 += _u1_comp->at( i1, r1 ) * _u2_comp->at( i2, r2 ) * _u3_comp->at( i3, r3 ) * T_internal(data_.at( i1, i2, i3 )); } } } _core_comp.at( r1, r2, r3 ) = sum_i1_i2_i3; } } } _core.cast_from( _core_comp ); #endif } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3> void VMML_TEMPLATE_CLASSNAME::reduce_ranks( const tucker3_tensor< K1, K2, K3, I1, I2, I3, T_value, T_coeff >& other ) //TuckerJI.rank_recuction(TuckerKI) K1 -> R1, K2 -> R2, K3 -> R3; I1, I2, I3 stay the same { assert(R1 <= K1); assert(R2 <= K2); assert(R3 <= K3); //reduce basis matrices matrix< I1, K1, T_coeff >* u1 = new matrix< I1, K1, T_coeff >(); other.get_u1( *u1); for( size_t r1 = 0; r1 < R1; ++r1 ) { _u1->set_column( r1, u1->get_column( r1 )); } matrix< I2, K2, T_coeff >* u2 = new matrix< I2, K2, T_coeff >(); other.get_u2( *u2 ); for( size_t r2 = 0; r2 < R2; ++r2) { _u2->set_column( r2, u2->get_column( r2 )); } matrix< I3, K3, T_coeff >* u3 = new matrix< I3, K3, T_coeff >(); other.get_u3( *u3 ); for( size_t r3 = 0; r3 < R3; ++r3) { _u3->set_column( r3, u3->get_column( r3 )); } //reduce core tensor3 other_core; other.get_core( other_core ); for( size_t r3 = 0; r3 < R3; ++r3 ) { for( size_t r1 = 0; r1 < R1; ++r1 ) { for( size_t r2 = 0; r2 < R2; ++r2 ) { _core.at( r1, r2, r3 ) = other_core.at( r1, r2, r3 ); } } } cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3> void VMML_TEMPLATE_CLASSNAME::subsampling( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& factor ) { assert(I1 <= K1); assert(I1 <= K2); assert(I1 <= K3); //subsample basis matrices matrix< K1, R1, T_coeff >* u1 = new matrix< K1, R1, T_coeff >(); other.get_u1( *u1 ); for( size_t i1 = 0, i = 0; i1 < K1; i1 += factor, ++i ) { _u1->set_row( i, u1->get_row( i1 )); } matrix< K2, R2, T_coeff >* u2 = new matrix< K2, R2, T_coeff >(); other.get_u2( *u2 ); for( size_t i2 = 0, i = 0; i2 < K2; i2 += factor, ++i) { _u2->set_row( i, u2->get_row( i2 )); } matrix< K3, R3, T_coeff >* u3 = new matrix< K3, R3, T_coeff >() ; other.get_u3( *u3 ); for( size_t i3 = 0, i = 0; i3 < K3; i3 += factor, ++i) { _u3->set_row( i, u3->get_row( i3 )); } other.get_core( _core ); cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3> void VMML_TEMPLATE_CLASSNAME::subsampling_on_average( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& factor ) { assert(I1 <= K1); assert(I1 <= K2); assert(I1 <= K3); //subsample basis matrices matrix< K1, R1, T_coeff >* u1 = new matrix< K1, R1, T_coeff >(); other.get_u1( *u1 ); for( size_t i1 = 0, i = 0; i1 < K1; i1 += factor, ++i ) { vector< R1, T_internal > tmp_row = u1->get_row( i1 ); T_internal num_items_averaged = 1; for( size_t j = i1+1; (j < (factor+i1)) & (j < K1); ++j, ++num_items_averaged ) tmp_row += u1->get_row( j ); tmp_row /= num_items_averaged; _u1->set_row( i, tmp_row); } matrix< K2, R2, T_coeff >* u2 = new matrix< K2, R2, T_coeff >(); other.get_u2( *u2 ); for( size_t i2 = 0, i = 0; i2 < K2; i2 += factor, ++i) { vector< R2, T_internal > tmp_row = u2->get_row( i2 ); T_internal num_items_averaged = 1; for( size_t j = i2+1; (j < (factor+i2)) & (j < K2); ++j, ++num_items_averaged ) tmp_row += u2->get_row( j ); tmp_row /= num_items_averaged; _u2->set_row( i, u2->get_row( i2 )); } matrix< K3, R3, T_coeff >* u3 = new matrix< K3, R3, T_coeff >(); other.get_u3( *u3 ); for( size_t i3 = 0, i = 0; i3 < K3; i3 += factor, ++i) { vector< R3, T_internal > tmp_row = u3->get_row( i3 ); T_internal num_items_averaged = 1; for( size_t j = i3+1; (j < (factor+i3)) & (j < K3); ++j, ++num_items_averaged ) tmp_row += u3->get_row( j ); tmp_row /= num_items_averaged; _u3->set_row( i, u3->get_row( i3 )); } other.get_core( _core ); cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3> void VMML_TEMPLATE_CLASSNAME::region_of_interest( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& start_index1, const size_t& end_index1, const size_t& start_index2, const size_t& end_index2, const size_t& start_index3, const size_t& end_index3) { assert(I1 <= K1); assert(I1 <= K2); assert(I1 <= K3); assert(start_index1 < end_index1); assert(start_index2 < end_index2); assert(start_index3 < end_index3); assert(end_index1 < K1); assert(end_index2 < K2); assert(end_index3 < K3); //region_of_interes of basis matrices matrix< K1, R1, T_coeff >* u1 = new matrix< K1, R1, T_coeff >(); other.get_u1( *u1 ); for( size_t i1 = start_index1, i = 0; i1 < end_index1; ++i1, ++i ) { _u1->set_row( i, u1->get_row( i1 )); } matrix< K2, R2, T_coeff>* u2 = new matrix< K2, R2, T_coeff>(); other.get_u2( *u2 ); for( size_t i2 = start_index2, i = 0; i2 < end_index2; ++i2, ++i) { _u2->set_row( i, u2->get_row( i2 )); } matrix< K3, R3, T_coeff >* u3 = new matrix< K3, R3, T_coeff>(); other.get_u3( *u3 ); for( size_t i3 = start_index3, i = 0; i3 < end_index3; ++i3, ++i) { _u3->set_row( i, u3->get_row( i3 )); } other.get_core( _core ); cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING template< typename T > void VMML_TEMPLATE_CLASSNAME::export_to( std::vector< T >& data_ ) { data_.clear(); cast_members(); u1_const_iterator it = _u1->begin(), it_end = _u1->end(); for( ; it != it_end; ++it ) { data_.push_back( static_cast< T >( *it) ); } u2_const_iterator u2_it = _u2->begin(), u2_it_end = _u2->end(); for( ; u2_it != u2_it_end; ++u2_it ) { data_.push_back(static_cast< T >(*u2_it) ); } u3_const_iterator u3_it = _u3->begin(), u3_it_end = _u3->end(); for( ; u3_it != u3_it_end; ++u3_it ) { data_.push_back(static_cast< T >( *u3_it) ); } t3_core_iterator it_core = _core.begin(), it_core_end = _core.end(); for( ; it_core != it_core_end; ++it_core ) { data_.push_back(static_cast< T >( *it_core) ); } } VMML_TEMPLATE_STRING template< typename T > void VMML_TEMPLATE_CLASSNAME::import_from( const std::vector< T >& data_ ) { size_t i = 0; //iterator over data_ size_t data_size = (size_t) data_.size(); if ( data_size != SIZE ) VMMLIB_ERROR( "import_from: the input data must have the size R1xR2xR3 + R1xI1 + R2xI2 + R3xI3 ", VMMLIB_HERE ); u1_iterator it = _u1->begin(), it_end = _u1->end(); for( ; it != it_end; ++it, ++i ) { *it = static_cast< T >( data_.at(i)); } u2_iterator u2_it = _u2->begin(), u2_it_end = _u2->end(); for( ; u2_it != u2_it_end; ++u2_it, ++i ) { *u2_it = static_cast< T >( data_.at(i)); } u3_iterator u3_it = _u3->begin(), u3_it_end = _u3->end(); for( ; u3_it != u3_it_end; ++u3_it, ++i ) { *u3_it = static_cast< T >( data_.at(i)); } t3_core_iterator it_core = _core.begin(), it_core_end = _core.end(); for( ; it_core != it_core_end; ++it_core, ++i ) { *it_core = static_cast< T >( data_.at(i)); } cast_comp_members(); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::export_quantized_to( std::vector& data_out_ ) { enable_quantify_coeff(); //quantize tucker3 components (u1-u3 and core) size_t len_export_data = SIZE * sizeof(T_coeff) + 8*sizeof(T_internal); char * data = new char[ len_export_data ]; size_t end_data = 0; size_t len_t_comp = sizeof( T_internal ); //quantize basis matrices and copy min-max values #if CODE_ALL_U_MIN_MAX T_internal u1_min, u1_max, u2_min, u2_max, u3_min, u3_max; quantize_basis_matrices( u1_min, u1_max, u2_min, u2_max, u3_min, u3_max ); memcpy( data, &u1_min, len_t_comp ); end_data = len_t_comp; memcpy( data + end_data, &u1_max, len_t_comp ); end_data += len_t_comp; memcpy( data + end_data, &u2_min, len_t_comp ); end_data += len_t_comp; memcpy( data + end_data, &u2_max, len_t_comp ); end_data += len_t_comp; memcpy( data + end_data, &u3_min, len_t_comp ); end_data += len_t_comp; memcpy( data + end_data, &u3_max, len_t_comp ); end_data += len_t_comp; #else T_internal u_min, u_max; quantize_basis_matrices( u_min, u_max); memcpy( data, &u_min, len_t_comp ); end_data = len_t_comp; memcpy( data + end_data, &u_max, len_t_comp ); end_data += len_t_comp; #endif //quantize core and copy min-max values T_internal core_min, core_max; quantize_core( core_min, core_max ); memcpy( data + end_data, &core_min, len_t_comp ); end_data += len_t_comp; memcpy( data + end_data, &core_max, len_t_comp ); end_data += len_t_comp; //copy data for u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( data + end_data, _u1, len_u1 ); end_data += len_u1; //copy data for u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( data + end_data, _u2, len_u2 ); end_data += len_u2; //copy data for u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( data + end_data, _u3, len_u3 ); end_data += len_u3; //copy data for core size_t len_core_slice = R1 * R2 * sizeof( T_coeff ); for (size_t r3 = 0; r3 < R3; ++r3 ) { memcpy( data + end_data, _core.get_frontal_slice_fwd( r3 ), len_core_slice ); end_data += len_core_slice; } data_out_.clear(); for( size_t byte = 0; byte < len_export_data; ++byte ) { data_out_.push_back( data[byte] ); } delete[] data; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::import_quantized_from( const std::vector& data_in_ ) { enable_quantify_coeff(); size_t end_data = 0; size_t len_t_comp = sizeof( T_internal ); size_t len_export_data = SIZE * sizeof(T_coeff) + 8*sizeof(T_internal); unsigned char * data = new unsigned char[ len_export_data ]; for( size_t byte = 0; byte < len_export_data; ++byte ) { data[byte] = data_in_.at(byte); } //copy min and max values: u1_min, u1_max, u2_min, u2_max, u3_min, u3_max, core_min, core_max T_internal u1_min = 0; T_internal u1_max = 0; T_internal u2_min = 0; T_internal u2_max = 0; T_internal u3_min = 0; T_internal u3_max = 0; T_internal u_min = 0; T_internal u_max = 0; #if CODE_ALL_U_MIN_MAX memcpy( &u1_min, data, len_t_comp ); end_data = len_t_comp; memcpy( &u1_max, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &u2_min, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &u2_max, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &u3_min, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &u3_max, data + end_data, len_t_comp ); end_data += len_t_comp; #else memcpy( &u_min, data, len_t_comp ); end_data = len_t_comp; memcpy( &u_max, data + end_data, len_t_comp ); end_data += len_t_comp; #endif T_internal core_min = 0; T_internal core_max = 0; memcpy( &core_min, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &core_max, data + end_data, len_t_comp ); end_data += len_t_comp; //copy data to u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( _u1, data + end_data, len_u1 ); end_data += len_u1; //copy data to u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( _u2, data + end_data, len_u2 ); end_data += len_u2; //copy data to u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( _u3, data + end_data, len_u3 ); end_data += len_u3; //copy data to core size_t len_core_slice = R1 * R2 * sizeof( T_coeff ); front_core_slice_type* slice = new front_core_slice_type(); for (size_t r3 = 0; r3 < R3; ++r3 ) { memcpy( slice, data + end_data, len_core_slice ); _core.set_frontal_slice_fwd( r3, *slice ); end_data += len_core_slice; } delete slice; delete[] data; //dequantize tucker3 components (u1-u3 and core) #if CODE_ALL_U_MIN_MAX dequantize_basis_matrices( u1_min, u1_max, u2_min, u2_max, u3_min, u3_max ); #else dequantize_basis_matrices( u_min, u_max, u_min, u_max, u_min, u_max ); #endif dequantize_core( core_min, core_max ); #if 0 std::cout << "dequantized: " << std::endl << "u1-u3: " << std::endl << *_u1 << std::endl << *_u1_comp << std::endl << *_u2 << std::endl << *_u2_comp << std::endl << *_u3 << std::endl << *_u3_comp << std::endl << " core " << std::endl << _core << std::endl << " core_comp " << std::endl << _core_comp << std::endl; #endif } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::export_hot_quantized_to( std::vector& data_out_ ) { enable_quantify_hot(); //quantize tucker3 components (u1-u3 and core) size_t len_export_data = R1*R2*R3 + (R1*I1 + R2*I2 + R3*I3) * sizeof(T_coeff) + 4*sizeof(T_internal); char * data = new char[ len_export_data ]; size_t end_data = 0; size_t len_t_comp = sizeof( T_internal ); //quantize basis matrices and copy min-max values T_internal u_min, u_max; quantize_basis_matrices( u_min, u_max); memcpy( data, &u_min, len_t_comp ); end_data = len_t_comp; memcpy( data + end_data, &u_max, len_t_comp ); end_data += len_t_comp; //quantize core and copy min-max values T_internal core_min, core_max; quantize_core( core_min, core_max ); //memcpy( data + end_data, &core_min, len_t_comp ); end_data += len_t_comp; min_value is always zero in log quant memcpy( data + end_data, &core_max, len_t_comp ); end_data += len_t_comp; //copy first value of core tensor separately as a float memcpy( data + end_data, &_hottest_core_value, len_t_comp ); end_data += len_t_comp; //copy data for u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( data + end_data, _u1, len_u1 ); end_data += len_u1; //copy data for u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( data + end_data, _u2, len_u2 ); end_data += len_u2; //copy data for u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( data + end_data, _u3, len_u3 ); end_data += len_u3; //copy data for core size_t len_core_el = 1; //currently 1 bit for sign and 7 bit for values //Note: skip position (0,0,0) because highest energy core value is encoded separately //colume-first iteration unsigned char core_el; for (size_t r3 = 0; r3 < R3; ++r3 ) { for (size_t r2 = 0; r2 < R2; ++r2 ) { for (size_t r1 = 0; r1 < R1; ++r1 ) { core_el = (_core.at( r1, r2, r3 ) | (_signs.at( r1, r2, r3) * 0x80 )); /*std::cout << "value: " << int(_core.at( r1, r2, r3 )) << " bit " << int( core_el ) << " sign: " << int(_signs.at( r1, r2, r3)) << std::endl;*/ memcpy( data + end_data, &core_el, len_core_el ); ++end_data; } } } data_out_.clear(); for( size_t byte = 0; byte < len_export_data; ++byte ) { data_out_.push_back( data[byte] ); } delete[] data; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::import_hot_quantized_from( const std::vector& data_in_ ) { enable_quantify_hot(); size_t end_data = 0; size_t len_t_comp = sizeof( T_internal ); size_t len_export_data = R1*R2*R3 + (R1*I1 + R2*I2 + R3*I3) * sizeof(T_coeff) + 4*sizeof(T_internal); unsigned char * data = new unsigned char[ len_export_data ]; for( size_t byte = 0; byte < len_export_data; ++byte ) { data[byte] = data_in_.at(byte); } //copy min and max values: u1_min, u1_max, u2_min, u2_max, u3_min, u3_max, core_min, core_max T_internal u_min = 0; T_internal u_max = 0; memcpy( &u_min, data, len_t_comp ); end_data = len_t_comp; memcpy( &u_max, data + end_data, len_t_comp ); end_data += len_t_comp; T_internal core_min = 0; T_internal core_max = 0; //core_min is 0 //memcpy( &core_min, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &core_max, data + end_data, len_t_comp ); end_data += len_t_comp; //copy first value of core tensor separately as a float memcpy( &_hottest_core_value, data + end_data, len_t_comp ); end_data += len_t_comp; //copy data to u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( _u1, data + end_data, len_u1 ); end_data += len_u1; //copy data to u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( _u2, data + end_data, len_u2 ); end_data += len_u2; //copy data to u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( _u3, data + end_data, len_u3 ); end_data += len_u3; //copy data to core size_t len_core_el = 1; //currently 1 bit for sign and 7 bit for values unsigned char core_el; for (size_t r3 = 0; r3 < R3; ++r3 ) { for (size_t r2 = 0; r2 < R2; ++r2 ) { for (size_t r1 = 0; r1 < R1; ++r1 ) { memcpy( &core_el, data + end_data, len_core_el ); _signs.at( r1, r2, r3 ) = (core_el & 0x80)/128; _core.at( r1, r2, r3 ) = core_el & 0x7f ; ++end_data; } } } //std::cout << "signs: " << _signs << std::endl; //std::cout << "_core: " << _core << std::endl; delete[] data; //dequantize tucker3 components (u1-u3 and core) dequantize_basis_matrices( u_min, u_max, u_min, u_max, u_min, u_max ); dequantize_core( core_min, core_max ); #if 0 std::cout << "dequantized: " << std::endl << "u1-u3: " << std::endl << *_u1 << std::endl << *_u1_comp << std::endl << *_u2 << std::endl << *_u2_comp << std::endl << *_u3 << std::endl << *_u3_comp << std::endl << " core " << std::endl << _core << std::endl << " cold core comp " << std::endl << _cold_core_comp << std::endl << " core_comp " << std::endl << _core_comp << std::endl; #endif } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz() const { size_t counter = 0; counter += _u1_comp->nnz(); counter += _u2_comp->nnz(); counter += _u3_comp->nnz(); counter += _core_comp.nnz(); return counter; } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz( const T_value& threshold ) const { size_t counter = 0; counter += _u1_comp->nnz( threshold ); counter += _u2_comp->nnz( threshold ); counter += _u3_comp->nnz( threshold ); counter += _core_comp.nnz( threshold ); return counter; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::hosvd_on_eigs( const t3_type& data_ ) { //TODO: is not yet implemented //matricization along each mode (backward matricization after Lathauwer et al. 2000a) mode1_matricization_type* m_lateral = new mode1_matricization_type(); // -> u1 mode2_matricization_type* m_frontal = new mode2_matricization_type(); // -> u2 mode3_matricization_type* m_horizontal = new mode3_matricization_type(); //-> u3 data_.lateral_matricization( *m_lateral); data_.frontal_matricization( *m_frontal); data_.horizontal_matricization( *m_horizontal); //std::cout << "tensor input for tucker, method1: " << std::endl << tensor_ << std::endl; //2-mode PCA for each matricization A_n: (1) covariance matrix, (2) SVD //covariance matrix S_n for each matrizitation A_n matrix< I1, I1, T_internal >* s1 = new matrix< I1, I1, T_internal >(); matrix< I2, I2, T_internal >* s2 = new matrix< I2, I2, T_internal >(); matrix< I3, I3, T_internal >* s3 = new matrix< I3, I3, T_internal >(); s1->multiply( *m_lateral, transpose( *m_lateral)); s2->multiply( *m_frontal, transpose( *m_frontal)); s3->multiply( *m_horizontal, transpose( *m_horizontal)); /*std::cout << "covariance matrix s1: " << std::endl << s1 << std::endl << "covariance matrix s2: " << s2 << std::endl << "covariance matrix s3: " << s3 << std::endl;*/ //eigenvalue decomposition for each covariance matrix delete m_frontal; delete m_lateral; delete m_horizontal; delete s1; delete s2; delete s3; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME } // namespace vmml #endif vmmlib-1.0/include/vmmlib/exception.hpp0000644000175000017500000000320511674116156017624 0ustar shevekshevek#ifndef __VMMLIB__EXCEPTION__HPP__ #define __VMMLIB__EXCEPTION__HPP__ #include #include #include #include #include #include #define VMMLIB_HERE ( except_here( __FILE__, __LINE__ ) ) #ifdef VMMLIB_THROW_EXCEPTIONS #define VMMLIB_ERROR( desc, here ) throw( exception( desc, here ) ) #else #define VMMLIB_ERROR( desc, here ) error_noexcept( desc, here ) #endif namespace vmml { struct except_here { except_here( const char* file_, int line_ ) : file( file_ ), line( line_ ) {} const char* file; int line; }; // struct except_here inline void error_noexcept( const std::string& desc, const except_here& here ) { std::cerr << "vmmlib error at " << here.file << ":" << here.line << "\n" << desc << std::endl; assert( 0 ); } class exception : public std::exception { public: exception( const std::string& desc, const except_here& here ) : _description( desc ) , _here( here ) {} virtual ~exception() throw() {} virtual const char* what() const throw() { std::stringstream ss; ss << _here.file << "(" << _here.line << "): - " << _description << std::endl; return ss.str().c_str(); } protected: std::string _description; const except_here& _here; private: // disallow std ctor exception() : _here( *new except_here( "", 0 ) ){}; // disallow assignment operator virtual const exception& operator=( const exception& ){ return *this; } }; } // namespace stream_process #endif vmmlib-1.0/include/vmmlib/matrix_pseudoinverse.hpp0000644000175000017500000001122611674116156022107 0ustar shevekshevek#ifndef __VMML__MATRIX_PSEUDOINVERSE__HPP__ #define __VMML__MATRIX_PSEUDOINVERSE__HPP__ #include #include #include #include #include #include //#include /* *** computes the pseudo inverse of a non-square matrix *** - the pseudo inverse is computed by the help of SVD - the tolerance for the significant singular values is optionally set - implementation works only for matrices with more rows than columns or quadratic matrices. use a transposed input matrix for matrices with more columns than rows */ namespace vmml { // T - vmml::matrix<...> or compatible // Tinternal - float or double template< typename T, typename Tinternal = double > class compute_pseudoinverse { //TODO: Add restriction for matrices with M >= N only to template public: typedef typename T::value_type Texternal; typedef matrix< T::ROWS, T::COLS, Tinternal > matrix_mn_type; typedef matrix< T::COLS, T::ROWS, Tinternal > matrix_nm_type; typedef matrix< T::COLS, T::COLS, Tinternal > matrix_nn_type; typedef matrix< T::COLS, T::ROWS, Texternal > pinv_type; typedef vector< T::COLS, Tinternal > vec_n_type; typedef vector< T::ROWS, Tinternal > vec_m_type; typedef lapack_svd< T::ROWS, T::COLS, Tinternal > svd_type; typedef blas_dgemm< T::COLS, 1, T::ROWS, Tinternal > blas_type; struct tmp_matrices { matrix_mn_type U; vec_n_type sigmas; matrix_nn_type Vt; matrix_mn_type input; matrix_nm_type result; pinv_type pseudoinverse; matrix_nm_type tmp; }; /// do pseudo inverse for M >= N /// void operator()( const T& input, T& pseudoinverse_transposed, typename T::value_type tolerance = std::numeric_limits< typename T::value_type >::epsilon() ) { if ( T::ROWS < T::COLS ) { VMMLIB_ERROR( "matrix compute_pseudoinverse - number of matrix rows have to be greater or equal to number of matrix columns.", VMMLIB_HERE ); } if ( _work == 0 ) { _work = new tmp_matrices(); } // perform an SVD on the matrix to get the singular values svd_type svd; matrix_mn_type& U = _work->U; vec_n_type& sigmas = _work->sigmas; matrix_nn_type& Vt = _work->Vt; matrix_mn_type& in_data = _work->input; in_data.cast_from( input ); bool svd_ok = svd.compute( in_data, U, sigmas, Vt ); if ( ! svd_ok ) { VMMLIB_ERROR( "matrix compute_pseudoinverse - problem with lapack svd.", VMMLIB_HERE ); } /*std::cout << "U: " << std::endl << U << std::endl << " sigmas: " << std::endl << sigmas << std::endl << " Vt: " << std::endl << Vt << std::endl;*/ // get the number of significant singular, i.e., values which are above the tolerance value typename vector< T::COLS, Tinternal >::const_iterator it = sigmas.begin() , it_end = sigmas.end(); size_t num_sigmas = 0; for( ; it != it_end; ++it ) { if ( *it >= tolerance ) ++num_sigmas; else return; } //compute inverse with all the significant inverse singular values matrix_nm_type& result = _work->result; result.zero(); pinv_type& pseudoinverse = _work->pseudoinverse; matrix_nm_type& tmp = _work->tmp; sigmas.reciprocal_safe(); //double sigma_inv = 0; vec_n_type vt_i; vec_m_type u_i; blas_type blas_dgemm1; if ( num_sigmas >= 1 ) { it = sigmas.begin(); for( size_t i = 0 ; i < num_sigmas && it != it_end; ++it, ++i ) { Vt.get_row( i, vt_i); U.get_column( i, u_i ); blas_dgemm1.compute_vv_outer( vt_i, u_i, tmp ); tmp *= *it ; result += tmp; } pseudoinverse.cast_from( result ); pseudoinverse.transpose_to( pseudoinverse_transposed ); } else { pseudoinverse_transposed.zero(); //return matrix with zeros } } compute_pseudoinverse() : _work( 0 ) {} compute_pseudoinverse( const compute_pseudoinverse& cp ) : _work( 0 ) {} ~compute_pseudoinverse() { delete _work; } protected: tmp_matrices* _work; }; //end compute_pseudoinverse class }// end vmml namespace #endif vmmlib-1.0/include/vmmlib/blas_dgemm.hpp0000644000175000017500000002114311674116156017721 0ustar shevekshevek#ifndef __VMML__VMMLIB_BLAS_DGEMM__HPP__ #define __VMML__VMMLIB_BLAS_DGEMM__HPP__ #include #include #include #include /** * * a wrapper for blas's DGEMM routine. SUBROUTINE DGEMM(TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC) * .. Scalar Arguments .. DOUBLE PRECISION ALPHA,BETA INTEGER K,LDA,LDB,LDC,M,N CHARACTER TRANSA,TRANSB * .. * .. Array Arguments .. DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*) * .. * * Purpose * ======= * * DGEMM performs one of the matrix-matrix operations * * C := alpha*op( A )*op( B ) + beta*C, * * where op( X ) is one of * * op( X ) = X or op( X ) = X**T, * * alpha and beta are scalars, and A, B and C are matrices, with op( A ) * an m by k matrix, op( B ) a k by n matrix and C an m by n matrix. * * * more information in: http://www.netlib.org/blas/dgemm.f * or http://www.netlib.org/clapack/cblas/dgemm.c ** */ namespace vmml { namespace blas { #if 0 /* Subroutine */ void cblas_dgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K, double alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc); #endif template< typename float_t > struct dgemm_params { CBLAS_ORDER order; CBLAS_TRANSPOSE trans_a; CBLAS_TRANSPOSE trans_b; blas_int m; blas_int n; blas_int k; float_t alpha; float_t* a; blas_int lda; //leading dimension of input array matrix left float_t* b; blas_int ldb; //leading dimension of input array matrix right float_t beta; float_t* c; blas_int ldc; //leading dimension of output array matrix right friend std::ostream& operator << ( std::ostream& os, const dgemm_params< float_t >& p ) { os << " (1)\torder " << p.order << std::endl << " (2)\ttrans_a " << p.trans_a << std::endl << " (3)\ttrans_b " << p.trans_b << std::endl << " (4)\tm " << p.m << std::endl << " (6)\tn " << p.n << std::endl << " (5)\tk " << p.k << std::endl << " (7)\talpha " << p.alpha << std::endl << " (8)\ta " << p.a << std::endl << " (9)\tlda " << p.lda << std::endl << " (10)\tb " << p.b << std::endl << " (11)\tldb " << p.ldb << std::endl << " (12)\tbeta " << p.beta << std::endl << " (13)\tc " << p.c << std::endl << " (14)\tldc " << p.ldc << std::endl << std::endl; return os; } }; template< typename float_t > inline void dgemm_call( dgemm_params< float_t >& p ) { VMMLIB_ERROR( "not implemented for this type.", VMMLIB_HERE ); } template<> inline void dgemm_call( dgemm_params< float >& p ) { //std::cout << "calling blas sgemm (single precision) " << std::endl; cblas_sgemm( p.order, p.trans_a, p.trans_b, p.m, p.n, p.k, p.alpha, p.a, p.lda, p.b, p.ldb, p.beta, p.c, p.ldc ); } template<> inline void dgemm_call( dgemm_params< double >& p ) { //std::cout << "calling blas dgemm (double precision) " << std::endl; cblas_dgemm( p.order, p.trans_a, p.trans_b, p.m, p.n, p.k, p.alpha, p.a, p.lda, p.b, p.ldb, p.beta, p.c, p.ldc ); } } // namespace blas template< size_t M, size_t K, size_t N, typename float_t > struct blas_dgemm { typedef matrix< M, K, float_t > matrix_left_t; typedef matrix< K, M, float_t > matrix_left_t_t; typedef matrix< K, N, float_t > matrix_right_t; typedef matrix< N, K, float_t > matrix_right_t_t; typedef matrix< M, N, float_t > matrix_out_t; typedef vector< M, float_t > vector_left_t; typedef vector< N, float_t > vector_right_t; blas_dgemm(); ~blas_dgemm() {}; bool compute( const matrix_left_t& A_, const matrix_right_t& B_, matrix_out_t& C_ ); bool compute( const matrix_left_t& A_, matrix_out_t& C_ ); bool compute_t( const matrix_right_t& B_, matrix_out_t& C_ ); bool compute_bt( const matrix_left_t& A_, const matrix_right_t_t& Bt_, matrix_out_t& C_ ); bool compute_t( const matrix_left_t_t& A_, const matrix_right_t_t& B_, matrix_out_t& C_ ); bool compute_vv_outer( const vector_left_t& A_, const vector_right_t& B_, matrix_out_t& C_ ); blas::dgemm_params< float_t > p; const blas::dgemm_params< float_t >& get_params(){ return p; }; }; // struct blas_dgemm template< size_t M, size_t K, size_t N, typename float_t > blas_dgemm< M, K, N, float_t >::blas_dgemm() { p.order = CblasColMajor; // p.trans_a = CblasNoTrans; p.trans_b = CblasNoTrans; p.m = M; p.n = N; p.k = K; p.alpha = 1; p.a = 0; p.lda = M; p.b = 0; p.ldb = K; //no transpose p.beta = 1; p.c = 0; p.ldc = M; } template< size_t M, size_t K, size_t N, typename float_t > bool blas_dgemm< M, K, N, float_t >::compute( const matrix_left_t& A_, const matrix_right_t& B_, matrix_out_t& C_ ) { // blas needs non-const data matrix_left_t* AA = new matrix_left_t( A_ ); matrix_right_t* BB = new matrix_right_t( B_ ); C_.zero(); p.a = AA->array; p.b = BB->array; p.c = C_.array; blas::dgemm_call< float_t >( p ); //std::cout << p << std::endl; //debug delete AA; delete BB; return true; } template< size_t M, size_t K, size_t N, typename float_t > bool blas_dgemm< M, K, N, float_t >::compute( const matrix_left_t& A_, matrix_out_t& C_ ) { // blas needs non-const data matrix_left_t* AA = new matrix_left_t( A_ ); C_.zero(); p.trans_b = CblasTrans; p.a = AA->array; p.b = AA->array; p.ldb = N; p.c = C_.array; blas::dgemm_call< float_t >( p ); //std::cout << p << std::endl; //debug delete AA; return true; } template< size_t M, size_t K, size_t N, typename float_t > bool blas_dgemm< M, K, N, float_t >::compute_t( const matrix_right_t& B_, matrix_out_t& C_ ) { // blas needs non-const data matrix_right_t* BB = new matrix_right_t( B_ ); C_.zero(); p.trans_a = CblasTrans; p.a = BB->array; p.b = BB->array; p.lda = K; p.c = C_.array; blas::dgemm_call< float_t >( p ); //std::cout << p << std::endl; //debug delete BB; return true; } template< size_t M, size_t K, size_t N, typename float_t > bool blas_dgemm< M, K, N, float_t >::compute_bt( const matrix_left_t& A_, const matrix_right_t_t& Bt_, matrix_out_t& C_ ) { // blas needs non-const data matrix_left_t* AA = new matrix_left_t( A_ ); matrix_right_t_t* BB = new matrix_right_t_t( Bt_ ); C_.zero(); p.trans_b = CblasTrans; p.a = AA->array; p.b = BB->array; p.c = C_.array; p.ldb = N; blas::dgemm_call< float_t >( p ); //std::cout << p << std::endl; //debug delete AA; delete BB; return true; } template< size_t M, size_t K, size_t N, typename float_t > bool blas_dgemm< M, K, N, float_t >::compute_t( const matrix_left_t_t& At_, const matrix_right_t_t& Bt_, matrix_out_t& C_ ) { // blas needs non-const data matrix_left_t_t* AA = new matrix_left_t_t( At_ ); matrix_right_t_t* BB = new matrix_right_t_t( Bt_ ); C_.zero(); p.trans_a = CblasTrans; p.trans_b = CblasTrans; p.a = AA->array; p.b = BB->array; p.c = C_.array; p.ldb = N; p.lda = K; blas::dgemm_call< float_t >( p ); //std::cout << p << std::endl; //debug delete AA; delete BB; return true; } template< size_t M, size_t K, size_t N, typename float_t > bool blas_dgemm< M, K, N, float_t >::compute_vv_outer( const vector_left_t& A_, const vector_right_t& B_, matrix_out_t& C_ ) { // blas needs non-const data vector_left_t* AA = new vector_left_t( A_ ); vector_right_t* BB = new vector_right_t( B_ ); C_.zero(); p.trans_a = CblasTrans; p.a = AA->array; p.b = BB->array; p.c = C_.array; p.lda = K; blas::dgemm_call< float_t >( p ); //std::cout << p << std::endl; //debug delete AA; delete BB; return true; } } // namespace vmml #endif vmmlib-1.0/include/vmmlib/blas_types.hpp0000644000175000017500000000040711674116156017774 0ustar shevekshevek#ifndef __VMML__BLAS_TYPES__HPP__ #define __VMML__BLAS_TYPES__HPP__ namespace vmml { namespace blas { #ifdef __APPLE__ typedef int blas_int; #else typedef int blas_int; #endif } // namespace blas } // namespace vmml #endif vmmlib-1.0/include/vmmlib/lapack_includes.hpp0000644000175000017500000000044111674116156020746 0ustar shevekshevek#ifndef __VMML__LAPACK_INCLUDES__HPP__ #define __VMML__LAPACK_INCLUDES__HPP__ #ifdef __APPLE__ #include #else extern "C" { #include #include } #endif #endif /* __VMML__LAPACK_INCLUDES__HPP__ */ vmmlib-1.0/include/vmmlib/vmmlib.hpp0000644000175000017500000000123111674116156017111 0ustar shevekshevek/* * VMMLib - Vector & Matrix Math Lib * * @author Jonas Boesch * @author Stefan Eilemann * @author Renato Pajarola * @author Susanne Suter * @author Philipp Schlegel * @author Daniel Pfeifer * @author David H. Eberly ( Wild Magic ) * @author Andrew Willmott ( VL ) * * @license revised BSD license, check LICENSE * * parts of the source code of VMMLib were inspired by David Eberly's * Wild Magic and Andrew Willmott's VL. * */ #ifndef __VMML__VMMLIB__HPP__ #define __VMML__VMMLIB__HPP__ #include #include #include #include #include #endif vmmlib-1.0/include/vmmlib/vector_traits.hpp0000644000175000017500000000176511674116156020527 0ustar shevekshevek// Copyright (c) 2010 Daniel Pfeifer #ifndef __VMML_VECTOR_TRAITS_HPP__ #define __VMML_VECTOR_TRAITS_HPP__ #include #include namespace boost { namespace la { template struct vector_traits > { typedef vmml::vector vector_type; static const int dim = M; typedef T scalar_type; template static scalar_type r(const vector_type& v) { BOOST_STATIC_ASSERT(I >= 0); BOOST_STATIC_ASSERT(I < dim); return v.array[I]; } template static scalar_type& w(vector_type& v) { BOOST_STATIC_ASSERT(I >= 0); BOOST_STATIC_ASSERT(I < dim); return v.array[I]; } static scalar_type ir(int i, const vector_type& v) { BOOST_ASSERT(i >= 0); BOOST_ASSERT(i < dim); return v.array[i]; } static scalar_type& iw(int i, vector_type& v) { BOOST_ASSERT(i >= 0); BOOST_ASSERT(i < dim); return v.array[i]; } }; } // namespace la } // namespace boost #endif /* VMML_VECTOR_TRAITS_HPP */ vmmlib-1.0/include/vmmlib/matrix_traits.hpp0000644000175000017500000000254511674116156020526 0ustar shevekshevek//Copyright (c) 2010 Daniel Pfeifer #ifndef __VMML_MATRIX_TRAITS_HPP__ #define __VMML_MATRIX_TRAITS_HPP__ #include #include namespace boost { namespace la { template struct matrix_traits > { typedef vmml::matrix matrix_type; static const int rows = M; static const int cols = N; typedef T scalar_type; template static scalar_type r(const matrix_type& m) { BOOST_STATIC_ASSERT(Row >= 0); BOOST_STATIC_ASSERT(Row < rows); BOOST_STATIC_ASSERT(Col >= 0); BOOST_STATIC_ASSERT(Col < cols); return m.at(Col, Row); } template static scalar_type& w(matrix_type& m) { BOOST_STATIC_ASSERT(Row >= 0); BOOST_STATIC_ASSERT(Row < rows); BOOST_STATIC_ASSERT(Col >= 0); BOOST_STATIC_ASSERT(Col < cols); return m.at(Col, Row); } static scalar_type ir(int row, int col, const matrix_type& m) { BOOST_ASSERT(row >= 0); BOOST_ASSERT(row < rows); BOOST_ASSERT(col >= 0); BOOST_ASSERT(col < cols); return m.at(col, row); } static scalar_type& iw(int row, int col, matrix_type& m) { BOOST_ASSERT(row >= 0); BOOST_ASSERT(row < rows); BOOST_ASSERT(col >= 0); BOOST_ASSERT(col < cols); return m.at(col, row); } }; } // namespace la } // namespace boost #endif /* VMML_MATRIX_TRAITS_HPP */ vmmlib-1.0/include/vmmlib/tucker3_importer.hpp0000644000175000017500000002676411674116156021146 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * * Import tool for Tucker3 tensor and quantized Tucker3 tensor * */ #ifndef __VMML__TUCK3_IMPORTER__HPP__ #define __VMML__TUCK3_IMPORTER__HPP__ #include /* FIXME: * * - T_internal */ namespace vmml { template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value = float, typename T_coeff = float > class tucker3_importer { public: typedef float T_internal; //FIXME! should match with tucker3 tensor typedef tucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > tucker3_type; typedef qtucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > qtucker3_type; typedef tensor3< R1, R2, R3, T_coeff > t3_core_type; typedef typename t3_core_type::iterator t3_core_iterator; typedef typename t3_core_type::const_iterator t3_core_const_iterator; typedef matrix< I1, R1, T_coeff > u1_type; typedef typename u1_type::iterator u1_iterator; typedef typename u1_type::const_iterator u1_const_iterator; typedef matrix< I2, R2, T_coeff > u2_type; typedef typename u2_type::iterator u2_iterator; typedef typename u2_type::const_iterator u2_const_iterator; typedef matrix< I3, R3, T_coeff > u3_type; typedef typename u3_type::iterator u3_iterator; typedef typename u3_type::const_iterator u3_const_iterator; typedef matrix< R1, R2, T_coeff > front_core_slice_type; //fwd: forward cylcling (after kiers et al., 2000) typedef tensor3< R1, R2, R3, char > t3_core_signs_type; template< typename T > static void import_from( const std::vector< T >& data_, tucker3_type& tuck3_data_ ); //previous version, but works only with 16bit quantization static void import_quantized_from( const std::vector& data_in_, qtucker3_type& tuck3_data_ ); //use this version, works with a better quantization for the core tensor: //logarithmic quantization and separate high energy core vale //suitable for voxelwise reconstruction static void import_hot_quantized_from( const std::vector& data_in_, qtucker3_type& tuck3_data_ ); //use this version for the ttm export/import (core: backward cyclic), without plain hot value static void import_ttm_quantized_from( const std::vector& data_in_, qtucker3_type& tuck3_data_ ); }; //end tucker3 importer class #define VMML_TEMPLATE_STRING template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value, typename T_coeff > #define VMML_TEMPLATE_CLASSNAME tucker3_importer< R1, R2, R3, I1, I2, I3, T_value, T_coeff > VMML_TEMPLATE_STRING template< typename T > void VMML_TEMPLATE_CLASSNAME::import_from( const std::vector< T >& data_, tucker3_type& tuck3_data_ ) { size_t i = 0; //iterator over data_ size_t data_size = (size_t) data_.size(); if ( data_size != tuck3_data_.SIZE ) VMMLIB_ERROR( "import_from: the input data must have the size R1xR2xR3 + R1xI1 + R2xI2 + R3xI3 ", VMMLIB_HERE ); u1_type* u1 = new u1_type; u2_type* u2 = new u2_type; u3_type* u3 = new u3_type; t3_core_type core; tuck3_data_.get_u1( *u1 ); tuck3_data_.get_u2( *u2 ); tuck3_data_.get_u3( *u3 ); tuck3_data_.get_core( core ); u1_iterator it = u1->begin(), it_end = u1->end(); for( ; it != it_end; ++it, ++i ) { *it = static_cast< T >( data_.at(i)); } u2_iterator u2_it = u2->begin(), u2_it_end = u2->end(); for( ; u2_it != u2_it_end; ++u2_it, ++i ) { *u2_it = static_cast< T >( data_.at(i)); } u3_iterator u3_it = u3->begin(), u3_it_end = u3->end(); for( ; u3_it != u3_it_end; ++u3_it, ++i ) { *u3_it = static_cast< T >( data_.at(i)); } t3_core_iterator it_core = core.begin(), it_core_end = core.end(); for( ; it_core != it_core_end; ++it_core, ++i ) { *it_core = static_cast< T >( data_.at(i)); } tuck3_data_.set_u1( *u1 ); tuck3_data_.set_u2( *u2 ); tuck3_data_.set_u3( *u3 ); tuck3_data_.set_core( core ); tuck3_data_.cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::import_quantized_from( const std::vector& data_in_, qtucker3_type& tuck3_data_ ) { size_t end_data = 0; size_t len_t_comp = sizeof( T_internal ); size_t len_export_data = tuck3_data_.SIZE * sizeof(T_coeff) + 8 * len_t_comp; unsigned char * data = new unsigned char[ len_export_data ]; for( size_t byte = 0; byte < len_export_data; ++byte ) { data[byte] = data_in_.at(byte); } //copy min and max values: u1_min, u1_max, u2_min, u2_max, u3_min, u3_max, core_min, core_max T_internal u_min = 0; T_internal u_max = 0; memcpy( &u_min, data, len_t_comp ); end_data = len_t_comp; memcpy( &u_max, data + end_data, len_t_comp ); end_data += len_t_comp; T_internal core_min = 0; T_internal core_max = 0; memcpy( &core_min, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &core_max, data + end_data, len_t_comp ); end_data += len_t_comp; u1_type* u1 = new u1_type; u2_type* u2 = new u2_type; u3_type* u3 = new u3_type; t3_core_type core; tuck3_data_.get_u1( *u1 ); tuck3_data_.get_u2( *u2 ); tuck3_data_.get_u3( *u3 ); tuck3_data_.get_core( core ); //copy data to u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( *u1, data + end_data, len_u1 ); end_data += len_u1; //copy data to u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( *u2, data + end_data, len_u2 ); end_data += len_u2; //copy data to u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( *u3, data + end_data, len_u3 ); end_data += len_u3; //copy data to core size_t len_core_slice = R1 * R2 * sizeof( T_coeff ); front_core_slice_type* slice = new front_core_slice_type(); for (size_t r3 = 0; r3 < R3; ++r3 ) { memcpy( slice, data + end_data, len_core_slice ); core.set_frontal_slice_fwd( r3, *slice ); end_data += len_core_slice; } tuck3_data_.set_u1( *u1 ); tuck3_data_.set_u2( *u2 ); tuck3_data_.set_u3( *u3 ); tuck3_data_.set_core( core ); //dequantize tucker3 components (u1-u3 and core) tuck3_data_.dequantize_basis_matrices( u_min, u_max, u_min, u_max, u_min, u_max ); tuck3_data_.dequantize_core( core_min, core_max ); delete slice; delete[] data; delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::import_hot_quantized_from( const std::vector& data_in_, qtucker3_type& tuck3_data_ ) { tuck3_data_.enable_quantify_hot(); size_t end_data = 0; size_t len_t_comp = sizeof( T_internal ); size_t len_export_data = R1*R2*R3 + (R1*I1 + R2*I2 + R3*I3) * sizeof(T_coeff) + 4 * len_t_comp; unsigned char * data = new unsigned char[ len_export_data ]; for( size_t byte = 0; byte < len_export_data; ++byte ) { data[byte] = data_in_.at(byte); } //copy min and max values: u1_min, u1_max, u2_min, u2_max, u3_min, u3_max, core_min, core_max T_internal u_min = 0; T_internal u_max = 0; memcpy( &u_min, data, len_t_comp ); end_data = len_t_comp; memcpy( &u_max, data + end_data, len_t_comp ); end_data += len_t_comp; T_internal core_min = 0; T_internal core_max = 0; //core_min is 0 //memcpy( &core_min, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &core_max, data + end_data, len_t_comp ); end_data += len_t_comp; //copy first value of core tensor separately as a float T_internal hottest_value = 0; memcpy( &hottest_value, data + end_data, len_t_comp ); end_data += len_t_comp; tuck3_data_.set_hottest_value( hottest_value ); u1_type* u1 = new u1_type; u2_type* u2 = new u2_type; u3_type* u3 = new u3_type; t3_core_type core; t3_core_signs_type signs; tuck3_data_.get_u1( *u1 ); tuck3_data_.get_u2( *u2 ); tuck3_data_.get_u3( *u3 ); tuck3_data_.get_core( core ); tuck3_data_.get_core_signs( signs ); //copy data to u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( *u1, data + end_data, len_u1 ); end_data += len_u1; //copy data to u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( *u2, data + end_data, len_u2 ); end_data += len_u2; //copy data to u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( *u3, data + end_data, len_u3 ); end_data += len_u3; //copy data to core size_t len_core_el = 1; //currently 1 bit for sign and 7 bit for values unsigned char core_el; for (size_t r3 = 0; r3 < R3; ++r3 ) { for (size_t r2 = 0; r2 < R2; ++r2 ) { for (size_t r1 = 0; r1 < R1; ++r1 ) { memcpy( &core_el, data + end_data, len_core_el ); signs.at( r1, r2, r3 ) = (core_el & 0x80)/128; core.at( r1, r2, r3 ) = core_el & 0x7f ; ++end_data; } } } tuck3_data_.set_u1( *u1 ); tuck3_data_.set_u2( *u2 ); tuck3_data_.set_u3( *u3 ); tuck3_data_.set_core( core ); tuck3_data_.set_core_signs( signs ); //dequantize tucker3 components (u1-u3 and core) tuck3_data_.dequantize_basis_matrices( u_min, u_max, u_min, u_max, u_min, u_max ); tuck3_data_.dequantize_core( core_min, core_max ); delete[] data; delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::import_ttm_quantized_from( const std::vector& data_in_, qtucker3_type& tuck3_data_ ) { tuck3_data_.enable_quantify_log(); size_t end_data = 0; size_t len_t_comp = sizeof( T_internal ); size_t len_export_data = R1*R2*R3 + (R1*I1 + R2*I2 + R3*I3) * sizeof(T_coeff) + 3 * len_t_comp; unsigned char * data = new unsigned char[ len_export_data ]; for( size_t byte = 0; byte < len_export_data; ++byte ) { data[byte] = data_in_.at(byte); } //copy min and max values: u1_min, u1_max, u2_min, u2_max, u3_min, u3_max, core_min, core_max T_internal u_min = 0; T_internal u_max = 0; memcpy( &u_min, data, len_t_comp ); end_data = len_t_comp; memcpy( &u_max, data + end_data, len_t_comp ); end_data += len_t_comp; T_internal core_min = 0; T_internal core_max = 0; //core_min is 0 //memcpy( &core_min, data + end_data, len_t_comp ); end_data += len_t_comp; memcpy( &core_max, data + end_data, len_t_comp ); end_data += len_t_comp; u1_type* u1 = new u1_type; u2_type* u2 = new u2_type; u3_type* u3 = new u3_type; t3_core_type core; t3_core_signs_type signs; tuck3_data_.get_u1( *u1 ); tuck3_data_.get_u2( *u2 ); tuck3_data_.get_u3( *u3 ); tuck3_data_.get_core( core ); tuck3_data_.get_core_signs( signs ); //copy data to u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( *u1, data + end_data, len_u1 ); end_data += len_u1; //copy data to u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( *u2, data + end_data, len_u2 ); end_data += len_u2; //copy data to u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( *u3, data + end_data, len_u3 ); end_data += len_u3; //copy data to core size_t len_core_el = 1; //currently 1 bit for sign and 7 bit for values //backward cyclic after lathauwer et al. unsigned char core_el; for (size_t r2 = 0; r2 < R2; ++r2 ) { for (size_t r3 = 0; r3 < R3; ++r3 ) { for (size_t r1 = 0; r1 < R1; ++r1 ) { memcpy( &core_el, data + end_data, len_core_el ); signs.at( r1, r2, r3 ) = (core_el & 0x80)/128; core.at( r1, r2, r3 ) = core_el & 0x7f ; ++end_data; } } } //std::cout << "signs: " << _signs << std::endl; //std::cout << "_core: " << _core << std::endl; delete[] data; tuck3_data_.set_u1( *u1 ); tuck3_data_.set_u2( *u2 ); tuck3_data_.set_u3( *u3 ); tuck3_data_.set_core( core ); tuck3_data_.set_core_signs( signs ); //dequantize tucker3 components (u1-u3 and core) tuck3_data_.dequantize_basis_matrices( u_min, u_max, u_min, u_max, u_min, u_max ); tuck3_data_.dequantize_core( core_min, core_max ); delete u1; delete u2; delete u3; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME } // namespace vmml #endif vmmlib-1.0/include/vmmlib/vector.hpp0000644000175000017500000011252111674116156017132 0ustar shevekshevek#ifndef __VMML__VECTOR__HPP__ #define __VMML__VECTOR__HPP__ #include #include #include #include #include #include #include #include #include #include #include namespace vmml { template< size_t M, typename T = float > class vector { public: typedef T value_type; typedef T* pointer; typedef T& reference; typedef T* iterator; typedef const T* const_iterator; typedef std::reverse_iterator< iterator > reverse_iterator; typedef std::reverse_iterator< const_iterator > const_reverse_iterator; static const size_t DIMENSION = M; // iterators inline iterator begin(); inline iterator end(); inline const_iterator begin() const; inline const_iterator end() const; inline reverse_iterator rbegin(); inline reverse_iterator rend(); inline const_reverse_iterator rbegin() const; inline const_reverse_iterator rend() const; #ifndef VMMLIB_NO_CONVERSION_OPERATORS // conversion operators inline operator T*(); inline operator const T*() const; #else inline T& operator[]( size_t index ); inline const T& operator[]( size_t index ) const; #endif // accessors inline T& operator()( size_t index ); inline const T& operator()( size_t index ) const; #if 0 inline T& operator[]( size_t index ); inline const T& operator[]( size_t index ) const; #endif inline T& at( size_t index ); inline const T& at( size_t index ) const; // element accessors for M <= 4; inline T& x(); inline T& y(); inline T& z(); inline T& w(); inline const T& x() const; inline const T& y() const; inline const T& z() const; inline const T& w() const; // pixel color element accessors for M<= 4 inline T& r(); inline T& g(); inline T& b(); inline T& a(); inline const T& r() const; inline const T& g() const; inline const T& b() const; inline const T& a() const; bool operator==( const vector& other ) const; bool operator!=( const vector& other ) const; bool equals( const vector& other, T tolerance = std::numeric_limits< T >::epsilon() ) const; bool operator<( const vector& other ) const; // remember kids: c_arrays are dangerous and evil! const vector& operator=( const T* c_array ); T operator=( T filler ); const vector& operator=( const vector& other ); // returns void to avoid 'silent' loss of precision when chaining template< typename U > void operator=( const vector< M, U >& other ); // to-homogenous-coordinates assignment operator // non-chainable because of sfinae template< size_t N > typename enable_if< N == M - 1 >::type* operator=( const vector< N, T >& source_ ); // from-homogenous-coordinates assignment operator // non-chainable because of sfinae template< size_t N > typename enable_if< N == M + 1 >::type* operator=( const vector< N, T >& source_ ); vector operator*( const vector& other ) const; vector operator/( const vector& other ) const; vector operator+( const vector& other ) const; vector operator-( const vector& other ) const; void operator*=( const vector& other ); void operator/=( const vector& other ); void operator+=( const vector& other ); void operator-=( const vector& other ); vector operator*( const T other ) const; vector operator/( const T other ) const; vector operator+( const T other ) const; vector operator-( const T other ) const; void operator*=( const T other ); void operator/=( const T other ); void operator+=( const T other ); void operator-=( const T other ); vector operator-() const; const vector& negate(); // constructors vector() {}; // std ctor - WARNING: NO INITIALIZATION vector( const T& a ); // sets all components to a; vector( const T& x, const T& y ); vector( const T& x, const T& y, const T& z ); vector( const T& x, const T& y, const T& z, const T& w ); // initializes the first M-1 values from vector_, the last from last_ vector( const vector< M-1, T >& vector_, T last_ ); vector( const T* values ); // vec< M > with homogeneous coordinates <-> vec< M-1 > conversion ctor // to-homogenous-coordinates ctor template< size_t N > vector( const vector< N, T >& source_, typename enable_if< N == M - 1 >::type* = 0 ); // from-homogenous-coordinates ctor template< size_t N > vector( const vector< N, T >& source_, typename enable_if< N == M + 1 >::type* = 0 ); template< typename U > vector( const vector< M, U >& source_ ); void set( T a ); // sets all components to a; void set( const vector< M-1, T >& v, T a ); // sets the first few components to a certain value void set( T x, T y ); void set( T x, T y, T z ); void set( T x, T y, T z, T w ); template< typename input_iterator_t > void iter_set( input_iterator_t begin_, input_iterator_t end_ ); // compute the cross product of two vectors // note: there's also a free function: // vector<> cross( const vector<>, const vector<> ) // result = vec1.cross( vec2 ) => retval result = vec1 x vec2 template< typename TT > inline vector cross( const vector< M, TT >& rhs, typename enable_if< M == 3, TT >::type* = 0 ) const; // result.cross( vec1, vec2 ) => (this) = vec1 x vec2 template< typename TT > void cross( const vector< M, TT >& a, const vector< M, TT >& b, typename enable_if< M == 3, TT >::type* = 0 ); // compute the dot product of two vectors // note: there's also a free function: // T dot( const vector<>, const vector<> ); inline T dot( const vector& other ) const; // normalize the vector // note: there's also a free function: // vector<> normalize( const vector<> ); inline T normalize(); //sets all matrix values with random values //remember to set srand( seed ); //if seed is set to -1, srand( seed ) was set outside set_random //otherwise srand( seed ) will be called with the given seed void set_random( int seed = -1 ); inline T length() const; inline T squared_length() const; inline T distance( const vector& other_vector_ ) const; inline T squared_distance( const vector& other_vector_ ) const; template< typename TT > vector< 3, T > rotate( const T theta, vector< M, TT > axis, typename enable_if< M == 3, TT >::type* = 0 ) const; // right hand system, CCW triangle // (*this) = normal of v0,v1,v2 void compute_normal( const vector& v0, const vector& v1, const vector& v2 ); // retval = normal of (this), v1, v2 vector compute_normal( const vector& v1, const vector& v2 ) const; template< size_t N > void get_sub_vector( vector< N, T >& sub_v_, size_t offset = 0, typename enable_if< M >= N >::type* = 0 ); template< size_t N > vector< N, T >& get_sub_vector( size_t offset = 0, typename enable_if< M >= N >::type* = 0 ); template< size_t N > const vector< N, T >& get_sub_vector( size_t offset = 0, typename enable_if< M >= N >::type* = 0 ) const; // sphere functions - sphere layout: center xyz, radius w template< typename TT > inline vector< 3, T > project_point_onto_sphere( const vector< 3, TT >& point, typename enable_if< M == 4, TT >::type* = 0 ) const; // returns a negative distance if the point lies in the sphere template< typename TT > inline T distance_to_sphere( const vector< 3, TT >& point, typename enable_if< M == 4, TT >::type* = 0 ) const; // plane functions - plane layout; normal xyz, distance w template< typename TT > inline T distance_to_plane( const vector< 3, TT >& point, typename enable_if< M == 4, TT >::type* = 0 ) const; template< typename TT > inline vector< 3, T > project_point_onto_plane( const vector< 3, TT >& point, typename enable_if< M == 4, TT >::type* = 0 ) const; // returns the index of the minimal resp. maximal value in the vector size_t find_min_index() const; size_t find_max_index() const; // returns the index of the minimal resp. maximal value in the vector size_t find_abs_min_index() const; size_t find_abs_max_index() const; // returns minimal resp. maximal value in the vector T& find_min(); T& find_max(); const T& find_min() const; const T& find_max() const; void clamp( const T& min = 0.0, const T& max = 1.0 ); template< typename TT > void scale_to( vector< M, TT >& scaled_vector, T min_value = -1.0, T max_value = 1.0 ) const; inline static size_t size(); // returns M bool is_unit_vector() const; // perturbs each component by randomly + or - the perturbation parameter void perturb( T perturbation = 0.0001 ); void sqrt_elementwise(); double norm() const; //l2 norm // computes the reciprocal value for each component, x = 1/x; // WARNING: might result in nans if division by 0! void reciprocal(); // computes the reciprocal value for each component, x = 1/x; // checks every component for 0, sets to max value if zero. void reciprocal_safe(); template< typename TT > void cast_from( const vector< M, TT >& other ); size_t nnz() const; // test each component of the vector for isnan and isinf inline bool is_valid() const; friend std::ostream& operator<< ( std::ostream& os, const vector& vector_ ) { #ifdef EQFABRIC_API_H const std::ios::fmtflags flags = os.flags(); const int prec = os.precision(); os.setf( std::ios::right, std::ios::adjustfield ); os.precision( 5 ); os << "[ "; for( size_t index = 0; index < M; ++index ) os << std::setw(10) << vector_.at( index ) << " "; os << "]"; os.precision( prec ); os.setf( flags ); #else os << "("; size_t index = 0; for( ; index < M - 1; ++index ) { os << vector_.at( index ) << ", "; } os << vector_.at( index ) << ") "; #endif return os; } // storage VMMLIB_ALIGN( T array[ M ] ); ; // Vector3 defaults static const vector FORWARD; static const vector BACKWARD; static const vector UP; static const vector DOWN; static const vector LEFT; static const vector RIGHT; static const vector ONE; static const vector ZERO; // Unit vectors static const vector UNIT_X; static const vector UNIT_Y; static const vector UNIT_Z; }; // class vector // // typedefs and statics // #ifndef VMMLIB_NO_TYPEDEFS typedef vector< 2, float > vec2f; typedef vector< 2, double > vec2d; typedef vector< 3, float > vec3f; typedef vector< 3, double > vec3d; typedef vector< 4, float > vec4f; typedef vector< 4, double > vec4d; #endif template< size_t M, typename T > const vector< M, T > vector< M, T >::FORWARD( 0, 0, -1 ); template< size_t M, typename T > const vector< M, T > vector< M, T >::BACKWARD( 0, 0, 1 ); template< size_t M, typename T > const vector< M, T > vector< M, T >::UP( 0, 1, 0 ); template< size_t M, typename T > const vector< M, T > vector< M, T >::DOWN( 0, -1, 0 ); template< size_t M, typename T > const vector< M, T > vector< M, T >::LEFT( -1, 0, 0 ); template< size_t M, typename T > const vector< M, T > vector< M, T >::RIGHT( 1, 0, 0 ); template< size_t M, typename T > const vector< M, T > vector< M, T >::ONE( static_cast< T >( 1 )); template< size_t M, typename T > const vector< M, T > vector< M, T >::ZERO( static_cast< T >( 0 )); template< size_t M, typename T > const vector< M, T > vector< M, T >::UNIT_X( 1, 0, 0 ); template< size_t M, typename T > const vector< M, T > vector< M, T >::UNIT_Y( 0, 1, 0 ); template< size_t M, typename T > const vector< M, T > vector< M, T >::UNIT_Z( 0, 0, 1 ); // // some free functions for convenience // template< size_t M, typename T > bool equals( const vector< M, T >& a, const vector< M, T >& b ) { return a.equals( b ); } // allows float * vector, not only vector * float template< size_t M, typename T > static vector< M, T > operator* ( T factor, const vector< M, T >& vector_ ) { return vector_ * factor; } template< size_t M, typename T > inline T dot( const vector< M, T >& first, const vector< M, T >& second ) { return first.dot( second ); } template< size_t M, typename T > inline vector< M, T > cross( const vector< 3, T >& a, const vector< 3, T >& b ) { return a.cross( b ); } template< size_t M, typename T > inline vector< M, T > normalize( const vector< M, T >& vector_ ) { vector< M, T > v( vector_ ); v.normalize(); return v; } template< size_t M, typename T > vector< M, T >::vector( const T& _a ) { for( iterator it = begin(), it_end = end(); it != it_end; ++it ) { *it = _a; } } template< size_t M, typename T > vector< M, T >::vector( const T& _x, const T& _y ) { array[ 0 ] = _x; array[ 1 ] = _y; } template< size_t M, typename T > vector< M, T >::vector( const T& _x, const T& _y, const T& _z ) { array[ 0 ] = _x; array[ 1 ] = _y; array[ 2 ] = _z; } template< size_t M, typename T > vector< M, T >::vector( const T& _x, const T& _y, const T& _z, const T& _w ) { array[ 0 ] = _x; array[ 1 ] = _y; array[ 2 ] = _z; array[ 3 ] = _w; } template< size_t M, typename T > vector< M, T >::vector( const T* values ) { memcpy( array, values, M * sizeof( T )); } template< size_t M, typename T > // initializes the first M-1 values from vector_, the last from last_ vector< M, T >::vector( const vector< M-1, T >& vector_, T last_ ) { typename vector< M-1, T >::const_iterator it = vector_.begin(), it_end = vector_.end(); iterator my_it = begin(); for( ; it != it_end; ++it, ++my_it ) { (*my_it) = *it; } (*my_it) = last_; } // to-homogenous-coordinates ctor template< size_t M, typename T > template< size_t N > vector< M, T >:: vector( const vector< N, T >& source_, typename enable_if< N == M - 1 >::type* ) { (*this) = source_; } // from-homogenous-coordinates ctor template< size_t M, typename T > template< size_t N > vector< M, T >:: vector( const vector< N, T >& source_, typename enable_if< N == M + 1 >::type* ) { (*this) = source_; } template< size_t M, typename T > template< typename U > vector< M, T >::vector( const vector< M, U >& source_ ) { (*this) = source_; } template< size_t M, typename T > void vector< M, T >::set( T _a ) { for( iterator it = begin(), it_end = end(); it != it_end; ++it ) { *it = _a; } } template< size_t M, typename T > void vector< M, T >::set( const vector< M-1, T >& v, T _a ) { memcpy( array, v.array, sizeof( T ) * (M-1) ); at( M-1 ) = _a; } template< size_t M, typename T > void vector< M, T >::set( T _x, T _y ) { array[ 0 ] = _x; array[ 1 ] = _y; } template< size_t M, typename T > void vector< M, T >::set( T _x, T _y, T _z ) { array[ 0 ] = _x; array[ 1 ] = _y; array[ 2 ] = _z; } template< size_t M, typename T > void vector< M, T >::set( T _x, T _y, T _z, T _w ) { array[ 0 ] = _x; array[ 1 ] = _y; array[ 2 ] = _z; array[ 3 ] = _w; } template< size_t M, typename T > inline T& vector< M, T >::operator()( size_t index ) { return at( index ); } template< size_t M, typename T > inline const T& vector< M, T >::operator()( size_t index ) const { return at( index ); } template< size_t M, typename T > inline T& vector< M, T >::at( size_t index ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( index >= M ) { VMMLIB_ERROR( "at() - index out of bounds", VMMLIB_HERE ); } #endif return array[ index ]; } template< size_t M, typename T > inline const T& vector< M, T >::at( size_t index ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( index >= M ) { VMMLIB_ERROR( "at() - index out of bounds", VMMLIB_HERE ); } #endif return array[ index ]; } #ifndef VMMLIB_NO_CONVERSION_OPERATORS template< size_t M, typename T > vector< M, T >::operator T*() { return array; } template< size_t M, typename T > vector< M, T >::operator const T*() const { return array; } #else template< size_t M, typename T > T& vector< M, T >::operator[]( size_t index ) { return at( index ); } template< size_t M, typename T > const T& vector< M, T >::operator[]( size_t index ) const { return at( index ); } #endif #if 0 template< size_t M, typename T > inline T& vector< M, T >::operator[]( size_t index ) { return at( index ); } template< size_t M, typename T > inline const T& vector< M, T >::operator[]( size_t index ) const { return at( index ); } #endif template< size_t M, typename T > vector< M, T > vector< M, T >::operator*( const vector< M, T >& other ) const { vector< M, T > result; for( size_t index = 0; index < M; ++index ) { result.at( index ) = at( index ) * other.at( index ); } return result; } template< size_t M, typename T > vector< M, T > vector< M, T >::operator/( const vector< M, T >& other ) const { vector< M, T > result; for( size_t index = 0; index < M; ++index ) { result.at( index ) = at( index ) / other.at( index ); } return result; } template< size_t M, typename T > vector< M, T > vector< M, T >::operator+( const vector< M, T >& other ) const { vector< M, T > result; for( size_t index = 0; index < M; ++index ) { result.at( index ) = at( index ) + other.at( index ); } return result; } template< size_t M, typename T > vector< M, T > vector< M, T >::operator-( const vector< M, T >& other ) const { vector< M, T > result; for( size_t index = 0; index < M; ++index ) { result.at( index ) = at( index ) - other.at( index ); } return result; } template< size_t M, typename T > void vector< M, T >::operator*=( const vector< M, T >& other ) { for( size_t index = 0; index < M; ++index ) { at( index ) *= other.at( index ); } } template< size_t M, typename T > void vector< M, T >::operator/=( const vector< M, T >& other ) { for( size_t index = 0; index < M; ++index ) { at( index ) /= other.at( index ); } } template< size_t M, typename T > void vector< M, T >::operator+=( const vector< M, T >& other ) { for( size_t index = 0; index < M; ++index ) { at( index ) += other.at( index ); } } template< size_t M, typename T > void vector< M, T >::operator-=( const vector< M, T >& other ) { for( size_t index = 0; index < M; ++index ) { at( index ) -= other.at( index ); } } template< size_t M, typename T > vector< M, T > vector< M, T >::operator*( const T other ) const { vector< M, T > result; for( size_t index = 0; index < M; ++index ) { result.at( index ) = at( index ) * other; } return result; } template< size_t M, typename T > vector< M, T > vector< M, T >::operator/( const T other ) const { vector< M, T > result; for( size_t index = 0; index < M; ++index ) { result.at( index ) = at( index ) / other; } return result; } template< size_t M, typename T > vector< M, T > vector< M, T >::operator+( const T other ) const { vector< M, T > result; for( size_t index = 0; index < M; ++index ) { result.at( index ) = at( index ) + other; } return result; } template< size_t M, typename T > vector< M, T > vector< M, T >::operator-( const T other ) const { vector< M, T > result; for( size_t index = 0; index < M; ++index ) { result.at( index ) = at( index ) - other; } return result; } template< size_t M, typename T > void vector< M, T >::operator*=( const T other ) { for( size_t index = 0; index < M; ++index ) { at( index ) *= other; } } template< size_t M, typename T > void vector< M, T >::operator/=( const T other ) { for( size_t index = 0; index < M; ++index ) { at( index ) /= other; } } template< size_t M, typename T > void vector< M, T >::operator+=( const T other ) { for( size_t index = 0; index < M; ++index ) { at( index ) += other; } } template< size_t M, typename T > void vector< M, T >::operator-=( const T other ) { for( size_t index = 0; index < M; ++index ) { at( index ) -= other; } } template< size_t M, typename T > vector< M, T > vector< M, T >::operator-() const { vector< M, T > v( *this ); return v.negate(); } template< size_t M, typename T > const vector< M, T >& vector< M, T >::negate() { for( size_t index = 0; index < M; ++index ) { array[ index ] = -array[ index ]; } return *this; } template< size_t M, typename T > inline T& vector< M, T >::x() { return array[ 0 ]; } template< size_t M, typename T > inline T& vector< M, T >::y() { return array[ 1 ]; } template< size_t M, typename T > inline T& vector< M, T >::z() { return array[ 2 ]; } template< size_t M, typename T > inline T& vector< M, T >::w() { return array[ 3 ]; } template< size_t M, typename T > inline const T& vector< M, T >::x() const { return array[ 0 ]; } template< size_t M, typename T > inline const T& vector< M, T >::y() const { return array[ 1 ]; } template< size_t M, typename T > inline const T& vector< M, T >::z() const { return array[ 2 ]; } template< size_t M, typename T > inline const T& vector< M, T >::w() const { return array[ 3 ]; } template< size_t M, typename T > inline T& vector< M, T >::r() { return array[ 0 ]; } template< size_t M, typename T > inline T& vector< M, T >::g() { return array[ 1 ]; } template< size_t M, typename T > inline T& vector< M, T >::b() { return array[ 2 ]; } template< size_t M, typename T > inline T& vector< M, T >::a() { return array[ 3 ]; } template< size_t M, typename T > inline const T& vector< M, T >::r() const { return array[ 0 ]; } template< size_t M, typename T > inline const T& vector< M, T >::g() const { return array[ 1 ]; } template< size_t M, typename T > inline const T& vector< M, T >::b() const { return array[ 2 ]; } template< size_t M, typename T > inline const T& vector< M, T >::a() const { return array[ 3 ]; } // result = vec1.cross( vec2 ) => result = vec1 x vec2 template< size_t M, typename T > template< typename TT > inline vector< M, T > vector< M, T >::cross( const vector< M, TT >& rhs, typename enable_if< M == 3, TT >::type* ) const { vector< M, T > result; result.cross( *this, rhs ); return result; } // result.cross( vec1, vec2 ) => (this) = vec1 x vec2 template< size_t M, typename T > template< typename TT > void vector< M, T >:: cross( const vector< M, TT >& aa, const vector< M, TT >& bb, typename enable_if< M == 3, TT >::type* ) { array[ 0 ] = aa.y() * bb.z() - aa.z() * bb.y(); array[ 1 ] = aa.z() * bb.x() - aa.x() * bb.z(); array[ 2 ] = aa.x() * bb.y() - aa.y() * bb.x(); } template< size_t M, typename T > inline T vector< M, T >::dot( const vector< M, T >& other ) const { T tmp = 0.0; for( size_t index = 0; index < M; ++index ) { tmp += at( index ) * other.at( index ); } return tmp; } template< size_t M, typename T > inline T vector< M, T >::normalize() { T len = length(); if ( len == 0 ) return 0; T tmp = 1.0 / len; (*this) *= tmp; return len; } template< size_t M, typename T > inline T vector< M, T >::length() const { return sqrt( squared_length() ); } template< size_t M, typename T > inline T vector< M, T >::squared_length() const { T _squared_length = 0.0; for( const_iterator it = begin(), it_end = end(); it != it_end; ++it ) { _squared_length += (*it) * (*it); } return _squared_length; } template< size_t M, typename T > inline T vector< M, T >::distance( const vector< M, T >& other_vector_ ) const { return sqrt( squared_distance( other_vector_ ) ); } template< size_t M, typename T > inline T vector< M, T >::squared_distance( const vector< M, T >& other_vector_ ) const { vector< M, T > tmp( *this ); tmp -= other_vector_; return tmp.squared_length(); } template< size_t M, typename T > void vector< M, T >::compute_normal( const vector< M, T >& aa, const vector< M, T >& bb, const vector< M, T >& cc ) { vector< M, T > u,v; // right hand system, CCW triangle u = bb - aa; v = cc - aa; cross( u, v ); normalize(); } template< size_t M, typename T > vector< M, T > vector< M, T >::compute_normal( const vector< M, T >& bb, const vector< M, T >& cc ) const { vector< M, T > tmp; tmp.compute_normal( *this, bb, cc); return tmp; } template< size_t M, typename T > template< typename TT > vector< 3, T > vector< M, T >::rotate( const T theta, vector< M, TT > axis, typename enable_if< M == 3, TT >::type* ) const { axis.normalize(); const T costheta = cos( theta ); const T sintheta = sin( theta ); return vector< 3, T >( (costheta + ( 1.0f - costheta ) * axis.x() * axis.x() ) * x() + (( 1 - costheta ) * axis.x() * axis.y() - axis.z() * sintheta ) * y() + (( 1 - costheta ) * axis.x() * axis.z() + axis.y() * sintheta ) * z(), (( 1 - costheta ) * axis.x() * axis.y() + axis.z() * sintheta ) * x() + ( costheta + ( 1 - costheta ) * axis.y() * axis.y() ) * y() + (( 1 - costheta ) * axis.y() * axis.z() - axis.x() * sintheta ) * z(), (( 1 - costheta ) * axis.x() * axis.z() - axis.y() * sintheta ) * x() + (( 1 - costheta ) * axis.y() * axis.z() + axis.x() * sintheta ) * y() + ( costheta + ( 1 - costheta ) * axis.z() * axis.z() ) * z() ); } // sphere layout: center xyz, radius w template< size_t M, typename T > template< typename TT > inline vector< 3, T > vector< M, T >:: project_point_onto_sphere( const vector< 3, TT >& point, typename enable_if< M == 4, TT >::type* ) const { const vector< 3, T >& _center = get_sub_vector< 3 >( 0 ); vector< 3, T > projected_point( point ); projected_point -= _center; projected_point.normalize(); projected_point *= w(); return _center + projected_point; } // sphere layout: center xyz, radius w template< size_t M, typename T > template< typename TT > inline T vector< M, T >:: distance_to_sphere( const vector< 3, TT >& point, typename enable_if< M == 4, TT >::type* ) const { const vector< 3, T >& center_ = get_sub_vector< 3 >( 0 ); return ( point - center_ ).length() - w(); } template< size_t M, typename T > template< size_t N > void vector< M, T >::get_sub_vector( vector< N, T >& sub_v, size_t offset, typename enable_if< M >= N >::type* ) { assert( offset <= M - N ); sub_v = reinterpret_cast< vector< N, T >& >( *( begin() + offset ) ); } template< size_t M, typename T > template< size_t N > inline vector< N, T >& vector< M, T >::get_sub_vector( size_t offset, typename enable_if< M >= N >::type* ) { assert( offset <= M - N ); return reinterpret_cast< vector< N, T >& >( *( begin() + offset ) ); } template< size_t M, typename T > template< size_t N > inline const vector< N, T >& vector< M, T >::get_sub_vector( size_t offset, typename enable_if< M >= N >::type* ) const { assert( offset <= M - N ); return reinterpret_cast< const vector< N, T >& >( *( begin() + offset ) ); } // plane: normal xyz, distance w template< size_t M, typename T > template< typename TT > inline T vector< M, T >::distance_to_plane( const vector< 3, TT >& point, typename enable_if< M == 4, TT >::type* ) const { const vector< 3, T >& normal = get_sub_vector< 3 >( 0 ); return normal.dot( point ) + w(); } // plane: normal xyz, distance w template< size_t M, typename T > template< typename TT > vector< 3, T > vector< M, T >::project_point_onto_plane( const vector< 3, TT >& point, typename enable_if< M == 4, TT >::type* ) const { const vector< 3, T >& normal = get_sub_vector< 3 >( 0 ); return point - ( normal * distance_to_plane( point ) ); } template< size_t M, typename T > bool vector< M, T >::operator==( const vector< M, T >& other ) const { bool ok = true; for( size_t index = 0; ok && index < M; ++index ) { ok = at( index ) == other.at( index ); } return ok; } template< size_t M, typename T > bool vector< M, T >::operator!=( const vector< M, T >& other ) const { return ! this->operator==( other ); } template< size_t M, typename T > bool vector< M, T >:: equals( const vector< M, T >& other, T tolerance ) const { bool ok = true; for( size_t index = 0; ok && index < M; ++index ) { ok = fabs( at( index ) - other( index ) ) < tolerance; } return ok; } template< size_t M, typename T > bool vector< M, T >::operator<( const vector< M, T >& other ) const { for(size_t index = 0; index < M; ++index ) { if (at( index ) < other.at( index )) return true; if (other.at( index ) < at( index )) return false; } return false; } // to-homogenous-coordinates assignment operator // non-chainable because of sfinae template< size_t M, typename T > template< size_t N > typename enable_if< N == M - 1 >::type* vector< M, T >:: operator=( const vector< N, T >& source_ ) { std::copy( source_.begin(), source_.end(), begin() ); at( M - 1 ) = static_cast< T >( 1.0 ); return 0; } // from-homogenous-coordinates assignment operator // non-chainable because of sfinae template< size_t M, typename T > template< size_t N > typename enable_if< N == M + 1 >::type* vector< M, T >:: operator=( const vector< N, T >& source_ ) { const T w_reci = static_cast< T >( 1.0 ) / source_( M ); iterator it = begin(), it_end = end(); for( size_t index = 0; it != it_end; ++it, ++index ) { *it = source_( index ) * w_reci; } return 0; } template< size_t M, typename T > const vector< M, T >& vector< M, T >::operator=( const T* c_array ) { iter_set( c_array, c_array + M ); return *this; } template< size_t M, typename T > T vector< M, T >::operator=( T filler_value ) { for( size_t index = 0; index < M; ++index ) { at( index ) = filler_value; } return filler_value; } template< size_t M, typename T > const vector< M, T >& vector< M, T >::operator=( const vector< M, T >& other ) { memcpy( array, other.array, M * sizeof( T ) ); return *this; } // returns void to avoid 'silent' loss of precision when chaining template< size_t M, typename T > template< typename U > void vector< M, T >::operator=( const vector< M, U >& source_ ) { typedef typename vector< M, U >::const_iterator u_c_iter; u_c_iter it = source_.begin(), it_end = source_.end(); for( iterator my_it = begin(); it != it_end; ++it, ++my_it ) { *my_it = static_cast< T >( *it ); } } template< size_t M, typename T > template< typename input_iterator_t > void vector< M, T >::iter_set( input_iterator_t begin_, input_iterator_t end_ ) { input_iterator_t in_it = begin_; iterator it = begin(), it_end = end(); for( ; it != it_end && in_it != end_; ++it, ++in_it ) { (*it) = static_cast< T >( *in_it ); } } template< size_t M, typename T > void vector< M, T >::clamp( const T& min, const T& max ) { for( size_t i = 0; i < M; ++i ) { if( array[i] < min ) array[i] = min; if( array[i] > max ) array[i] = max; } } template< size_t M, typename T > template< typename TT > void vector< M, T >::scale_to( vector< M, TT >& result_, T min_value, T max_value ) const { T range = max_value-min_value; T half_range = range * 0.5; T scale = ( 1.0 / range ) * static_cast< T >( std::numeric_limits< TT >::max() ); for( size_t index = 0; index < M; ++index ) { result_.at( index ) = static_cast< TT >( ( at( index ) + half_range ) * scale ); } } template< size_t M, typename T > inline size_t vector< M, T >::size() { return M; } template< size_t M, typename T > size_t vector< M, T >::find_min_index() const { return std::min_element( begin(), end() ) - begin(); } template< size_t M, typename T > size_t vector< M, T >::find_max_index() const { return std::max_element( begin(), end() ) - begin(); } template< size_t M, typename T > size_t vector< M, T >::find_abs_min_index() const { return std::min_element( begin(), end(), vmml::math::abs_less< T >() ) - begin(); } template< size_t M, typename T > size_t vector< M, T >::find_abs_max_index() const { return std::max_element( begin(), end(), vmml::math::abs_greater< T >() ) - begin(); } template< size_t M, typename T > T& vector< M, T >::find_min() { return *std::min_element( begin(), end() ); } template< size_t M, typename T > const T& vector< M, T >::find_min() const { return *std::min_element( begin(), end() ); } template< size_t M, typename T > T& vector< M, T >::find_max() { return *std::max_element( begin(), end() ); } template< size_t M, typename T > const T& vector< M, T >::find_max() const { return *std::max_element( begin(), end() ); } template< size_t M, typename T > inline typename vector< M, T >::iterator vector< M, T >::begin() { return array; } template< size_t M, typename T > inline typename vector< M, T >::iterator vector< M, T >::end() { return array + M; ; } template< size_t M, typename T > inline typename vector< M, T >::const_iterator vector< M, T >::begin() const { return array; } template< size_t M, typename T > inline typename vector< M, T >::const_iterator vector< M, T >::end() const { return array + M; ; } template< size_t M, typename T > inline typename vector< M, T >::reverse_iterator vector< M, T >::rbegin() { return array + M - 1; } template< size_t M, typename T > inline typename vector< M, T >::reverse_iterator vector< M, T >::rend() { return array - 1; } template< size_t M, typename T > inline typename vector< M, T >::const_reverse_iterator vector< M, T >::rbegin() const { return array + M - 1; } template< size_t M, typename T > inline typename vector< M, T >::const_reverse_iterator vector< M, T >::rend() const { return array - 1; } template< size_t M, typename T > bool vector< M, T >::is_unit_vector() const { const_iterator it = begin(), it_end = end(); bool one = false; for( ; it != it_end; ++it ) { if ( *it == 1.0 ) { if ( one ) return false; one = true; } else if ( *it != 0.0 ) { return false; } } return one; } template< size_t M, typename T > void vector< M, T >::perturb( T perturbation ) { for( iterator it = begin(), it_end = end(); it != it_end; ++it ) { (*it) += ( rand() & 1u ) ? perturbation : -perturbation; } } template< size_t M, typename T > void vector< M, T >::sqrt_elementwise() { for( iterator it = begin(), it_end = end(); it != it_end; ++it ) { (*it) = sqrt(*it); } } template< size_t M, typename T > void vector< M, T >::reciprocal() { for( iterator it = begin(), it_end = end(); it != it_end; ++it ) { (*it) = static_cast< T >( 1.0 ) / (*it); } } template< size_t M, typename T > void vector< M, T >::reciprocal_safe() { for( iterator it = begin(), it_end = end(); it != it_end; ++it ) { T& v = *it; if ( v == static_cast< T >( 0 ) ) v = std::numeric_limits< T >::max(); else v = static_cast< T >( 1.0 ) / v; } } template< size_t M, typename T > template< typename TT > void vector< M, T >::cast_from( const vector< M, TT >& other ) { typedef vmml::vector< M, TT > vector_tt_type ; typedef typename vector_tt_type::const_iterator tt_const_iterator; iterator it = begin(), it_end = end(); tt_const_iterator other_it = other.begin(); for( ; it != it_end; ++it, ++other_it ) { *it = static_cast< T >( *other_it ); } } template< size_t M, typename T > size_t vector< M, T >::nnz() const { size_t counter = 0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( *it != 0 ) { ++counter; } } return counter; } template< size_t M, typename T > bool vector< M, T >::is_valid() const { bool valid = true; for( const_iterator it = begin(); valid && it != end(); ++it ) { if ( std::isnan( *it ) ) valid = false; if ( std::isinf( *it ) ) valid = false; } #ifdef VMMLIB_THROW_EXCEPTIONS if ( ! valid ) VMMLIB_ERROR( "matrix contains nan or inf.", VMMLIB_HERE ); #endif return valid; } template< size_t M, typename T > double vector< M, T >::norm( ) const { double norm_v = 0.0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) { norm_v += *it * *it; } return sqrt(norm_v); } template< size_t M, typename T > void vector< M, T >::set_random( int seed ) { if ( seed >= 0 ) srand( seed ); double fillValue = 0.0f; for( size_t i = 0; i < M; ++i ) { fillValue = rand(); fillValue /= RAND_MAX; at( i ) = -1.0 + 2.0 * static_cast< double >( fillValue ) ; } } } // namespace vmml #endif vmmlib-1.0/include/vmmlib/frustum.hpp0000644000175000017500000002247311674116156017343 0ustar shevekshevek/* * VMMLib - Vector & Matrix Math Lib * * @author Stefan Eilemann * * @license revised BSD license, check LICENSE */ #ifndef __VMML__FRUSTUM__HPP__ #define __VMML__FRUSTUM__HPP__ #include #include #include // - declaration - namespace vmml { template< typename T > class frustum { public: VMMLIB_ALIGN( T array[6] ); // contructors frustum(); // warning: components NOT initialised ( for performance ) frustum( const T left, const T right, const T bottom, const T top, const T near_plane, const T far_plane ); template< typename U > frustum( const frustum< U >& source_ ); //the pointer 'values' must be a valid 6 component c array of the resp. type template< typename U > frustum( const U* values ); ~frustum(); const frustum& operator=( const frustum& source_ ); template< typename U > void operator=( const frustum< U >& source_ ); void set( const T _left, const T _right, const T _bottom, const T _top, const T _near, const T _far ); // set the frustum using the same parameters as gluPerspective. void set_perspective( T field_of_view_y, T aspect_ratio, T near_plane_, T far_plane ); matrix< 4, 4, T > compute_matrix() const; matrix< 4, 4, T > compute_ortho_matrix() const; void compute_matrix( matrix< 4, 4, T >& matrix_ ) const; void compute_ortho_matrix( matrix< 4, 4, T >& matrix_ ) const; void apply_jitter( const vector< 2, T >& jitter_ ); // 'move' the frustum. this function changes the near_plane, and adjusts the // other parameters in a way that the 'perspective pyramid' stays the same. void adjust_near( const T near_plane ); inline T& left(); inline const T& left() const; inline T& right(); inline const T& right() const; inline T& bottom(); inline const T& bottom() const; inline T& top(); inline const T& top() const; inline T& near_plane(); inline const T& near_plane() const; inline T& far_plane(); inline const T& far_plane() const; inline T get_width() const; inline T get_height() const; friend std::ostream& operator << ( std::ostream& os, const frustum& frustum_ ) { const std::ios::fmtflags flags = os.flags(); const int prec = os.precision(); os.setf( std::ios::right, std::ios::adjustfield ); os.precision( 5 ); os << "[" << std::setw(10) << frustum_.left() << " " << std::setw(10) << frustum_.right() << " " << std::setw(10) << frustum_.bottom() << " " << std::setw(10) << frustum_.top() << " " << std::setw(10) << frustum_.near_plane() << " " << std::setw(10) << frustum_.far_plane() << "]"; os.precision( prec ); os.setf( flags ); return os; }; static const frustum DEFAULT; }; #ifndef VMMLIB_NO_TYPEDEFS typedef frustum< float > frustumf; typedef frustum< double > frustumd; #endif } // namespace vmml // - implementation - // namespace vmml { template< typename T > const frustum< T > frustum< T >::DEFAULT( static_cast< T >( -1.0 ), static_cast< T >( 1.0 ), static_cast< T >( -1.0 ), static_cast< T >( 1.0 ), static_cast< T >( 0.1 ), static_cast< T >( 100.0 ) ); template < typename T > frustum< T >::frustum() {} template < typename T > frustum::frustum( const T _left, const T _right, const T _bottom, const T _top, const T _near, const T _far ) { set( _left, _right, _bottom, _top, _near, _far ); } template < typename T > template< typename U > frustum< T >::frustum( const frustum< U >& source_ ) { (*this) = source_; } template < typename T > template< typename U > frustum< T >::frustum( const U* values ) { assert( values && "frustum: Nullpointer argument as source for initialisation!" ); left() = static_cast< T > ( values[0] ); right() = static_cast< T > ( values[1] ); bottom() = static_cast< T > ( values[2] ); top() = static_cast< T > ( values[3] ); near_plane() = static_cast< T > ( values[4] ); far_plane() = static_cast< T > ( values[5] ); } template < typename T > frustum< T >::~frustum() {} template< typename T > const frustum< T >& frustum< T >::operator=( const frustum& source_ ) { memcpy( array, source_.array, 6 * sizeof( T ) ); return *this; } template< typename T > template< typename U > void frustum< T >::operator=( const frustum< U >& source_ ) { for( size_t index = 0; index < 6; ++index ) { array[ index ] = static_cast< T >( source_.array[ index ] ); } } template < typename T > void frustum< T >::set( const T _left, const T _right, const T _bottom, const T _top, const T _near, const T _far ) { left() = _left; right() = _right; bottom() = _bottom; top() = _top; near_plane() = _near; far_plane() = _far; } // 'move' the frustum. this function changes the near_plane, and adjusts the // other parameters in a way that the 'perspective pyramid' stays the same. template < typename T > void frustum::adjust_near( const T new_near ) { if( new_near == near_plane() ) return; const T ratio = new_near / near_plane(); right() *= ratio; left() *= ratio; top() *= ratio; bottom() *= ratio; near_plane() = new_near; } // set the frustum using the same parameters as gluPerspective. template < typename T > void frustum::set_perspective( T fov_y, T aspect_ratio, T near_plane_, T far_plane_ ) { near_plane() = near_plane_; far_plane() = far_plane_; top() = tan( 0.5 * fov_y * M_PI / 180.0 ) * 0.5; bottom() = - top(); left() = bottom() * aspect_ratio; right() = top() * aspect_ratio; } template < typename T > matrix< 4, 4, T > frustum::compute_matrix() const { matrix< 4, 4, T > matrix_; compute_matrix( matrix_ ); return matrix_; } template < typename T > void frustum::compute_matrix( matrix< 4, 4, T >& M ) const { M( 0,0 ) = 2.0 * near_plane() / ( right() - left() ); M( 0,1 ) = 0.0; M( 0,2 ) = ( right() + left() ) / ( right() - left() ); M( 0,3 ) = 0.0; M( 1,0 ) = 0.0; M( 1,1 ) = 2.0 * near_plane() / ( top() - bottom() ); M( 1,2 ) = ( top() + bottom() ) / ( top() - bottom() ); M( 1,3 ) = 0.0; M( 2,0 ) = 0.0; M( 2,1 ) = 0.0; // NOTE: Some glfrustum man pages say wrongly '(far + near) / (far - near)' M( 2,2 ) = -( far_plane() + near_plane() ) / ( far_plane() - near_plane() ); M( 2,3 ) = -2.0 * far_plane() * near_plane() / ( far_plane() - near_plane() ); M( 3,0 ) = 0.0; M( 3,1 ) = 0.0; M( 3,2 ) = -1.0; M( 3,3 ) = 0.0; } template < typename T > matrix< 4, 4, T > frustum< T >::compute_ortho_matrix() const { matrix< 4, 4, T > matrix_; compute_ortho_matrix( matrix_ ); return matrix_; } template < typename T > void frustum< T >::compute_ortho_matrix( matrix< 4, 4, T >& M ) const { M( 0,0 ) = 2.0 / ( right() - left() ); M( 0,1 ) = 0.0; M( 0,2 ) = 0.0; M( 0,3 ) = -( right() + left() ) / ( right() - left() ); M( 1,0 ) = 0.0; M( 1,1 ) = 2.0 / ( top() - bottom() ); M( 1,2 ) = 0.0f; M( 1,3 ) = -( top() + bottom() ) / ( top() - bottom() ); M( 2,0 ) = 0.0; M( 2,1 ) = 0.0; M( 2,2 ) = -2.0 / ( far_plane() - near_plane() ); M( 2,3 ) = -( far_plane() + near_plane() ) / ( far_plane() - near_plane() ); M( 3,0 ) = 0.0; M( 3,1 ) = 0.0; M( 3,2 ) = 0.0; M( 3,3 ) = 1.0f; } template < typename T > void frustum< T >::apply_jitter( const vector< 2, T >& jitter_ ) { left() = left() + jitter_.x(); right() = right() + jitter_.x(); bottom() = bottom() + jitter_.y(); top() = top() + jitter_.y(); } template< typename T > inline T& frustum< T >::left() { return array[ 0 ]; } template< typename T > inline const T& frustum< T >::left() const { return array[ 0 ]; } template< typename T > inline T& frustum< T >::right() { return array[ 1 ]; } template< typename T > inline const T& frustum< T >::right() const { return array[ 1 ]; } template< typename T > inline T& frustum< T >::bottom() { return array[ 2 ]; } template< typename T > inline const T& frustum< T >::bottom() const { return array[ 2 ]; } template< typename T > inline T& frustum< T >::top() { return array[ 3 ]; } template< typename T > inline const T& frustum< T >::top() const { return array[ 3 ]; } template< typename T > inline T& frustum< T >::near_plane() { return array[ 4 ]; } template< typename T > inline const T& frustum< T >::near_plane() const { return array[ 4 ]; } template< typename T > inline T& frustum< T >::far_plane() { return array[ 5 ]; } template< typename T > inline const T& frustum< T >::far_plane() const { return array[ 5 ]; } template< typename T > inline T frustum< T >::get_width() const { return fabs( right() - left( )); } template< typename T > inline T frustum< T >::get_height() const { return fabs( top() - bottom( )); } } //namespace vmml #endif vmmlib-1.0/include/vmmlib/visibility.hpp0000644000175000017500000000034011674116156020012 0ustar shevekshevek#ifndef __VMML__VISIBILITY__HPP__ #define __VMML__VISIBILITY__HPP__ namespace vmml { enum Visibility { VISIBILITY_NONE = 0, VISIBILITY_PARTIAL = 1, VISIBILITY_FULL = 2 }; } // namespace vmml #endif vmmlib-1.0/include/vmmlib/svd.hpp0000644000175000017500000002126111674116156016424 0ustar shevekshevek#ifndef __VMML__SINGULAR_VALUE_DECOMPOSITION__HPP__ #define __VMML__SINGULAR_VALUE_DECOMPOSITION__HPP__ #include #include #include namespace vmml { /* * Given a matrix a[1..m][1..n], this routine computes its singular value * decomposition, A = U·W·V T. The matrix U replaces a on output. The diagonal * matrix of singular values W is output as a vector w[1..n]. The transpose V T * (not the matrix V ! ) is output as v[1..n][1..n]. */ //static double rv1[16]; template < size_t M, size_t N, typename T > void svdecompose( matrix< M, N, T >& a, vector< N, T >& w, matrix< N, N, T >& v ) { int m = M; int n = N; int flag, i, its, j, jj, k, l, nm; T anorm, c, f, g, h, s, scale, x, y, z; //T* rv1 = (T*)calloc( n, sizeof(T)); // vector(1,n); vector< N, T > rv1; g = scale = anorm = 0.0; // Householder reduction to bidiagonal form. for ( i = 0; i < n; ++i ) { l = i + 1; rv1[i] = scale * g; g = s = scale = 0.0; if ( i < m ) { for ( k = i; k < m; ++k ) scale += fabs(a[k][i]); if ( scale ) { for ( k = i; k < m; ++k ) { a[k][i] /= scale; s += a[k][i] * a[k][i]; } f = a[i][i]; g = -math::sign( static_cast< T >(sqrt(s)), f); h = f * g - s; a[i][i] = f - g; for ( j = l; j < n; ++j ) { for ( s = 0.0, k = i; k < m; ++k ) s += a[k][i] * a[k][j]; f = s / h; for ( k = i; k < m; ++k ) a[k][j] += f * a[k][i]; } for ( k = i; k < m; ++k ) a[k][i] *= scale; } } w[i] = scale * g; g = s = scale = 0.0; if ( i < m && i != n-1 ) { for ( k = l; k < n; ++k ) scale += fabs(a[i][k]); if ( scale ) { for ( k = l; k < n; ++k ) { a[i][k] /= scale; s += a[i][k] * a[i][k]; } f = a[i][l]; g = -math::sign( static_cast< T >( sqrt(s)), f); h = f * g - s; a[i][l] = f - g; for ( k = l; k < n; ++k ) rv1[k] = a[i][k] / h; for ( j = l; j < m; ++j ) { for ( s = 0.0, k = l; k < n; ++k ) s += a[j][k] * a[i][k]; for ( k = l; k < n; ++k ) a[j][k] += s * rv1[k]; } for ( k = l; k < n; ++k ) a[i][k] *= scale; } } anorm = (std::max)( anorm, static_cast< T >( ( fabs( w[i] ) + fabs( rv1[i] ) ) ) ); } for ( i = n-1; i >= 0; --i ) { // Accumulation of right-hand transformations. if ( i < n ) { if ( g ) { for ( j = l; j < n; ++j ) // Double division to avoid possible underflow. v[j][i] = (a[i][j] / a[i][l]) / g; for ( j = l; j < n; ++j ) { for ( s = 0.0, k = l; k < n; ++k ) s += a[i][k] * v[k][j]; for ( k = l; k < n; ++k ) v[k][j] += s * v[k][i]; } } for ( j = l; j < n; ++j ) v[i][j] = v[j][i] = 0.0; } v[i][i] = 1.0; g = rv1[i]; l = i; } i = ( m < n ) ? m - 1 : n - 1; for ( ; i >= 0; --i ) // IMIN { // Accumulation of left-hand transformations. l = i + 1; g = w[i]; for ( j = l; j < n; ++j ) a[i][j] = 0.0; if ( g ) { g = 1.0 / g; for ( j = l; j < n; ++j ) { for ( s = 0.0, k = l; k < m; ++k ) s += a[k][i] * a[k][j]; f = (s / a[i][i]) * g; for ( k = i; k < m; ++k ) a[k][j] += f * a[k][i]; } for ( j = i; j < m; ++j ) a[j][i] *= g; } else for ( j = i; j < m; ++j ) a[j][i] = 0.0; ++a[i][i]; } for ( k = n-1; k >= 0; --k ) { // Diagonalization of the bidiagonal form: Loop over singular values, // and over allowed iterations. for ( its = 0; its < 30; ++its ) { flag = 1; for ( l = k; l >= 0; --l ) { // Test for splitting. nm = l - 1; // Note that rv1[1] is always zero. if ( ( fabs( rv1[l] ) + anorm ) == anorm ) { flag = 0; break; } if ( ( fabs( w[ nm ] ) + anorm ) == anorm ) break; } if ( flag ) { c = 0.0; // Cancellation of rv1[l], if l > 1. s = 1.0; for ( i = l; i <= k; ++i ) { f = s * rv1[i]; rv1[i] = c * rv1[i]; if ( ( fabs(f) + anorm ) == anorm ) break; g = w[i]; h = math::pythag(f, g); w[i] = h; h = 1.0 / h; c = g * h; s = -f * h; for ( j = 0; j < m; ++j ) { y = a[j][nm]; z = a[j][i]; a[j][nm] = y * c + z * s; a[j][i] = z * c - y * s; } } } z = w[k]; if ( l == k ) { // Convergence. if ( z < 0.0 ) { // Singular value is made nonnegative. w[k] = -z; for ( j = 0; j < n; ++j ) v[j][k] = -v[j][k]; } break; } if ( its == 30 ) { //fprintf(stderr, "Warning: no convergence in 30 svdcmp iterations\n"); std::cerr << "SingularValueDecomposition - Warning: no convergence in 30 iterations." << std::endl; } x = w[l]; // Shift from bottom 2-by-2 minor. nm = k - 1; y = w[nm]; g = rv1[nm]; h = rv1[k]; f = ( (y-z) * (y+z) + (g-h) * (g+h) ) / (2.0 * h * y ); g = math::pythag( f, static_cast< T >( 1.0 ) ); f = ( ( x - z ) * ( x + z ) + h * ( ( y / ( f + math::sign( g, f ) ) ) - h ) ) / x; c = s = 1.0; // Next QR transformation: for ( j = l; j <= nm; ++j ) { i = j + 1; g = rv1[i]; y = w[i]; h = s * g; g = c * g; z = math::pythag( f, h ); rv1[j] = z; c = f / z; s = h / z; f = x * c + g * s; g = g * c - x * s; h = y * s; y *= c; for ( jj = 0; jj < n; ++jj ) { x = v[jj][j]; z = v[jj][i]; v[jj][j] = x * c + z * s; v[jj][i] = z * c - x * s; } z = math::pythag( f, h ); w[j] = z; // Rotation can be arbitrary if z = 0. if ( z ) { z = 1.0 / z; c = f * z; s = h * z; } f = c * g + s * y; x = c * y - s * g; for ( jj = 0; jj < m; ++jj ) { y = a[jj][j]; z = a[jj][i]; a[jj][j] = y * c + z * s; a[jj][i] = z * c - y * s; } } rv1[l] = 0.0; rv1[k] = f; w[k] = x; } } //free(rv1); for ( i = 0; i < 3; ++i ) for ( j = 0; j < 3; ++j ) if ( i < j && w[i] < w[j] ) { double t = w[i]; double u = w[j]; w[i] = u; w[j] = t; for ( k = 0; k < 3; ++k ) { t = v[i][k]; u = v[j][k]; v[i][k] = u * pow( -1, i ); v[j][k] = t * pow( -1, j ); t = a[k][i]; u = a[k][j]; a[k][i] = u * pow( -1, i ); a[k][j] = t * pow( -1, j ); } } } } #endif vmmlib-1.0/include/vmmlib/matrix.hpp0000644000175000017500000021204111674116156017132 0ustar shevekshevek#ifndef __VMML__MATRIX__HPP__ #define __VMML__MATRIX__HPP__ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // file I/O namespace vmml { // matrix of type T with m rows and n columns template< size_t M, size_t N, typename T = float > class matrix { public: typedef T value_type; typedef T* pointer; typedef T& reference; typedef T* iterator; typedef const T* const_iterator; typedef std::reverse_iterator< iterator > reverse_iterator; typedef std::reverse_iterator< const_iterator > const_reverse_iterator; static const size_t ROWS = M; static const size_t COLS = N; // accessors inline T& operator()( size_t row_index, size_t col_index ); inline const T& operator()( size_t row_index, size_t col_index ) const; inline T& at( size_t row_index, size_t col_index ); inline const T& at( size_t row_index, size_t col_index ) const; // element iterators - NOTE: column-major order iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const; reverse_iterator rbegin(); reverse_iterator rend(); const_reverse_iterator rbegin() const; const_reverse_iterator rend() const; // ctors // note: this ctor does not initialize anything because of performance reasons. matrix(); template< typename U > matrix( const matrix< M, N, U >& source_ ); template< size_t P, size_t Q > matrix( const matrix< P, Q, T >& source_ ); #ifndef VMMLIB_NO_CONVERSION_OPERATORS // auto conversion operator operator T*(); operator const T*() const; #endif bool operator==( const matrix& other ) const; bool operator!=( const matrix& other ) const; // due to limited precision, two 'idential' matrices might seem different. // this function allows to specify a tolerance when comparing matrices. bool equals( const matrix& other, T tolerance ) const; // this version takes a comparison functor to compare the components of // the two matrices template< typename compare_t > bool equals( const matrix& other, compare_t& cmp ) const; void multiply_piecewise( const matrix& other ); // (this) matrix = left matrix_mxp * right matrix_pxn template< size_t P > void multiply( const matrix< M, P, T >& left, const matrix< P, N, T >& right ); // convolution operation (extending borders) of (this) matrix and the given kernel template< size_t U, size_t V > void convolve(const matrix< U, V, T >& kernel); // returned matrix_mxp = (this) matrix * other matrix_nxp; // note: using multiply(...) it avoids a copy of the resulting matrix template< size_t P > matrix< M, P, T > operator*( const matrix< N, P, T >& other ) const; // operator *= is only enabled for square matrices template< size_t O, size_t P, typename TT > typename enable_if< M == N && O == P && M == O, TT >::type* operator*=( const matrix< O, P, TT >& right ); inline matrix operator+( const matrix& other ) const; inline matrix operator-( const matrix& other ) const; void operator+=( const matrix& other ); void operator-=( const matrix& other ); void operator+=( T scalar ); void operator-=( T scalar ); template< size_t O, size_t P, size_t Q, size_t R > typename enable_if< M == O + Q && N == P + R >::type* direct_sum( const matrix< O, P, T >& m0, const matrix< Q, R, T >& m1 ); // // matrix-scalar operations / scaling // matrix operator*( T scalar ); void operator*=( T scalar ); matrix operator/( T scalar ); void operator/=( T scalar ); // // matrix-vector operations // // transform column vector by matrix ( vec = matrix * vec ) vector< M, T > operator*( const vector< N, T >& other ) const; // transform column vector by matrix ( vec = matrix * vec ) // assume homogenous coords, e.g. vec3 = mat4x4 * vec3, with w = 1.0 template< size_t O > vector< O, T > operator*( const vector< O, T >& vector_ ) const; inline matrix< M, N, T > operator-() const; matrix< M, N, T > negate() const; // compute tensor product: (this) = vector (X) vector void tensor( const vector< M, T >& u, const vector< N, T >& v ); // tensor, for api compatibility with old vmmlib version. // WARNING: for M = N = 4 only. template< size_t uM, size_t vM > typename enable_if< uM == 3 && vM == 3 && M == N && M == 4 >::type* tensor( const vector< uM, T >& u, const vector< vM, T >& v ); // row_offset and col_offset define the starting indices for the sub_matrix // the sub_matrix is extracted according to the size of the target matrix, i.e. ( OXP ) template< size_t O, size_t P > matrix< O, P, T > get_sub_matrix( size_t row_offset, size_t col_offset, typename enable_if< O <= M && P <= N >::type* = 0 ) const; template< size_t O, size_t P > typename enable_if< O <= M && P <= N >::type* get_sub_matrix( matrix< O, P, T >& result, size_t row_offset = 0, size_t col_offset = 0 ) const; template< size_t O, size_t P > typename enable_if< O <= M && P <= N >::type* set_sub_matrix( const matrix< O, P, T >& sub_matrix, size_t row_offset = 0, size_t col_offset = 0 ); // copies a transposed version of *this into transposedMatrix void transpose_to( matrix< N, M, T >& transpose_ ) const; //symmetric covariance matrix of a right matrix multiplication: MxN x NxM = MxM void symmetric_covariance( matrix< M, M, T >& cov_m_ ) const; const matrix& operator=( const matrix& source_ ); // these assignment operators return nothing to avoid silent loss of // precision template< typename U > void operator=( const matrix< M, N, U >& source_ ); void operator=( const T old_fashioned_matrix[ M ][ N ] ); // WARNING: data_array[] must be at least of size M * N - otherwise CRASH! // WARNING: assumes row_by_row layout - if this is not the case, // use matrix::set( data_array, false ) void operator=( const T* data_array ); void operator=( const std::vector< T >& data ); // sets all elements to fill_value void operator=( T fill_value ); void fill( T fill_value ); // note: this function copies elements until either the matrix is full or // the iterator equals end_. template< typename input_iterator_t > void set( input_iterator_t begin_, input_iterator_t end_, bool row_major_layout = true ); //sets all matrix values with random values //remember to set srand( seed ); //if seed is set to -1, srand( seed ) was set outside set_random //otherwise srand( seed ) will be called with the given seed void set_random( int seed = -1 ); //sets all matrix values with discrete cosine transform coefficients (receive orthonormal coefficients) void set_dct(); void zero(); void identity(); double frobenius_norm() const; template< typename TT > void cast_from( const matrix< M, N, TT >& other ); void write_csv_file( const std::string& dir_, const std::string& filename_ ) const; template< typename TT > void quantize_to( matrix< M, N, TT >& quantized_, const T& min_value, const T& max_value ) const; template< typename TT > void quantize( matrix< M, N, TT >& quantized_, T& min_value, T& max_value ) const; template< typename TT > void dequantize( matrix< M, N, TT >& quantized_, const TT& min_value, const TT& max_value ) const; void columnwise_sum( vector< N, T>& summed_columns_ ) const; double sum_elements() const; void sum_rows( matrix< M/2, N, T>& other ) const; void sum_columns( matrix< M, N/2, T>& other ) const; template< size_t R > typename enable_if< R == M && R == N >::type* diag( const vector< R, T >& diag_values_ ); //Khatri-Rao Product: columns must be of same size template< size_t O > void khatri_rao_product( const matrix< O, N, T >& right_, matrix< M*O, N, T >& prod_ ) const; //Kronecker Product: MxN x_kronecker OxP = M*OxN*P template< size_t O, size_t P > void kronecker_product( const matrix< O, P, T >& right_, matrix< M*O, N*P, T >& result_) const; T get_min() const; T get_max() const; T get_abs_min() const; T get_abs_max() const; //returns number of non-zeros size_t nnz() const; size_t nnz( const T& threshold_ ) const; void threshold( const T& threshold_value_ ); vector< M, T > get_column( size_t column_index ) const; void get_column( size_t column_index, vector< M, T>& column ) const; void set_column( size_t index, const vector< M, T >& column ); void get_column( size_t index, matrix< M, 1, T >& column ) const; void set_column( size_t index, const matrix< M, 1, T >& column ); vector< N, T > get_row( size_t index ) const; void get_row( size_t index, vector< N, T >& row ) const; void set_row( size_t index, const vector< N, T >& row ); void get_row( size_t index, matrix< 1, N, T >& row ) const; void set_row( size_t index, const matrix< 1, N, T >& row ); size_t size() const; // return M * N; size_t get_number_of_rows() const; size_t get_number_of_columns() const; T det() const; // the return value indicates if the matrix is invertible. // we need a tolerance term since the computation of the determinant is // subject to precision errors. template< size_t O, size_t P, typename TT > bool inverse( matrix< O, P, TT >& inverse_, T tolerance = std::numeric_limits::epsilon(), typename enable_if< M == N && O == P && O == M && M >= 2 && M <= 4, TT >::type* = 0 ) const; template< size_t O, size_t P > typename enable_if< O == P && M == N && O == M && M >= 2 >::type* get_adjugate( matrix< O, P, T >& adjugate ) const; template< size_t O, size_t P > typename enable_if< O == P && M == N && O == M && M >= 2 >::type* get_cofactors( matrix< O, P, T >& cofactors ) const; // returns the determinant of a square matrix M-1, N-1 template< size_t O, size_t P > T get_minor( matrix< O, P, T >& minor_, size_t row_to_cut, size_t col_to_cut, typename enable_if< O == M-1 && P == N-1 && M == N && M >= 2 >::type* = 0 ) const; // // 4*4 matrices only // /** create rotation matrix from parameters. * @param angle - angle in radians * @param rotation axis - must be normalized! */ template< typename TT > void rotate( const TT angle, const vector< M-1, T >& axis, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > void rotate_x( const TT angle, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > void rotate_y( const TT angle, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > void rotate_z( const TT angle, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > void pre_rotate_x( const TT angle, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > void pre_rotate_y( const TT angle, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > void pre_rotate_z( const TT angle, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > void scale( const TT scale[3], typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > void scale( const TT x_, const T y, const T z, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > inline void scale( const vector< 3, TT >& scale_, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > inline void scale_translation( const TT scale_[3], typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > inline void scale_translation( const vector< 3, TT >& scale_, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > inline void set_translation( const TT x_, const TT y_, const TT z_, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > inline void set_translation( const TT trans[3], typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > inline void set_translation( const vector< 3, TT >& translation_, typename enable_if< M == N && M == 4, TT >::type* = 0 ); template< typename TT > inline void get_translation( vector< 3, TT >& translation_, typename enable_if< M == N && M == 4, TT >::type* = 0 ) const; // hack for static-member-init template< typename init_functor_t > static const matrix get_initialized_matrix(); inline T& x(); inline T& y(); inline T& z(); // tests every component for isnan && isinf inline bool is_valid() const; // legacy/compatibility accessor struct row_accessor { row_accessor( T* array_ ) : array( array_ ) {} T& operator[]( size_t col_index ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( col_index >= N ) VMMLIB_ERROR( "column index out of bounds", VMMLIB_HERE ); #endif return array[ col_index * M ]; } const T& operator[]( size_t col_index ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( col_index >= N ) VMMLIB_ERROR( "column index out of bounds", VMMLIB_HERE ); #endif return array[ col_index * M ]; } T* array; private: row_accessor() {} // disallow std ctor }; // this is a hack to allow array-style access to matrix elements // usage: matrix< 2, 2, float > m; m[ 1 ][ 0 ] = 37.0f; inline row_accessor operator[]( size_t row_index ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( row_index > M ) VMMLIB_ERROR( "row index out of bounds", VMMLIB_HERE ); #endif return row_accessor( array + row_index ); } // this is a hack to remove a warning about implicit conversions inline row_accessor operator[]( int row_index ) { return ( *this )[ size_t ( row_index ) ]; } friend std::ostream& operator << ( std::ostream& os, const matrix< M, N, T >& matrix ) { #ifdef EQFABRIC_API_H const std::ios::fmtflags flags = os.flags(); const int prec = os.precision(); os.setf( std::ios::right, std::ios::adjustfield ); os.precision( 5 ); for( size_t row_index = 0; row_index < M; ++row_index ) { os << "|"; for( size_t col_index = 0; col_index < N; ++col_index ) { os << std::setw(10) << matrix.at( row_index, col_index ) << " "; } os << "|" << std::endl; } os.precision( prec ); os.setf( flags ); #else for( size_t row_index = 0; row_index < M; ++row_index ) { os << "("; for( size_t col_index = 0; col_index < N; ++col_index ) { if( sizeof(T) ==sizeof(unsigned char)) { os << int(matrix.at( row_index, col_index )); } else { os << matrix.at( row_index, col_index ); } if (col_index < (N-1) ) os << ", "; } os << ")" << std::endl; } #endif return os; }; // protected: // column_by_column VMMLIB_ALIGN( T array[ M * N ] ); // static members static const matrix< M, N, T > IDENTITY; static const matrix< M, N, T > ZERO; }; // class matrix #ifndef VMMLIB_NO_TYPEDEFS typedef matrix< 3, 3, float > mat3f; typedef matrix< 3, 3, double > mat3d; typedef matrix< 4, 4, float > mat4f; typedef matrix< 4, 4, double > mat4d; #endif /* * free functions */ template< size_t M, size_t N, typename T > bool equals( const matrix< M, N, T >& m0, const matrix< M, N, T >& m1, T tolerance ) { return m0.equals( m1, tolerance ); } template< size_t M, size_t N, typename T > inline void multiply( const matrix< M, N, T >& left, const matrix< M, N, T >& right, matrix< M, N, T >& result ) { result.multiply( left, right ); } template< size_t M, size_t N, typename T > template< size_t U, size_t V > void matrix< M, N, T>::convolve(const matrix< U, V, T >& kernel) { matrix< M, N, T> temp; // do not override original values instantly as old values are needed for calculation for(int y_ = 0; y_ < N; ++y_) { for(int x_ = 0; x_ < M; ++x_) { double sum = 0.0; for(int j = 0; j < V; ++j) { int srcy = y_ - V/2 + j; // Extending border values if(srcy < 0) srcy = 0; if(srcy >= N) srcy = N-1; for(int i = 0; i < U; ++i) { int srcx = x_ - U/2 + i; // Extending border values if(srcx < 0) srcx = 0; if(srcx >= M) srcx = M-1; sum += kernel.at(j,i) * at(srcy,srcx); } } temp.at(y_,x_) = sum; } } *this = temp; } template< size_t M, size_t N, size_t P, typename T > inline void multiply( const matrix< M, P, T >& left, const matrix< P, N, T >& right, matrix< M, N, T >& result ) { result.multiply( left, right ); } template< size_t M, size_t N, typename T > inline typename enable_if< M == N >::type* identity( matrix< M, N, T >& matrix_ ) { matrix_ = static_cast< T >( 0.0 ); for( size_t index = 0; index < M; ++index ) { matrix_( index, index ) = static_cast< T >( 1.0 ); } return 0; // for sfinae } template< typename T > inline T compute_determinant( const matrix< 1, 1, T >& matrix_ ) { return matrix_.array[ 0 ]; } template< typename T > inline T compute_determinant( const matrix< 2, 2, T >& matrix_ ) { const T& a = matrix_( 0, 0 ); const T& b = matrix_( 0, 1 ); const T& c = matrix_( 1, 0 ); const T& d = matrix_( 1, 1 ); return a * d - b * c; } template< typename T > inline T compute_determinant( const matrix< 3, 3, T >& m_ ) { return m_( 0,0 ) * ( m_( 1,1 ) * m_( 2,2 ) - m_( 1,2 ) * m_( 2,1 ) ) + m_( 0,1 ) * ( m_( 1,2 ) * m_( 2,0 ) - m_( 1,0 ) * m_( 2,2 ) ) + m_( 0,2 ) * ( m_( 1,0 ) * m_( 2,1 ) - m_( 1,1 ) * m_( 2,0 ) ); } template< typename T > inline T compute_determinant( const matrix< 4, 4, T >& m ) { T m00 = m( 0, 0 ); T m10 = m( 1, 0 ); T m20 = m( 2, 0 ); T m30 = m( 3, 0 ); T m01 = m( 0, 1 ); T m11 = m( 1, 1 ); T m21 = m( 2, 1 ); T m31 = m( 3, 1 ); T m02 = m( 0, 2 ); T m12 = m( 1, 2 ); T m22 = m( 2, 2 ); T m32 = m( 3, 2 ); T m03 = m( 0, 3 ); T m13 = m( 1, 3 ); T m23 = m( 2, 3 ); T m33 = m( 3, 3 ); return m03 * m12 * m21 * m30 - m02 * m13 * m21 * m30 - m03 * m11 * m22 * m30 + m01 * m13 * m22 * m30 + m02 * m11 * m23 * m30 - m01 * m12 * m23 * m30 - m03 * m12 * m20 * m31 + m02 * m13 * m20 * m31 + m03 * m10 * m22 * m31 - m00 * m13 * m22 * m31 - m02 * m10 * m23 * m31 + m00 * m12 * m23 * m31 + m03 * m11 * m20 * m32 - m01 * m13 * m20 * m32 - m03 * m10 * m21 * m32 + m00 * m13 * m21 * m32 + m01 * m10 * m23 * m32 - m00 * m11 * m23 * m32 - m02 * m11 * m20 * m33 + m01 * m12 * m20 * m33 + m02 * m10 * m21 * m33 - m00 * m12 * m21 * m33 - m01 * m10 * m22 * m33 + m00 * m11 * m22 * m33; } template< typename T > bool compute_inverse( const matrix< 2, 2, T >& m_, matrix< 2, 2, T >& inverse_, T tolerance_ = std::numeric_limits::epsilon()) { T det_ = compute_determinant( m_ ); if ( fabs( det_ ) < tolerance_ ) { return false; } T detinv = static_cast< T >( 1.0 ) / det_; // set inverse_ to the adjugate of M m_.get_adjugate( inverse_ ); inverse_ *= detinv; return true; } template< typename T > bool compute_inverse( const matrix< 3, 3, T >& m_, matrix< 3, 3, T >& inverse_, T tolerance_ = std::numeric_limits::epsilon() ) { // Invert a 3x3 using cofactors. This is about 8 times faster than // the Numerical Recipes code which uses Gaussian elimination. inverse_.at( 0, 0 ) = m_.at( 1, 1 ) * m_.at( 2, 2 ) - m_.at( 1, 2 ) * m_.at( 2, 1 ); inverse_.at( 0, 1 ) = m_.at( 0, 2 ) * m_.at( 2, 1 ) - m_.at( 0, 1 ) * m_.at( 2, 2 ); inverse_.at( 0, 2 ) = m_.at( 0, 1 ) * m_.at( 1, 2 ) - m_.at( 0, 2 ) * m_.at( 1, 1 ); inverse_.at( 1, 0 ) = m_.at( 1, 2 ) * m_.at( 2, 0 ) - m_.at( 1, 0 ) * m_.at( 2, 2 ); inverse_.at( 1, 1 ) = m_.at( 0, 0 ) * m_.at( 2, 2 ) - m_.at( 0, 2 ) * m_.at( 2, 0 ); inverse_.at( 1, 2 ) = m_.at( 0, 2 ) * m_.at( 1, 0 ) - m_.at( 0, 0 ) * m_.at( 1, 2 ); inverse_.at( 2, 0 ) = m_.at( 1, 0 ) * m_.at( 2, 1 ) - m_.at( 1, 1 ) * m_.at( 2, 0 ); inverse_.at( 2, 1 ) = m_.at( 0, 1 ) * m_.at( 2, 0 ) - m_.at( 0, 0 ) * m_.at( 2, 1 ); inverse_.at( 2, 2 ) = m_.at( 0, 0 ) * m_.at( 1, 1 ) - m_.at( 0, 1 ) * m_.at( 1, 0 ); const T determinant = m_.at( 0, 0 ) * inverse_.at( 0, 0 ) + m_.at( 0, 1 ) * inverse_.at( 1, 0 ) + m_.at( 0, 2 ) * inverse_.at( 2, 0 ); if ( fabs( determinant ) <= tolerance_ ) return false; // matrix is not invertible const T detinv = static_cast< T >( 1.0 ) / determinant; inverse_.at( 0, 0 ) *= detinv; inverse_.at( 0, 1 ) *= detinv; inverse_.at( 0, 2 ) *= detinv; inverse_.at( 1, 0 ) *= detinv; inverse_.at( 1, 1 ) *= detinv; inverse_.at( 1, 2 ) *= detinv; inverse_.at( 2, 0 ) *= detinv; inverse_.at( 2, 1 ) *= detinv; inverse_.at( 2, 2 ) *= detinv; return true; } template< typename T > bool compute_inverse( const matrix< 4, 4, T >& m_, matrix< 4, 4, T >& inv_, T tolerance_ = std::numeric_limits::epsilon() ) { const T* array = m_.array; // tuned version from Claude Knaus /* first set of 2x2 determinants: 12 multiplications, 6 additions */ const T t1[6] = { array[ 2] * array[ 7] - array[ 6] * array[ 3], array[ 2] * array[11] - array[10] * array[ 3], array[ 2] * array[15] - array[14] * array[ 3], array[ 6] * array[11] - array[10] * array[ 7], array[ 6] * array[15] - array[14] * array[ 7], array[10] * array[15] - array[14] * array[11] }; /* first half of comatrix: 24 multiplications, 16 additions */ inv_.array[0] = array[ 5] * t1[5] - array[ 9] * t1[4] + array[13] * t1[3]; inv_.array[1] = array[ 9] * t1[2] - array[13] * t1[1] - array[ 1] * t1[5]; inv_.array[2] = array[13] * t1[0] - array[ 5] * t1[2] + array[ 1] * t1[4]; inv_.array[3] = array[ 5] * t1[1] - array[ 1] * t1[3] - array[ 9] * t1[0]; inv_.array[4] = array[ 8] * t1[4] - array[ 4] * t1[5] - array[12] * t1[3]; inv_.array[5] = array[ 0] * t1[5] - array[ 8] * t1[2] + array[12] * t1[1]; inv_.array[6] = array[ 4] * t1[2] - array[12] * t1[0] - array[ 0] * t1[4]; inv_.array[7] = array[ 0] * t1[3] - array[ 4] * t1[1] + array[ 8] * t1[0]; /* second set of 2x2 determinants: 12 multiplications, 6 additions */ const T t2[6] = { array[ 0] * array[ 5] - array[ 4] * array[ 1], array[ 0] * array[ 9] - array[ 8] * array[ 1], array[ 0] * array[13] - array[12] * array[ 1], array[ 4] * array[ 9] - array[ 8] * array[ 5], array[ 4] * array[13] - array[12] * array[ 5], array[ 8] * array[13] - array[12] * array[ 9] }; /* second half of comatrix: 24 multiplications, 16 additions */ inv_.array[8] = array[ 7] * t2[5] - array[11] * t2[4] + array[15] * t2[3]; inv_.array[9] = array[11] * t2[2] - array[15] * t2[1] - array[ 3] * t2[5]; inv_.array[10] = array[15] * t2[0] - array[ 7] * t2[2] + array[ 3] * t2[4]; inv_.array[11] = array[ 7] * t2[1] - array[ 3] * t2[3] - array[11] * t2[0]; inv_.array[12] = array[10] * t2[4] - array[ 6] * t2[5] - array[14] * t2[3]; inv_.array[13] = array[ 2] * t2[5] - array[10] * t2[2] + array[14] * t2[1]; inv_.array[14] = array[ 6] * t2[2] - array[14] * t2[0] - array[ 2] * t2[4]; inv_.array[15] = array[ 2] * t2[3] - array[ 6] * t2[1] + array[10] * t2[0]; /* determinant: 4 multiplications, 3 additions */ const T determinant = array[0] * inv_.array[0] + array[4] * inv_.array[1] + array[8] * inv_.array[2] + array[12] * inv_.array[3]; if( fabs( determinant ) <= tolerance_ ) return false; // matrix is not invertible /* division: 16 multiplications, 1 division */ const T detinv = static_cast< T >( 1.0 ) / determinant; for( size_t i = 0; i != 16; ++i ) inv_.array[i] *= detinv; return true; } // this function returns the transpose of a matrix // however, using matrix::transpose_to( .. ) avoids the copy. template< size_t M, size_t N, typename T > inline matrix< N, M, T > transpose( const matrix< M, N, T >& matrix_ ) { matrix< N, M, T > transpose_; matrix_.transpose_to( transpose_ ); return transpose_; } template< size_t M, size_t N, typename T > bool is_positive_definite( const matrix< M, N, T >& matrix_, const T limit = -1e12, typename enable_if< M == N && M <= 3 >::type* = 0 ) { if ( matrix_.at( 0, 0 ) < limit ) return false; // sylvester criterion if ( M > 1 ) { matrix< 2, 2, T > m; matrix_.get_sub_matrix( m, 0, 0 ); if ( compute_determinant( m ) < limit ) return false; } if ( M > 2 ) { matrix< 3, 3, T > m; matrix_.get_sub_matrix( m, 0, 0 ); if ( compute_determinant( m ) < limit ) return false; } return true; } template< size_t M, size_t N, typename T > matrix< M, N, T >::matrix() { // no initialization for performance reasons. } template< size_t M, size_t N, typename T > template< typename U > matrix< M, N, T >:: matrix( const matrix< M, N, U >& source_ ) { (*this) = source_; } template< size_t M, size_t N, typename T > template< size_t P, size_t Q > matrix< M, N, T >:: matrix( const matrix< P, Q, T >& source_ ) { const size_t minL = P < M ? P : M; const size_t minC = Q < N ? Q : N; (*this) = ZERO; for ( size_t i = 0 ; i < minL ; i++ ) for ( size_t j = 0 ; j < minC ; j++ ) { at( i,j ) = source_( i, j ); } } template< size_t M, size_t N, typename T > inline T& matrix< M, N, T >::at( size_t row_index, size_t col_index ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( row_index >= M || col_index >= N ) VMMLIB_ERROR( "at( row, col ) - index out of bounds", VMMLIB_HERE ); #endif return array[ col_index * M + row_index ]; } template< size_t M, size_t N, typename T > const inline T& matrix< M, N, T >::at( size_t row_index, size_t col_index ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( row_index >= M || col_index >= N ) VMMLIB_ERROR( "at( row, col ) - index out of bounds", VMMLIB_HERE ); #endif return array[ col_index * M + row_index ]; } template< size_t M, size_t N, typename T > inline T& matrix< M, N, T >::operator()( size_t row_index, size_t col_index ) { return at( row_index, col_index ); } template< size_t M, size_t N, typename T > const inline T& matrix< M, N, T >::operator()( size_t row_index, size_t col_index ) const { return at( row_index, col_index ); } #if 0 template< size_t M, size_t N, typename T > matrix< M, N, T >::matrix() { } template< size_t M, size_t N, typename T > matrix< M, N, T >::matrix( const matrix< M, N >& original ) { } #endif #ifndef VMMLIB_NO_CONVERSION_OPERATORS template< size_t M, size_t N, typename T > matrix< M, N, T >:: operator T*() { return array; } template< size_t M, size_t N, typename T > matrix< M, N, T >:: operator const T*() const { return array; } #endif template< size_t M, size_t N, typename T > bool matrix< M, N, T >:: operator==( const matrix< M, N, T >& other ) const { bool ok = true; for( size_t i = 0; ok && i < M * N; ++i ) { ok = array[ i ] == other.array[ i ]; } return ok; } template< size_t M, size_t N, typename T > bool matrix< M, N, T >:: operator!=( const matrix< M, N, T >& other ) const { return ! operator==( other ); } template< size_t M, size_t N, typename T > bool matrix< M, N, T >:: equals( const matrix< M, N, T >& other, T tolerance ) const { bool ok = true; for( size_t row_index = 0; ok && row_index < M; row_index++) { for( size_t col_index = 0; ok && col_index < N; col_index++) { ok = fabs( at( row_index, col_index ) - other( row_index, col_index ) ) < tolerance; } } return ok; } template< size_t M, size_t N, typename T > template< typename compare_t > bool matrix< M, N, T >:: equals( const matrix< M, N, T >& other_matrix, compare_t& cmp ) const { bool ok = true; for( size_t row = 0; ok && row < M; ++row ) { for( size_t col = 0; ok && col < N; ++col) { ok = cmp( at( row, col ), other_matrix.at( row, col ) ); } } return ok; } template< size_t M, size_t N, typename T > const matrix< M, N, T >& matrix< M, N, T >::operator=( const matrix& source_ ) { memcpy( array, source_.array, M * N * sizeof( T ) ); return *this; } template< size_t M, size_t N, typename T > template< typename U > void matrix< M, N, T >::operator=( const matrix< M, N, U >& source_ ) { const U* it = source_.begin(); const U* it_end = source_.end(); iterator my_it = begin(); for( ; it != it_end; ++it, ++my_it ) { *my_it = static_cast< T >( *it ); } } template< size_t M, size_t N, typename T > void matrix< M, N, T >::operator=( const T old_fashioned_matrix[ M ][ N ] ) { for( size_t row = 0; row < M; row++) { for( size_t col = 0; col < N; col++) { at( row, col ) = old_fashioned_matrix[ row ][ col ]; } } } // WARNING: data_array[] must be at least of size M * N - otherwise CRASH! // WARNING: assumes row_by_row layout - if this is not the case, // use matrix::set( data_array, false ) template< size_t M, size_t N, typename T > void matrix< M, N, T >::operator=( const T* data_array ) { set( data_array, data_array + M * N, true ); } template< size_t M, size_t N, typename T > void matrix< M, N, T >::operator=( const std::vector< T >& data ) { if ( data.size() < M * N ) VMMLIB_ERROR( "index out of bounds.", VMMLIB_HERE ); set( data.begin(), data.end(), true ); } template< size_t M, size_t N, typename T > void matrix< M, N, T >::multiply_piecewise( const matrix& other ) { for( size_t row_index = 0; row_index < M; row_index++) { for( size_t col_index = 0; col_index < N; col_index++ ) { T& value = at( row_index, col_index ); value *= other.at( row_index, col_index ); } } } template< size_t M, size_t N, typename T > template< size_t P > void matrix< M, N, T >::multiply( const matrix< M, P, T >& left, const matrix< P, N, T >& right ) { for( size_t row_index = 0; row_index < M; row_index++) { for( size_t col_index = 0; col_index < N; col_index++) { T& component = at( row_index, col_index ); component = static_cast< T >( 0.0 ); for( size_t p = 0; p < P; p++) { component += left.at( row_index, p ) * right.at( p, col_index ); } } } } template< size_t M, size_t N, typename T > template< size_t P > matrix< M, P, T > matrix< M, N, T >::operator*( const matrix< N, P, T >& other ) const { matrix< M, P, T > result; result.multiply( *this, other ); return result; } template< size_t M, size_t N, typename T > template< size_t O, size_t P, typename TT > typename enable_if< M == N && O == P && M == O, TT >::type* matrix< M, N, T >::operator*=( const matrix< O, P, TT >& right ) { matrix< M, N, T > copy( *this ); multiply( copy, right ); return 0; } template< size_t M, size_t N, typename T > matrix< M, N, T > matrix< M, N, T >::operator/( T scalar ) { matrix< M, N, T > result; for( size_t row_index = 0; row_index < M; ++row_index ) { for( size_t col_index = 0; col_index < N; ++col_index ) { result.at( row_index, col_index ) = at( row_index, col_index ) / scalar; } } return result; } template< size_t M, size_t N, typename T > void matrix< M, N, T >::operator/=( T scalar ) { for( size_t row_index = 0; row_index < M; ++row_index ) { for( size_t col_index = 0; col_index < N; ++col_index ) { at( row_index, col_index ) /= scalar; } } } template< size_t M, size_t N, typename T > matrix< M, N, T > matrix< M, N, T >::operator*( T scalar ) { matrix< M, N, T > result; for( size_t row_index = 0; row_index < M; ++row_index ) { for( size_t col_index = 0; col_index < N; ++col_index ) { result.at( row_index, col_index ) = at( row_index, col_index ) * scalar; } } return result; } template< size_t M, size_t N, typename T > void matrix< M, N, T >::operator*=( T scalar ) { for( size_t row_index = 0; row_index < M; ++row_index ) { for( size_t col_index = 0; col_index < N; ++col_index ) { at( row_index, col_index ) *= scalar; } } } template< size_t M, size_t N, typename T > vector< M, T > matrix< M, N, T >:: operator*( const vector< N, T >& other ) const { vector< M, T > result; // this < M, 1 > = < M, P > * < P, 1 > T tmp; for( size_t row_index = 0; row_index < M; row_index++) { tmp = static_cast< T >( 0.0 ); for( size_t p = 0; p < N; p++) { tmp += at( row_index, p ) * other.at( p ); } result.at( row_index ) = tmp; } return result; } // transform vector by matrix ( vec = matrix * vec ) // assume homogenous coords( for vec3 = mat4 * vec3 ), e.g. vec[3] = 1.0 template< size_t M, size_t N, typename T > template< size_t O > vector< O, T > matrix< M, N, T >:: operator*( const vector< O, T >& vector_ ) const { vector< O, T > result; T tmp; for( size_t row_index = 0; row_index < M; ++row_index ) { tmp = 0.0; for( size_t col_index = 0; col_index < N-1; ++col_index ) { tmp += vector_( col_index ) * at( row_index, col_index ); } if ( row_index < N - 1 ) result( row_index ) = tmp + at( row_index, N-1 ); // * 1.0 -> homogeneous vec4 else { tmp += at( row_index, N - 1 ); for( size_t col_index = 0; col_index < N - 1; ++col_index ) { result( col_index ) /= tmp; } } } return result; } template< size_t M, size_t N, typename T > inline matrix< M, N, T > matrix< M, N, T >::operator-() const { return negate(); } template< size_t M, size_t N, typename T > matrix< M, N, T > matrix< M, N, T >::negate() const { matrix< M, N, T > result; result *= -1.0; return result; } template< size_t M, size_t N, typename T > void matrix< M, N, T >::tensor( const vector< M, T >& u, const vector< N, T >& v ) { for ( size_t col_index = 0; col_index < N; ++col_index ) for ( size_t row_index = 0; row_index < M; ++row_index ) at( row_index, col_index ) = u.array[ col_index ] * v.array[ row_index ]; } template< size_t M, size_t N, typename T > template< size_t uM, size_t vM > typename enable_if< uM == 3 && vM == 3 && M == N && M == 4 >::type* matrix< M, N, T >::tensor( const vector< uM, T >& u, const vector< vM, T >& v ) { int i, j; for ( size_t col_index = 0; col_index < 3; ++col_index ) { for ( size_t row_index = 0; row_index < 3; ++row_index ) at( row_index, col_index ) = u.array[ col_index ] * v.array[ row_index ]; at( 3, col_index ) = u.array[ col_index ]; } for ( size_t row_index = 0; row_index < 3; ++row_index ) at( row_index, 3 ) = v.array[ row_index ]; at( 3, 3 ) = 1.0; return 0; } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: transpose_to( matrix< N, M, T >& tM ) const { for( size_t row = 0; row < M; ++row ) { for( size_t col = 0; col < N; ++col ) { tM.at( col, row ) = at( row, col ); } } } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: symmetric_covariance( matrix< M, M, T >& cov_m_ ) const { T tmp = 0; for( size_t row = 0; row < M; ++row ) { for( size_t col = row; col < M; ++col ) { for ( size_t k = 0; k < N; ++k ) { tmp += (at( row, k ) * at( col, k )); } cov_m_.at( row, col ) = tmp; cov_m_.at( col, row ) = tmp; tmp = 0; } } } template< size_t M, size_t N, typename T > vector< M, T > matrix< M, N, T >:: get_column( size_t index ) const { vector< M, T > column; get_column( index, column ); return column; } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: get_column( size_t index, vector< M, T >& column ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( index >= N ) VMMLIB_ERROR( "get_column() - index out of bounds.", VMMLIB_HERE ); #endif memcpy( &column.array[0], &array[ M * index ], M * sizeof( T ) ); } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: set_column( size_t index, const vector< M, T >& column ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( index >= N ) VMMLIB_ERROR( "set_column() - index out of bounds.", VMMLIB_HERE ); #endif memcpy( array + M * index, column.array, M * sizeof( T ) ); } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: get_column( size_t index, matrix< M, 1, T >& column ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( index >= N ) VMMLIB_ERROR( "get_column() - index out of bounds.", VMMLIB_HERE ); #endif memcpy( column.array, array + M * index, M * sizeof( T ) ); } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: set_column( size_t index, const matrix< M, 1, T >& column ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( index >= N ) VMMLIB_ERROR( "set_column() - index out of bounds.", VMMLIB_HERE ); #endif memcpy( &array[ M * index ], column.array, M * sizeof( T ) ); } template< size_t M, size_t N, typename T > vector< N, T > matrix< M, N, T >:: get_row( size_t index ) const { vector< N, T > row; get_row( index, row ); return row; } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: get_row( size_t row_index, vector< N, T >& row ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( row_index >= M ) VMMLIB_ERROR( "get_row() - index out of bounds.", VMMLIB_HERE ); #endif for( size_t col_index = 0; col_index < N; ++col_index ) { row.at( col_index ) = at( row_index, col_index ); } } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: set_row( size_t row_index, const vector< N, T >& row ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( row_index >= M ) VMMLIB_ERROR( "set_row() - index out of bounds.", VMMLIB_HERE ); #endif for( size_t col_index = 0; col_index < N; ++col_index ) { at( row_index, col_index ) = row.at( col_index ); } } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: get_row( size_t row_index, matrix< 1, N, T >& row ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( row_index >= M ) VMMLIB_ERROR( "get_row() - index out of bounds.", VMMLIB_HERE ); #endif for( size_t col_index = 0; col_index < N; ++col_index ) { row.at( 0, col_index ) = at( row_index, col_index ); } } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: set_row( size_t row_index, const matrix< 1, N, T >& row ) { #ifdef VMMLIB_SAFE_ACCESSORS if ( row_index >= M ) VMMLIB_ERROR( "set_row() - index out of bounds.", VMMLIB_HERE ); #endif for( size_t col_index = 0; col_index < N; ++col_index ) { at( row_index, col_index ) = row.at( 0, col_index ); } } /* template< size_t M, size_t N, typename T > matrix< 1, N, T >& matrix< M, N, T >:: operator[]( size_t row_index ) { if ( row_index >= M ) throw "FIXME."; assert( row_index < M ); return _rows[ row_index ]; } template< size_t M, size_t N, typename T > const matrix< 1, N, T >& matrix< M, N, T >:: operator[]( size_t row_index ) const { if ( row_index >= M ) throw "FIXME."; assert( row_index < M ); return _rows[ row_index ]; } */ template< size_t M, size_t N, typename T > size_t matrix< M, N, T >:: get_number_of_rows() const { return M; } template< size_t M, size_t N, typename T > size_t matrix< M, N, T >:: get_number_of_columns() const { return N; } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: fill( T fillValue ) { for( size_t row_index = 0; row_index < M; ++row_index ) { for( size_t col_index = 0; col_index < N; ++col_index ) { at( row_index, col_index ) = fillValue; } } } template< size_t M, size_t N, typename T > inline T& matrix< M, N, T >::x() { return array[ 12 ]; } template< size_t M, size_t N, typename T > inline T& matrix< M, N, T >::y() { return array[ 13 ]; } template< size_t M, size_t N, typename T > inline T& matrix< M, N, T >::z() { return array[ 14 ]; } template< size_t M, size_t N, typename T > template< typename input_iterator_t > void matrix< M, N, T >:: set( input_iterator_t begin_, input_iterator_t end_, bool row_major_layout ) { input_iterator_t it( begin_ ); if( row_major_layout ) { for( size_t row = 0; row < M; ++row ) { for( size_t col = 0; col < N; ++col, ++it ) { if ( it == end_ ) return; at( row, col ) = static_cast< T >( *it ); } } } else { std::copy( it, it + ( M * N ), begin() ); } } template< size_t M, size_t N, typename T > void matrix< M, N, T >::zero() { fill( static_cast< T >( 0.0 ) ); } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: operator=( T value_ ) { std::fill( begin(), end(), value_ ); } template< size_t M, size_t N, typename T > inline matrix< M, N, T > matrix< M, N, T >:: operator+( const matrix< M, N, T >& other ) const { matrix< M, N, T > result( *this ); result += other; return result; } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: operator+=( const matrix< M, N, T >& other ) { iterator it = begin(), it_end = end(); const_iterator other_it = other.begin(); for( ; it != it_end; ++it, ++other_it ) { *it += *other_it; } } template< size_t M, size_t N, typename T > void matrix< M, N, T >::operator+=( T scalar ) { iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) { *it += scalar; } } template< size_t M, size_t N, typename T > inline matrix< M, N, T > matrix< M, N, T >:: operator-( const matrix< M, N, T >& other ) const { matrix< M, N, T > result( *this ); result -= other; return result; } template< size_t M, size_t N, typename T > void matrix< M, N, T >:: operator-=( const matrix< M, N, T >& other ) { iterator it = begin(), it_end = end(); const_iterator other_it = other.begin(); for( ; it != it_end; ++it, ++other_it ) { *it -= *other_it; } } template< size_t M, size_t N, typename T > void matrix< M, N, T >::operator-=( T scalar ) { iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) { *it -= scalar; } } template< size_t M, size_t N, typename T > template< size_t O, size_t P, size_t Q, size_t R > typename enable_if< M == O + Q && N == P + R >::type* matrix< M, N, T >:: direct_sum( const matrix< O, P, T >& upper_left, const matrix< Q, R, T >& lower_right ) { (*this) = static_cast< T >( 0.0 ); for( size_t row = 0; row < O; ++row ) { for( size_t col = 0; col < P; ++col ) { at( row, col ) = upper_left( row, col ); } } for( size_t row = 0; row < Q; ++row ) { for( size_t col = 0; col < R; ++col ) { at( O + row, P + col ) = lower_right( row, col ); } } return 0; } template< size_t M, size_t N, typename T > template< size_t O, size_t P > matrix< O, P, T > matrix< M, N, T >:: get_sub_matrix( size_t row_offset, size_t col_offset, typename enable_if< O <= M && P <= N >::type* ) const { matrix< O, P, T > result; get_sub_matrix( result, row_offset, col_offset ); return result; } template< size_t M, size_t N, typename T > template< size_t O, size_t P > typename enable_if< O <= M && P <= N >::type* matrix< M, N, T >:: get_sub_matrix( matrix< O, P, T >& result, size_t row_offset, size_t col_offset ) const { #ifdef VMMLIB_SAFE_ACCESSORS if ( O + row_offset > M || P + col_offset > N ) VMMLIB_ERROR( "index out of bounds.", VMMLIB_HERE ); #endif for( size_t row = 0; row < O; ++row ) { for( size_t col = 0; col < P; ++col ) { result.at( row, col ) = at( row_offset + row, col_offset + col ); } } return 0; } template< size_t M, size_t N, typename T > template< size_t O, size_t P > typename enable_if< O <= M && P <= N >::type* matrix< M, N, T >:: set_sub_matrix( const matrix< O, P, T >& sub_matrix, size_t row_offset, size_t col_offset ) { for( size_t row = 0; row < O; ++row ) { for( size_t col = 0; col < P; ++col ) { at( row_offset + row, col_offset + col ) = sub_matrix.at( row, col ); } } return 0; // for sfinae } template< size_t M, size_t N, typename T > inline T matrix< M, N, T >::det() const { return compute_determinant( *this ); } template< size_t M, size_t N, typename T > template< size_t O, size_t P, typename TT > inline bool matrix< M, N, T >::inverse( matrix< O, P, TT >& inverse_, T tolerance, typename enable_if< M == N && O == P && O == M && M >= 2 && M <= 4, TT >::type* ) const { return compute_inverse( *this, inverse_, tolerance ); } template< size_t M, size_t N, typename T > template< size_t O, size_t P > typename enable_if< O == P && M == N && O == M && M >= 2 >::type* matrix< M, N, T >:: get_adjugate( matrix< O, P, T >& adjugate ) const { get_cofactors( adjugate ); adjugate = transpose( adjugate ); return 0; } template< size_t M, size_t N, typename T > template< size_t O, size_t P > typename enable_if< O == P && M == N && O == M && M >= 2 >::type* matrix< M, N, T >:: get_cofactors( matrix< O, P, T >& cofactors ) const { matrix< M-1, N-1, T > minor_; const size_t _negate = 1u; for( size_t row_index = 0; row_index < M; ++row_index ) { for( size_t col_index = 0; col_index < N; ++col_index ) { if ( ( row_index + col_index ) & _negate ) cofactors( row_index, col_index ) = -get_minor( minor_, row_index, col_index ); else cofactors( row_index, col_index ) = get_minor( minor_, row_index, col_index ); } } return 0; } template< size_t M, size_t N, typename T > template< size_t O, size_t P > T matrix< M, N, T >:: get_minor( matrix< O, P, T >& minor_, size_t row_to_cut, size_t col_to_cut, typename enable_if< O == M-1 && P == N-1 && M == N && M >= 2 >::type* ) const { ssize_t row_offset = 0; ssize_t col_offset = 0; for( ssize_t row_index = 0; row_index < M; ++row_index ) { if ( row_index == row_to_cut ) row_offset = -1; else { for( ssize_t col_index = 0; col_index < M; ++col_index ) { if ( col_index == col_to_cut ) col_offset = -1; else minor_.at( row_index + row_offset, col_index + col_offset ) = at( row_index, col_index ); } col_offset = 0; } } return compute_determinant( minor_ ); } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: rotate( const TT angle_, const vector< M-1, T >& axis, typename enable_if< M == N && M == 4, TT >::type* ) { const T angle = static_cast< T >( angle_ ); const T sine = sin( angle ); const T cosine = cos( angle ); // this is necessary since Visual Studio cannot resolve the // pow()-call correctly if we just use 2.0 directly. // this way, the '2.0' is converted to the same format // as the axis components const T _zero = 0.0; const T one = 1.0; const T two = 2.0; array[0] = cosine + ( one - cosine ) * pow( axis.array[0], two ); array[1] = ( one - cosine ) * axis.array[0] * axis.array[1] + sine * axis.array[2]; array[2] = ( one - cosine ) * axis.array[0] * axis.array[2] - sine * axis.array[1]; array[3] = _zero; array[4] = ( one - cosine ) * axis.array[0] * axis.array[1] - sine * axis.array[2]; array[5] = cosine + ( one - cosine ) * pow( axis.array[1], two ); array[6] = ( one - cosine ) * axis.array[1] * axis.array[2] + sine * axis.array[0]; array[7] = _zero; array[8] = ( one - cosine ) * axis.array[0] * axis.array[2] + sine * axis.array[1]; array[9] = ( one - cosine ) * axis.array[1] * axis.array[2] - sine * axis.array[0]; array[10] = cosine + ( one - cosine ) * pow( axis.array[2], two ); array[11] = _zero; array[12] = _zero; array[13] = _zero; array[14] = _zero; array[15] = one; } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: rotate_x( const TT angle_, typename enable_if< M == N && M == 4, TT >::type* ) { const T angle = static_cast< T >( angle_ ); const T sine = sin( angle ); const T cosine = cos( angle ); T tmp; tmp = array[ 4 ] * cosine + array[ 8 ] * sine; array[ 8 ] = - array[ 4 ] * sine + array[ 8 ] * cosine; array[ 4 ] = tmp; tmp = array[ 5 ] * cosine + array[ 9 ] * sine; array[ 9 ] = - array[ 5 ] * sine + array[ 9 ] * cosine; array[ 5 ] = tmp; tmp = array[ 6 ] * cosine + array[ 10 ] * sine; array[ 10 ] = - array[ 6 ] * sine + array[ 10 ] * cosine; array[ 6 ] = tmp; tmp = array[ 7 ] * cosine + array[ 11 ] * sine; array[ 11 ] = - array[ 7 ] * sine + array[ 11 ] * cosine; array[ 7 ] = tmp; } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: rotate_y( const TT angle_, typename enable_if< M == N && M == 4, TT >::type* ) { const T angle = static_cast< T >( angle_ ); const T sine = sin( angle ); const T cosine = cos( angle ); T tmp; tmp = array[ 0 ] * cosine - array[ 8 ] * sine; array[ 8 ] = array[ 0 ] * sine + array[ 8 ] * cosine; array[ 0 ] = tmp; tmp = array[ 1 ] * cosine - array[ 9 ] * sine; array[ 9 ] = array[ 1 ] * sine + array[ 9 ] * cosine; array[ 1 ] = tmp; tmp = array[ 2 ] * cosine - array[ 10 ] * sine; array[ 10 ] = array[ 2 ] * sine + array[ 10 ] * cosine; array[ 2 ] = tmp; tmp = array[ 3 ] * cosine - array[ 11 ] * sine; array[ 11 ] = array[ 3 ] * sine + array[ 11 ] * cosine; array[ 3 ] = tmp; } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: rotate_z( const TT angle_, typename enable_if< M == N && M == 4, TT >::type* ) { const T angle = static_cast< T >( angle_ ); const T sine = sin( angle ); const T cosine = cos( angle ); T tmp; tmp = array[ 0 ] * cosine + array[ 4 ] * sine; array[ 4 ] = - array[ 0 ] * sine + array[ 4 ] * cosine; array[ 0 ] = tmp; tmp = array[ 1 ] * cosine + array[ 5 ] * sine; array[ 5 ] = - array[ 1 ] * sine + array[ 5 ] * cosine; array[ 1 ] = tmp; tmp = array[ 2 ] * cosine + array[ 6 ] * sine; array[ 6 ] = - array[ 2 ] * sine + array[ 6 ] * cosine; array[ 2 ] = tmp; tmp = array[ 3 ] * cosine + array[ 7 ] * sine; array[ 7 ] = - array[ 3 ] * sine + array[ 7 ] * cosine; array[ 3 ] = tmp; } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: pre_rotate_x( const TT angle_, typename enable_if< M == N && M == 4, TT >::type* ) { const T angle = static_cast< T >( angle_ ); const T sine = sin( angle ); const T cosine = cos( angle ); T tmp; tmp = array[ 1 ]; array[ 1 ] = array[ 1 ] * cosine + array[ 2 ] * sine; array[ 2 ] = tmp * -sine + array[ 2 ] * cosine; tmp = array[ 5 ]; array[ 5 ] = array[ 5 ] * cosine + array[ 6 ] * sine; array[ 6 ] = tmp * -sine + array[ 6 ] * cosine; tmp = array[ 9 ]; array[ 9 ] = array[ 9 ] * cosine + array[ 10 ] * sine; array[ 10 ] = tmp * -sine + array[ 10 ] * cosine; tmp = array[ 13 ]; array[ 13 ] = array[ 13 ] * cosine + array[ 14 ] * sine; array[ 14 ] = tmp * -sine + array[ 14 ] * cosine; } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: pre_rotate_y( const TT angle_, typename enable_if< M == N && M == 4, TT >::type* ) { const T angle = static_cast< T >( angle_ ); const T sine = sin( angle ); const T cosine = cos( angle ); T tmp; tmp = array[ 0 ]; array[ 0 ] = array[ 0 ] * cosine - array[ 2 ] * sine; array[ 2 ] = tmp * sine + array[ 2 ] * cosine; tmp = array[ 4 ]; array[ 4 ] = array[ 4 ] * cosine - array[ 6 ] * sine; array[ 6 ] = tmp * sine + array[ 6 ] * cosine; tmp = array[ 8 ]; array[ 8 ] = array[ 8 ] * cosine - array[ 10 ] * sine; array[ 10 ] = tmp * sine + array[ 10 ] * cosine; tmp = array[ 12 ]; array[ 12 ] = array[ 12 ] * cosine - array[ 14 ] * sine; array[ 14 ] = tmp * sine + array[ 14 ] * cosine; } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: pre_rotate_z( const TT angle_, typename enable_if< M == N && M == 4, TT >::type* ) { const T angle = static_cast< T >( angle_ ); const T sine = sin( angle ); const T cosine = cos( angle ); T tmp; tmp = array[ 0 ]; array[ 0 ] = array[ 0 ] * cosine + array[ 1 ] * sine; array[ 1 ] = tmp * -sine + array[ 1 ] * cosine; tmp = array[ 4 ]; array[ 4 ] = array[ 4 ] * cosine + array[ 5 ] * sine; array[ 5 ] = tmp * -sine + array[ 5 ] * cosine; tmp = array[ 8 ]; array[ 8 ] = array[ 8 ] * cosine + array[ 9 ] * sine; array[ 9 ] = tmp * -sine + array[ 9 ] * cosine; tmp = array[ 12 ]; array[ 12 ] = array[ 12 ] * cosine + array[ 13 ] * sine; array[ 13 ] = tmp * -sine + array[ 13 ] * cosine; } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: scale( const TT _scale[3], typename enable_if< M == N && M == 4, TT >::type* ) { const T scale0 = static_cast< T >( _scale[ 0 ] ); const T scale1 = static_cast< T >( _scale[ 1 ] ); const T scale2 = static_cast< T >( _scale[ 2 ] ); array[0] *= scale0; array[1] *= scale0; array[2] *= scale0; array[3] *= scale0; array[4] *= scale1; array[5] *= scale1; array[6] *= scale1; array[7] *= scale1; array[8] *= scale2; array[9] *= scale2; array[10] *= scale2; array[11] *= scale2; } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: scale( const TT x_, const T y_, const T z_, typename enable_if< M == N && M == 4, TT >::type* ) { const T _x = static_cast< T >( x_ ); array[0] *= _x; array[1] *= _x; array[2] *= _x; array[3] *= _x; array[4] *= y_; array[5] *= y_; array[6] *= y_; array[7] *= y_; array[8] *= z_; array[9] *= z_; array[10] *= z_; array[11] *= z_; } template< size_t M, size_t N, typename T > template< typename TT > inline void matrix< M, N, T >:: scale( const vector< 3, TT >& scale_, typename enable_if< M == N && M == 4, TT >::type* ) { scale( scale_.array ); } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >:: scale_translation( const TT scale_[3], typename enable_if< M == N && M == 4, TT >::type* ) { array[12] *= static_cast< T >( scale_[0] ); array[13] *= static_cast< T >( scale_[1] ); array[14] *= static_cast< T >( scale_[2] ); } template< size_t M, size_t N, typename T > template< typename TT > inline void matrix< M, N, T >:: scale_translation( const vector< 3, TT >& scale_, typename enable_if< M == N && M == 4, TT >::type* ) { scale_translation( scale_.array ); } template< size_t M, size_t N, typename T > template< typename TT > inline void matrix< M, N, T >:: set_translation( const TT x_, const TT y_, const TT z_, typename enable_if< M == N && M == 4, TT >::type* ) { array[12] = static_cast< T >( x_ ); array[13] = static_cast< T >( y_ ); array[14] = static_cast< T >( z_ ); } template< size_t M, size_t N, typename T > template< typename TT > inline void matrix< M, N, T >:: set_translation( const TT trans[3], typename enable_if< M == N && M == 4, TT >::type* ) { array[12] = static_cast< T >( trans[ 0 ] ); array[13] = static_cast< T >( trans[ 1 ] ); array[14] = static_cast< T >( trans[ 2 ] ); } template< size_t M, size_t N, typename T > template< typename TT > inline void matrix< M, N, T >:: set_translation( const vector< 3, TT >& translation_, typename enable_if< M == N && M == 4, TT >::type* ) { set_translation( translation_.array ); } template< size_t M, size_t N, typename T > template< typename TT > inline void matrix< M, N, T >:: get_translation( vector< 3, TT >& translation_, typename enable_if< M == N && M == 4, TT >::type* ) const { translation_.array[ 0 ] = array[ 12 ]; translation_.array[ 1 ] = array[ 13 ]; translation_.array[ 2 ] = array[ 14 ]; } template< size_t M, size_t N, typename T > size_t matrix< M, N, T >:: size() const { return M * N; } template< size_t M, size_t N, typename T > typename matrix< M, N, T >::iterator matrix< M, N, T >:: begin() { return array; } template< size_t M, size_t N, typename T > typename matrix< M, N, T >::iterator matrix< M, N, T >:: end() { return array + size(); } template< size_t M, size_t N, typename T > typename matrix< M, N, T >::const_iterator matrix< M, N, T >:: begin() const { return array; } template< size_t M, size_t N, typename T > typename matrix< M, N, T >::const_iterator matrix< M, N, T >:: end() const { return array + size(); } template< size_t M, size_t N, typename T > typename matrix< M, N, T >::reverse_iterator matrix< M, N, T >:: rbegin() { return array + size() - 1; } template< size_t M, size_t N, typename T > typename matrix< M, N, T >::reverse_iterator matrix< M, N, T >:: rend() { return array - 1; } template< size_t M, size_t N, typename T > typename matrix< M, N, T >::const_reverse_iterator matrix< M, N, T >:: rbegin() const { return array + size() - 1; } template< size_t M, size_t N, typename T > typename matrix< M, N, T >::const_reverse_iterator matrix< M, N, T >:: rend() const { return array - 1; } template< size_t M, size_t N, typename T > template< typename init_functor_t > const matrix< M, N, T > matrix< M, N, T >::get_initialized_matrix() { matrix< M, N, T > matrix_; init_functor_t()( matrix_ ); return matrix_; } // it's ugly, but it allows having properly initialized static members // without having to worry about static initialization order. template< size_t M, size_t N, typename T > const matrix< M, N, T > matrix< M, N, T >::IDENTITY( matrix< M, N, T >:: get_initialized_matrix< set_to_identity_functor< matrix< M, N, T > > >() ); template< size_t M, size_t N, typename T > const matrix< M, N, T > matrix< M, N, T >::ZERO( matrix< M, N, T >:: get_initialized_matrix< set_to_zero_functor< matrix< M, N, T > > >() ); template< size_t M, size_t N, typename T > double matrix< M, N, T >::frobenius_norm( ) const { double norm = 0.0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) { norm += *it * *it; } return sqrt(norm); } template< size_t M, size_t N, typename T > template< size_t O > void matrix< M, N, T >::khatri_rao_product( const matrix< O, N, T >& right_, matrix< M*O, N, T >& prod_ ) const { //build product for every column for (size_t col = 0; col < N; ++col ) { for ( size_t m = 0; m < M; ++m ) { for (size_t o = 0; o < O; ++o ) { prod_.at(O*m + o, col) = at( m, col ) * right_.at( o, col ); } } } } template< size_t M, size_t N, typename T > template< size_t O, size_t P > void matrix< M, N, T >::kronecker_product( const matrix< O, P, T >& right_, matrix< M*O, N*P, T >& result_ ) const { //build product for every column for (size_t m = 0; m < M; ++m ) { for ( size_t n = 0; n < N; ++n ) { for (size_t o = 0; o < O; ++o ) { for (size_t p = 0; p < P; ++p ) { result_.at(O*m + o, P*n + p) = at( m, n ) * right_.at( o, p ); } } } } } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >::cast_from( const matrix< M, N, TT >& other ) { typedef vmml::matrix< M, N, TT > matrix_tt_type ; typedef typename matrix_tt_type::const_iterator tt_const_iterator; iterator it = begin(), it_end = end(); tt_const_iterator other_it = other.begin(); for( ; it != it_end; ++it, ++other_it ) { *it = static_cast< T >( *other_it ); } } template< size_t M, size_t N, typename T > T matrix< M, N, T >::get_min() const { T min_value = static_cast(std::numeric_limits::max()); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( *it < min_value ) { min_value = *it; } } return min_value; } template< size_t M, size_t N, typename T > T matrix< M, N, T >::get_max() const { T max_value = static_cast(0); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( *it > max_value ) { max_value = *it; } } return max_value; } template< size_t M, size_t N, typename T > T matrix< M, N, T >::get_abs_min() const { T min_value = static_cast(std::numeric_limits::max()); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( fabs(*it) < fabs(min_value) ) { min_value = fabs(*it); } } return min_value; } template< size_t M, size_t N, typename T > T matrix< M, N, T >::get_abs_max() const { T max_value = static_cast(0); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( fabs(*it) > fabs(max_value) ) { max_value = fabs(*it); } } return max_value; } template< size_t M, size_t N, typename T > size_t matrix< M, N, T >::nnz() const { size_t counter = 0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( *it != 0 ) { ++counter; } } return counter; } template< size_t M, size_t N, typename T > size_t matrix< M, N, T >::nnz( const T& threshold_ ) const { size_t counter = 0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( fabs(*it) > threshold_ ) { ++counter; } } return counter; } template< size_t M, size_t N, typename T > void matrix< M, N, T >::threshold( const T& threshold_value_ ) { iterator it = begin(), it_end = end(); for( ; it != it_end; ++it) { if ( fabs(*it) <= threshold_value_ ) { *it = static_cast (0); } } } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >::quantize_to( matrix< M, N, TT >& quantized_, const T& min_value, const T& max_value ) const { long max_tt_range = long(std::numeric_limits< TT >::max()); long min_tt_range = long(std::numeric_limits< TT >::min()); long tt_range = (max_tt_range - min_tt_range); T t_range = max_value - min_value; typedef matrix< M, N, TT > m_tt_type ; typedef typename m_tt_type::iterator tt_iterator; tt_iterator it_quant = quantized_.begin(); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it, ++it_quant ) { if (std::numeric_limits::is_signed ) { *it_quant = TT( std::min( std::max( min_tt_range, long(( *it * tt_range / t_range ) + 0.5)), max_tt_range )); } else { *it_quant = TT( std::min( std::max( min_tt_range, long(((*it - min_value) * tt_range / t_range) + 0.5)), max_tt_range )); } } } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >::quantize( matrix< M, N, TT >& quantized_, T& min_value, T& max_value ) const { min_value = get_min(); max_value = get_max(); quantize_to( quantized_, min_value, max_value ); } template< size_t M, size_t N, typename T > template< typename TT > void matrix< M, N, T >::dequantize( matrix< M, N, TT >& dequantized_, const TT& min_value, const TT& max_value ) const { long max_t_range = long(std::numeric_limits< T >::max()); long min_t_range = long(std::numeric_limits< T >::min()); long t_range = (max_t_range - min_t_range); TT tt_range = max_value - min_value; typedef matrix< M, N, TT > m_tt_type ; typedef typename m_tt_type::iterator tt_iterator; tt_iterator it_dequant = dequantized_.begin(); const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it, ++it_dequant ) { if (std::numeric_limits::is_signed ) { *it_dequant = std::min( std::max( min_value, TT((TT(*it) / t_range) * tt_range)), max_value ); } else { *it_dequant = std::min( std::max( min_value, TT((((TT(*it) / t_range)) * tt_range ) + min_value)), max_value ); } } } template< size_t M, size_t N, typename T > void matrix< M, N, T >::columnwise_sum( vector< N, T>& summed_columns_ ) const { for ( size_t n = 0; n < N; ++n ) { T value = 0; for ( size_t m = 0; m < M; ++m ) { value += at( m, n ); } summed_columns_.at( n ) = value; } } template< size_t M, size_t N, typename T > double matrix< M, N, T >::sum_elements( ) const { double sum = 0.0; const_iterator it = begin(), it_end = end(); for( ; it != it_end; ++it ) { sum += *it; } return sum; } template< size_t M, size_t N, typename T > template< size_t R> typename enable_if< R == M && R == N>::type* matrix< M, N, T >::diag( const vector< R, T >& diag_values_ ) { zero(); for( size_t r = 0; r < R; ++r ) { at(r, r) = static_cast< T >( diag_values_.at(r) ); } return 0; } template< size_t M, size_t N, typename T > void matrix< M, N, T >::set_dct() { double weight = 0.0f; double num_rows = M; double fill_value = 0.0f; for( size_t row = 0; row < M; ++row ) { weight = ( row == 0.0 ) ? sqrt(1/num_rows) : sqrt(2/num_rows); //to reiceive orthonormality for( size_t col = 0; col < N; ++col ) { fill_value = (2 * col + 1) * row * M_PI / (2*M); fill_value = cos( fill_value ); fill_value *= weight; at( row, col ) = static_cast< T >( fill_value ) ; } } } template< size_t M, size_t N, typename T > void matrix< M, N, T >::set_random( int seed ) { if ( seed >= 0 ) srand( seed ); double fillValue = 0.0f; for( size_t row = 0; row < M; ++row ) { for( size_t col = 0; col < N; ++col ) { fillValue = rand(); fillValue /= RAND_MAX; at( row, col ) = -1.0 + 2.0 * static_cast< double >( fillValue ) ; } } } template< size_t M, size_t N, typename T > void matrix< M, N, T >::write_csv_file( const std::string& dir_, const std::string& filename_ ) const { int dir_length = dir_.size() -1; int last_separator = dir_.find_last_of( "/"); std::string path = dir_; if (last_separator < dir_length ) { path.append( "/" ); } path.append( filename_ ); //check for format if( filename_.find( "csv", filename_.size() -3) == (-1)) { path.append( "."); path.append( "csv" ); } std::ofstream outfile; outfile.open( path.c_str() ); if( outfile.is_open() ) { outfile << *this << std::endl; outfile.close(); } else { std::cout << "no file open" << std::endl; } } template< size_t M, size_t N, typename T > bool matrix< M, N, T >::is_valid() const { bool valid = true; for( const_iterator it = begin(); valid && it != end(); ++it ) { if ( std::isnan( *it ) ) valid = false; if ( std::isinf( *it ) ) valid = false; } #ifdef VMMLIB_THROW_EXCEPTIONS if ( ! valid ) VMMLIB_ERROR( "matrix contains nan or inf.", VMMLIB_HERE ); #endif return valid; } template< size_t M, size_t N, typename T > void matrix< M, N, T >::sum_rows( matrix< M/2, N, T>& other ) const { typedef vector< N, T > row_type; row_type* row0 = new row_type; row_type* row1 = new row_type; other.zero(); for ( size_t row = 0; row < M; ++row ) { get_row( row++, *row0 ); if ( row < M ) { get_row( row, *row1 ); *row0 += *row1; other.set_row( row/2 , *row0 ); } } delete row0; delete row1; } template< size_t M, size_t N, typename T > void matrix< M, N, T >::sum_columns( matrix< M, N/2, T>& other ) const { typedef vector< M, T > col_type; col_type* col0 = new col_type; col_type* col1 = new col_type; other.zero(); for ( size_t col = 0; col< N; ++col ) { get_column( col++, *col0 ); if ( col < N ) { get_column( col, *col1 ); *col0 += *col1; other.set_column( col/2, *col0 ); } } delete col0; delete col1; } } // namespace vmml #endif vmmlib-1.0/include/vmmlib/qr_decomposition.hpp0000644000175000017500000000354611674116156021214 0ustar shevekshevek#ifndef __VMML__QR_DECOMPOSITION__HPP__ #define __VMML__QR_DECOMPOSITION__HPP__ #include #include #include #include #include /* * QR decomposition using stabilized gram-schmidt * A -> matrix to be factorized * Q -> orthonormal * Rn -> upper triangular */ namespace vmml { template< size_t M, size_t N, typename T > void qr_decompose_gram_schmidt( const matrix< M, N, T >& A_, matrix< M, M, T >& Q, matrix< N, N, T >& R ) { Q = 0.0; R = 0.0; // create a copy of A_ since we will change it in the algorithm matrix< M, N, T > A( A_ ); vector< M, T > a_column, q_column; #if 0 // for each column for( size_t k = 0; k < N; ++k ) { // compute norm of A's column k A.get_column( k, a_column ); const T a_norm = a_column.length(); R.at( k, k ) = a_norm; if ( a_norm == static_cast< T >( 0.0 ) ) break; Q.set_column( k, a_column / a_norm ); for( size_t j = k+1; j < N; ++j ) { Q.get_column( k, q_column ); A.get_column( j, a_column ); R.at( k, j ) = a_column.dot( q_column ); for( size_t i = 0; i < M; ++i ) { A( i, j ) = A( i, j ) - R( k, j ) * Q( i, k ); } } } #else vector< M, T > v; for( int j = 0; j < N; ++j ) { A.get_column( j, v ); for( int i = 0; i < j; ++i ) { Q.get_column( i, q_column ); A.get_column( j, a_column ); R( i, j ) = dot( q_column, a_column ); v -= q_column * R(i,j); } R(j,j) = v.length(); Q.set_column( j, v / R(j,j) ); } #endif } } // namespace vmml #endif vmmlib-1.0/include/vmmlib/lapack_linear_least_squares.hpp0000644000175000017500000001704211674116156023352 0ustar shevekshevek#ifndef __VMML__VMMLIB_LAPACK_LINEAR_LEAST_SQUARES__HPP__ #define __VMML__VMMLIB_LAPACK_LINEAR_LEAST_SQUARES__HPP__ #include #include #include #include #include #include /** * * this is a wrapper for the following lapack routines: * * xGELS * * */ namespace vmml { // XYYZZZ // X = data type: S - float, D - double // YY = matrix type, GE - general, TR - triangular // ZZZ = function name namespace lapack { // // // SGELS/DGELS // // // parameter struct template< typename float_t > struct llsq_params_xgels { char trans; // 'N'->A, 'T'->Atransposed lapack_int m; // number of rows, M >= 0 lapack_int n; // number of columns, N >= 0 lapack_int nrhs; // number of columns of B/X float_t* a; // input A lapack_int lda; // leading dimension of A (number of rows) float_t* b; // input B, output X lapack_int ldb; // leading dimension of b float_t* work; // workspace lapack_int lwork; // workspace size lapack_int info; // 'return' value friend std::ostream& operator << ( std::ostream& os, const llsq_params_xgels< float_t >& p ) { os << " m " << p.m << " n " << p.n << " nrhs " << p.nrhs << " lda " << p.lda << " ldb " << p.ldb << " lwork " << p.lwork << " info " << p.info << std::endl; return os; } }; // call wrappers #if 0 void dgels_(const char *trans, const int *M, const int *N, const int *nrhs, double *A, const int *lda, double *b, const int *ldb, double *work, const int * lwork, int *info); #endif template< typename float_t > inline void llsq_call_xgels( llsq_params_xgels< float_t >& p ) { VMMLIB_ERROR( "not implemented for this type.", VMMLIB_HERE ); } template<> inline void llsq_call_xgels( llsq_params_xgels< float >& p ) { sgels_( &p.trans, &p.m, &p.n, &p.nrhs, p.a, &p.lda, p.b, &p.ldb, p.work, &p.lwork, &p.info ); } template<> inline void llsq_call_xgels( llsq_params_xgels< double >& p ) { dgels_( &p.trans, &p.m, &p.n, &p.nrhs, p.a, &p.lda, p.b, &p.ldb, p.work, &p.lwork, &p.info ); } template< size_t M, size_t N, typename float_t > struct linear_least_squares_xgels { bool compute( const matrix< M, N, float_t >& A, const vector< M, float_t >& B, vector< N, float_t >& x ); linear_least_squares_xgels(); ~linear_least_squares_xgels(); const lapack::llsq_params_xgels< float_t >& get_params(){ return p; }; matrix< M, N, float_t >& get_factorized_A() { return _A; } protected: matrix< M, N, float_t > _A; vector< M, float_t > _b; llsq_params_xgels< float_t > p; }; template< size_t M, size_t N, typename float_t > bool linear_least_squares_xgels< M, N, float_t >::compute( const matrix< M, N, float_t >& A, const vector< M, float_t >& B, vector< N, float_t >& x ) { _A = A; _b = B; llsq_call_xgels( p ); // success if ( p.info == 0 ) { for( size_t index = 0; index < N; ++index ) { x( index ) = _b( index ); } return true; } if ( p.info < 0 ) { VMMLIB_ERROR( "xGELS - invalid argument.", VMMLIB_HERE ); } else { std::cout << "A\n" << A << std::endl; std::cout << "B\n" << B << std::endl; VMMLIB_ERROR( "least squares solution could not be computed.", VMMLIB_HERE ); } return false; } template< size_t M, size_t N, typename float_t > linear_least_squares_xgels< M, N, float_t >:: linear_least_squares_xgels() { p.trans = 'N'; p.m = M; p.n = N; p.nrhs = 1; p.a = _A.array; p.lda = M; p.b = _b.array; p.ldb = M; p.work = new float_t(); p.lwork = -1; // workspace query llsq_call_xgels( p ); p.lwork = static_cast< lapack_int > ( p.work[0] ); delete p.work; p.work = new float_t[ p.lwork ]; } template< size_t M, size_t N, typename float_t > linear_least_squares_xgels< M, N, float_t >:: ~linear_least_squares_xgels() { delete[] p.work; } // // // SGESV/DGESV // // template< typename float_t > struct llsq_params_xgesv { lapack_int n; // order of matrix A = M * N lapack_int nrhs; // number of columns of B float_t* a; // input A, output P*L*U lapack_int lda; // leading dimension of A (for us: number of rows) lapack_int* ipiv; // pivot indices, integer array of size N float_t* b; // input b, output X lapack_int ldb; // leading dimension of b lapack_int info; friend std::ostream& operator << ( std::ostream& os, const llsq_params_xgesv< float_t >& p ) { os << "n " << p.n << " nrhs " << p.nrhs << " lda " << p.lda << " ldb " << p.ldvt << " info " << p.info << std::endl; return os; } }; #if 0 /* Subroutine */ int dgesv_(integer *n, integer *nrhs, doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *ldb, integer *info); #endif template< typename float_t > inline void llsq_call_xgesv( llsq_params_xgesv< float_t >& p ) { VMMLIB_ERROR( "not implemented for this type.", VMMLIB_HERE ); } template<> inline void llsq_call_xgesv( llsq_params_xgesv< float >& p ) { sgesv_( &p.n, &p.nrhs, p.a, &p.lda, p.ipiv, p.b, &p.ldb, &p.info ); } template<> inline void llsq_call_xgesv( llsq_params_xgesv< double >& p ) { dgesv_( &p.n, &p.nrhs, p.a, &p.lda, p.ipiv, p.b, &p.ldb, &p.info ); } template< size_t M, size_t N, typename float_t > struct linear_least_squares_xgesv { // computes x ( Ax = b ). x replaces b on output. void compute( matrix< N, N, float_t >& A, matrix< N, M, float_t >& b ); linear_least_squares_xgesv(); ~linear_least_squares_xgesv(); const lapack::llsq_params_xgesv< float_t >& get_params() { return p; } lapack::llsq_params_xgesv< float_t > p; }; // struct lapack_linear_least_squares template< size_t M, size_t N, typename float_t > void linear_least_squares_xgesv< M, N, float_t >:: compute( matrix< N, N, float_t >& A, matrix< N, M, float_t >& b ) { p.a = A.array; p.b = b.array; lapack::llsq_call_xgesv( p ); if ( p.info != 0 ) { if ( p.info < 0 ) VMMLIB_ERROR( "invalid value in input matrix", VMMLIB_HERE ); else VMMLIB_ERROR( "factor U is exactly singular, solution could not be computed.", VMMLIB_HERE ); } } template< size_t M, size_t N, typename float_t > linear_least_squares_xgesv< M, N, float_t >:: linear_least_squares_xgesv() { p.n = N; p.nrhs = M; p.lda = N; p.ldb = N; p.ipiv = new lapack_int[ N ]; } template< size_t M, size_t N, typename float_t > linear_least_squares_xgesv< M, N, float_t >:: ~linear_least_squares_xgesv() { delete[] p.ipiv; } } // namespace lapack } // namespace vmml #endif vmmlib-1.0/include/vmmlib/blas_dot.hpp0000644000175000017500000000627311674116156017425 0ustar shevekshevek#ifndef __VMML__VMMLIB_BLAS_DOT__HPP__ #define __VMML__VMMLIB_BLAS_DOT__HPP__ #include #include #include #include /** * * a wrapper for blas's DOT routine. * REAL FUNCTION SDOT(N,SX,INCX,SY,INCY) * .. Scalar Arguments .. * INTEGER INCX,INCY,N * * .. Array Arguments .. * REAL SX(*),SY(*) * * * Purpose * ======= * * SDOT forms the dot product of two vectors. * uses unrolled loops for increments equal to one. * * * more information in: http://netlib.org/blas/sdot.f ** */ namespace vmml { namespace blas { #if 0 /* Subroutine */ float cblas_sdot( const int N, const float *X, const int incX, const float *Y, const int incY ); double cblas_ddot( const int N, const double *X, const int incX, const double *Y, const int incY ); #endif template< typename float_t > struct dot_params { blas_int n; float_t* x; blas_int inc_x; float_t* y; blas_int inc_y; friend std::ostream& operator << ( std::ostream& os, const dot_params< float_t >& p ) { os << " (1)\tn " << p.n << std::endl << " (2)\tx " << p.x << std::endl << " (3)\tincX " << p.inc_x << std::endl << " (4)\ty " << p.y << std::endl << " (5)\tincY " << p.inc_y << std::endl << std::endl; return os; } }; template< typename float_t > inline float_t dot_call( dot_params< float_t >& p ) { VMMLIB_ERROR( "not implemented for this type.", VMMLIB_HERE ); } template<> inline float dot_call( dot_params< float >& p ) { //std::cout << "calling blas sdot (single precision) " << std::endl; float vvi = cblas_sdot( p.n, p.x, p.inc_x, p.y, p.inc_y ); return vvi; } template<> inline double dot_call( dot_params< double >& p ) { //std::cout << "calling blas ddot (double precision) " << std::endl; double vvi = cblas_ddot( p.n, p.x, p.inc_x, p.y, p.inc_y ); return vvi; } } // namespace blas template< size_t M, typename float_t > struct blas_dot { typedef vector< M, float_t > vector_t; blas_dot(); ~blas_dot() {}; bool compute( const vector_t& A_, const vector_t& B_, float_t& dot_prod_ ); blas::dot_params< float_t > p; const blas::dot_params< float_t >& get_params(){ return p; }; }; // struct blas_dot template< size_t M, typename float_t > blas_dot< M, float_t >::blas_dot() { p.n = M; p.x = 0; p.inc_x = 1; p.y = 0; p.inc_y = 1; } template< size_t M, typename float_t > bool blas_dot< M, float_t >::compute( const vector_t& A_, const vector_t& B_, float_t& dot_prod_ ) { // blas needs non-const data vector_t* AA = new vector_t( A_ ); vector_t* BB = new vector_t( B_ ); p.x = AA->array; p.y = BB->array; dot_prod_ = blas::dot_call< float_t >( p ); //std::cout << dot_prod_ << std::endl; //debug delete AA; delete BB; return true; } } // namespace vmml #endif vmmlib-1.0/include/vmmlib/enable_if.hpp0000644000175000017500000000070711674116156017536 0ustar shevekshevek#ifndef __VMML__SFINAE__HPP__ #define __VMML__SFINAE__HPP__ #include /** * heavily inspired by boost::enable_if * http://www.boost.org, file: boost/utility/enable_if.hpp, * Copyright 2003 Jaakko Järvi, Jeremiah Willcock, Andrew Lumsdaine */ namespace vmml { template < bool condition, typename T = void > struct enable_if { typedef T type; }; template< typename T > struct enable_if< false, T > {}; } // namespace vmml #endif vmmlib-1.0/include/vmmlib/quaternion.hpp0000644000175000017500000005013311674116156020015 0ustar shevekshevek/* * VMMLib - Vector & Matrix Math Lib * * @author Philip Schlegel * @author Jonas Boesch * @author Julius Natrup * */ #ifndef __VMML__QUATERNION__HPP__ #define __VMML__QUATERNION__HPP__ #include #include #include #include #include #include #include #include #include #include #include #include #include // - declaration - // #define QUATERNION_TRACE_EPSILON 1e-5 namespace vmml { template < typename T > class quaternion : private vector< 4, T > { public: typedef vector< 4, T > super; using super::operator(); //using super::operator=; using super::at; using super::x; using super::y; using super::z; using super::w; using super::array; using super::find_min; using super::find_max; using super::find_min_index; using super::find_max_index; using super::iter_set; //constructors quaternion(); // warning: components NOT initialised (for performance) quaternion( T x, T y, T z, T w ); quaternion( const vector< 3, T >& xyz , T w ); // initializes the quaternion with xyz, sets w to zero quaternion( const vector< 3, T >& xyz ); // uses the top-left 3x3 part of the supplied matrix as rotation matrix template< size_t M > quaternion( const matrix< M, M, T >& rotation_matrix_, typename enable_if< M >= 3 >::type* = 0 ); void zero(); void identity(); template< size_t DIM > void set( const matrix< DIM, DIM, T >& rotation_matrix_ ); void set( T ww, T xx, T yy, T zz); void set( vector< 3, T >& xyz, T w ); template< typename input_iterator_t > void set( input_iterator_t begin_, input_iterator_t end_ ); bool operator==( const T& a ) const; bool operator!=( const T& a ) const; bool operator==( const quaternion& a ) const; bool operator!=( const quaternion& a ) const; bool operator==( const vector< 4, T >& a ) const; bool operator!=( const vector< 4, T >& a ) const; bool is_akin( const quaternion& a, const T& delta = std::numeric_limits< T >::epsilon() ); void conjugate(); quaternion get_conjugate() const; T abs() const; T squared_abs() const; T normalize(); quaternion get_normalized() const; quaternion negate() const; quaternion operator-() const; const quaternion& operator=(const quaternion& other); const vector< 4, T >& operator=( const vector< 4, T >& other ); // // quaternion/quaternion operations // quaternion operator+( const quaternion< T >& a ) const; quaternion operator-( const quaternion< T >& a ) const; // caution: a * q != q * a in general quaternion operator*( const quaternion< T >& a ) const; void operator+=( const quaternion< T >& a ); void operator-=( const quaternion< T >& a ); // caution: a *= q != q *= a in general void operator*=( const quaternion< T >& a ); // // quaternion/scalar operations // quaternion operator*( T a ) const; quaternion operator/( T a ) const; void operator*=( T a ); void operator/=( T a ); // //quaternion/vector operations // quaternion operator+( const vector< 3, T >& a ) const; quaternion operator-( const vector< 3, T >& a ) const; quaternion operator*( const vector< 3, T >& a ) const; void operator+=( const vector< 3, T >& a ); void operator-=( const vector< 3, T >& a ); void operator*=( const vector< 3, T >& a ); // vec3 = this x b vector< 3, T > cross( const quaternion< T >& b ) const; T dot( const quaternion< T >& a ) const; static T dot( const quaternion< T >& a, const quaternion< T >& b ); // returns multiplicative inverse quaternion inverse(); void normal( const quaternion& aa, const quaternion& bb, const quaternion& cc, const quaternion& dd ); quaternion normal( const quaternion& aa, const quaternion& bb, const quaternion& cc ); // to combine two rotations, multiply the respective quaternions before using rotate // instead of rotating twice for increased performance, but be aware of non-commutativity! void rotate( T theta, const vector< 3, T >& a ); quaternion rotate( T theta, vector< 3, T >& axis, const vector< 3, T >& a ); quaternion rotate_x( T theta, const vector< 3, T >& a ); quaternion rotate_y( T theta, const vector< 3, T >& a ); quaternion rotate_z( T theta, const vector< 3, T >& a ); quaternion slerp( T a, const quaternion< T >& p, const quaternion& q ); matrix< 3, 3, T > get_rotation_matrix() const; template< size_t DIM > void get_rotation_matrix( matrix< DIM, DIM, T >& result ) const; friend std::ostream& operator<< ( std::ostream& os, const quaternion& q ) { os << "("; size_t index = 0; for( ; index < 3; ++index ) { os << q.at( index ) << ", "; } os << q.at( index ) << ") "; return os; }; static const quaternion ZERO; static const quaternion IDENTITY; static const quaternion QUATERI; static const quaternion QUATERJ; static const quaternion QUATERK; }; // class quaternion #ifndef VMMLIB_NO_TYPEDEFS typedef quaternion< float > quaternionf; typedef quaternion< double > quaterniond; #endif // - implementation - // template < typename T > const quaternion< T > quaternion< T >::ZERO( 0, 0, 0, 0 ); template < typename T > const quaternion< T > quaternion< T >::IDENTITY( 0, 0, 0, 1 ); template < typename T > const quaternion< T > quaternion< T >::QUATERI( 1, 0, 0, 0 ); template < typename T > const quaternion< T > quaternion< T >::QUATERJ( 0, 1, 0, 0 ); template < typename T > const quaternion< T > quaternion< T >::QUATERK( 0, 0, 1, 0 ); template < typename T > quaternion< T >::quaternion() { // intentionally left empty } template < typename T > quaternion< T >::quaternion( T x_, T y_, T z_, T w_ ) { x() = x_; y() = y_; z() = z_; w() = w_; } template < typename T > quaternion< T >::quaternion( const vector< 3, T >& xyz, T w_ ) { super::set( xyz, w_ ); } template < typename T > quaternion< T >::quaternion( const vector< 3, T >& xyz ) { super::set( xyz, static_cast< T >( 0.0 ) ); } template< typename T > template< size_t M > quaternion< T >::quaternion( const matrix< M, M, T >& rotation_matrix_, typename enable_if< M >= 3 >::type* ) { this->template set< M >( rotation_matrix_ ); } // top-left 3x3 is interpreted as rot matrix. template < typename T > template< size_t DIM > void quaternion< T >:: set( const matrix< DIM, DIM, T >& M ) { T trace = M( 0, 0 ) + M( 1, 1 ) + M( 2,2 ) + 1.0; // very small traces may introduce a big numerical error if( trace > QUATERNION_TRACE_EPSILON ) { T s = 0.5 / sqrt( trace ); x() = M( 2, 1 ) - M( 1, 2 ); x() *= s; y() = M( 0, 2 ) - M( 2, 0 ); y() *= s; z() = M( 1, 0 ) - M( 0, 1 ); z() *= s; w() = 0.25 / s; } else { vector< 3, T > diag( M( 0, 0 ), M( 1, 1 ), M( 2, 2 ) ); size_t largest = diag.find_max_index(); // 0, 0 is largest if ( largest == 0 ) { T s = 0.5 / sqrt( 1.0 + M( 0, 0 ) - M( 1, 1 ) - M( 2, 2 ) ); x() = 0.25 / s; y() = M( 0,1 ) + M( 1,0 ); y() *= s; z() = M( 0,2 ) + M( 2,0 ); z() *= s; w() = M( 1,2 ) - M( 2,1 ); w() *= s; } else if ( largest == 1 ) { T s = 0.5 / sqrt( 1.0 + M( 1,1 ) - M( 0,0 ) - M( 2,2 ) ); x() = M( 0,1 ) + M( 1,0 ); x() *= s; y() = 0.25 / s; z() = M( 1,2 ) + M( 2,1 ); z() *= s; w() = M( 0,2 ) - M( 2,0 ); w() *= s; } // 2, 2 is largest else if ( largest == 2 ) { T s = 0.5 / sqrt( 1.0 + M( 2,2 ) - M( 0,0 ) - M( 1,1 ) ); x() = M( 0,2 ) + M( 2,0 ); x() *= s; y() = M( 1,2 ) + M( 2,1 ); y() *= s; z() = 0.25 / s; w() = M( 0,1 ) - M( 1,0 ); w() *= s; } else { assert( 0 ); } } } template < typename T > void quaternion< T >::zero() { (*this) = ZERO; } template < typename T > void quaternion< T >::identity() { (*this) = IDENTITY; } template < typename T > void quaternion< T >::set( T xx, T yy, T zz, T ww ) { x() = xx; y() = yy; z() = zz; w() = ww; } template< typename T > void quaternion< T >::set( vector< 3, T >& xyz, T _w ) { x() = xyz.x(); y() = xyz.y(); z() = xyz.z(); w() = _w; } template < typename T > template< typename input_iterator_t > void quaternion< T >::set( input_iterator_t begin_, input_iterator_t end_ ) { super::template set< input_iterator_t >( begin_, end_ ); } template < typename T > bool quaternion< T >::operator==( const T& a ) const { return ( w() == a && x() == 0 && y() == 0 && z() == 0 ); } template < typename T > bool quaternion< T >::operator!=( const T& a ) const { return ( w() != a || x() != 0 || y() != 0 || z() != 0 ); } template < typename T > bool quaternion< T >::operator==( const vector< 4, T >& a ) const { return this->operator==( reinterpret_cast< const quaternion< T >& >( a ) ); } template < typename T > bool quaternion< T >::operator!=( const vector< 4, T >& a ) const { return ! this->operator==( a ); } template < typename T > bool quaternion< T >::operator==( const quaternion& a ) const { return ( w() == a.w() && x() == a.x() && y() == a.y() && z() == a.z() ); } template < typename T > bool quaternion< T >::operator!=( const quaternion& a ) const { return ! this->operator==( a ); } template < typename T > bool quaternion< T >::is_akin( const quaternion& a, const T& delta ) { if( fabsf( w() - a.w() ) > delta || fabsf( x() - a.x() ) > delta || fabsf( y() - a.y() ) > delta || fabsf( z() - a.z() ) > delta ) return false; return true; } template < typename T > void quaternion< T >::conjugate() { x() = -x(); y() = -y(); z() = -z(); } template < typename T > quaternion< T > quaternion< T >::get_conjugate() const { return quaternion< T > ( -x(), -y(), -z(), w() ); } template < typename T > T quaternion< T >::abs() const { return sqrt( squared_abs() ); } template < typename T > T quaternion< T >::squared_abs() const { return x() * x() + y() * y() + z() * z() + w() * w(); } template < typename T > quaternion< T > quaternion< T >::inverse() { quaternion< T > q( *this ); q.conjugate(); T tmp = squared_abs(); tmp = static_cast< T >( 1.0 ) / tmp; return q * tmp; } template < typename T > T quaternion< T >::normalize() { T length = abs(); if( length == 0.0 ) return 0.0; length = 1.0f / length; this->operator*=( length ); return length; } template < typename T > quaternion< T > quaternion< T >::get_normalized() const { quaternion< T > q( *this ); q.normalize(); return q; } // // quaternion/quaternion operations // template < typename T > quaternion< T > quaternion< T >::operator+( const quaternion< T >& a ) const { return quaternion( x() + a.x(), y() + a.y(), z() + a.z(), w() + a.w() ); } template < typename T > quaternion< T > quaternion< T >::operator-( const quaternion< T >& a ) const { return quaternion( x() - a.x(), y() - a.y(), z() - a.z(), w() - a.w() ); } // returns Grasssmann product template < typename T > quaternion< T > quaternion< T >::operator*( const quaternion< T >& a ) const { quaternion< T > ret( *this ); ret *= a; return ret; } // Grassmann product template < typename T > void quaternion< T >::operator*=( const quaternion< T >& q ) { #if 0 quaternion< T > orig( *this ); x() = orig.w() * a.x() + orig.x() * a.w() + orig.y() * a.z() - orig.z() * a.y(); y() = orig.w() * a.y() + orig.y() * a.w() + orig.z() * a.x() - orig.x() * a.z(); z() = orig.w() * a.z() + orig.z() * a.w() + orig.x() * a.y() - orig.y() * a.x(); w() = orig.w() * a.w() - orig.x() * a.x() - orig.y() * a.y() - orig.z() * a.z(); #else // optimized version, 7 less mul, but 15 more add/subs // after Henrik Engstrom, from a gamedev.net article. T* _array = super::array; const T& a = _array[ 3 ]; const T& b = _array[ 0 ]; const T& c = _array[ 1 ]; const T& d = _array[ 2 ]; const T& _x = q.array[ 3 ]; const T& _y = q.array[ 0 ]; const T& _z = q.array[ 1 ]; const T& _w = q.array[ 2 ]; const T tmp_00 = (d - c) * (_z - _w); const T tmp_01 = (a + b) * (_x + _y); const T tmp_02 = (a - b) * (_z + _w); const T tmp_03 = (c + d) * (_x - _y); const T tmp_04 = (d - b) * (_y - _z); const T tmp_05 = (d + b) * (_y + _z); const T tmp_06 = (a + c) * (_x - _w); const T tmp_07 = (a - c) * (_x + _w); const T tmp_08 = tmp_05 + tmp_06 + tmp_07; const T tmp_09 = 0.5 * (tmp_04 + tmp_08); _array[ 3 ] = tmp_00 + tmp_09 - tmp_05; _array[ 0 ] = tmp_01 + tmp_09 - tmp_08; _array[ 1 ] = tmp_02 + tmp_09 - tmp_07; _array[ 2 ] = tmp_03 + tmp_09 - tmp_06; #endif } template < typename T > quaternion< T > quaternion< T >::operator-() const { return quaternion( -x(), -y(), -z(), -w() ); } template < typename T > void quaternion< T >::operator+=( const quaternion< T >& a ) { array[ 0 ] += a.array[ 0 ]; array[ 1 ] += a.array[ 1 ]; array[ 2 ] += a.array[ 2 ]; array[ 3 ] += a.array[ 3 ]; } template < typename T > void quaternion< T >::operator-=( const quaternion< T >& a ) { array[ 0 ] -= a.array[ 0 ]; array[ 1 ] -= a.array[ 1 ]; array[ 2 ] -= a.array[ 2 ]; array[ 3 ] -= a.array[ 3 ]; } // // quaternion/scalar operations // template < typename T > quaternion< T > quaternion< T >::operator*( const T a ) const { return quaternion( x() * a, y() * a, z() * a, w() * a ); } template < typename T > quaternion< T > quaternion< T >::operator/( T a ) const { if ( a == 0.0 ) { VMMLIB_ERROR( "Division by zero.", VMMLIB_HERE ); } a = 1.0 / a; return quaternion( x() * a, y() * a, z() * a, w() * a ); } template < typename T > void quaternion< T >::operator*=( T a ) { array[ 0 ] *= a; array[ 1 ] *= a; array[ 2 ] *= a; array[ 3 ] *= a; } template < typename T > void quaternion< T >::operator/=( T a ) { if ( a == 0.0 ) { VMMLIB_ERROR( "Division by zero", VMMLIB_HERE ); } a = 1.0f / a; this->operator*=( a ); } //quaternion/vector operations template < typename T > quaternion< T > quaternion< T >::operator+( const vector< 3, T >& a ) const { return quaternion( x() + a.x(), y() + a.y(), z() + a.z(), w() ); } template < typename T > quaternion< T > quaternion< T >::operator-( const vector< 3, T >& a ) const { return quaternion( w(), x() - a.x(), y() - a.y(), z() - a.z() ); } template < typename T > quaternion< T > quaternion< T >::operator*( const vector< 3, T >& a ) const { return quaternion( -x() * a.x() - y() * a.y() - z() * a.z(), w() * a.x() + y() * a.z() - z() * a.y(), w() * a.y() + z() * a.x() - x() * a.z(), w() * a.z() + x() * a.y() - y() * a.x() ); } template < typename T > void quaternion< T >::operator+=( const vector< 3, T >& xyz ) { x() += xyz.x(); y() += xyz.y(); y() += xyz.z(); } template < typename T > void quaternion< T >::operator-=( const vector< 3, T >& xyz ) { x() -= xyz.x(); y() -= xyz.y(); z() -= xyz.z(); return *this; } template < typename T > void quaternion< T >::operator*=(const vector< 3, T >& a ) { T _x = x(); T _y = y(); T _z = z(); T _w = w(); x() = _w * a.x() + _y * a.z() - _z * a.y(); y() = _w * a.y() + _z * a.x() - _x * a.z(); z() = _w * a.z() + _x * a.y() - _y * a.x(); w() = -_x * a.x() - _y * a.y() - _z * a.z(); } template < typename T > vector< 3, T > quaternion< T >::cross( const quaternion< T >& bb ) const { vector< 3, T > result; result.array[ 0 ] = y() * bb.z() - z() * bb.y(); result.array[ 1 ] = z() * bb.x() - x() * bb.z(); result.array[ 2 ] = x() * bb.y() - y() * bb.x(); return result; } template < typename T > T quaternion< T >::dot( const quaternion< T >& a ) const { return w() * a.w() + x() * a.x() + y() * a.y() + z() * a.z(); } template < typename T > T quaternion< T >:: dot( const quaternion< T >& a, const quaternion< T >& b ) { return a.w() * b.w() + a.x() * b.x() + a.y() * b.y() + a.z() * b.z(); } template < typename T > void quaternion< T >::normal( const quaternion< T >& aa, const quaternion< T >& bb, const quaternion< T >& cc, const quaternion< T >& dd ) { //right hand system, CCW triangle const quaternion< T > quat_t = bb - aa; const quaternion< T > quat_u = cc - aa; const quaternion< T > quat_v = dd - aa; cross( quat_t, quat_u, quat_v ); normalize(); } template < typename T > quaternion< T > quaternion< T >::normal( const quaternion< T >& aa, const quaternion< T >& bb, const quaternion< T >& cc ) { quaternion< T > tmp; tmp.normal( *this, aa, bb, cc ); return tmp; } // to combine two rotations, multiply the respective quaternions before using rotate // instead of rotating twice for increased performance, but be aware of non-commutativity! // (the first rotation quaternion has to be the first factor) template< typename T > quaternion< T > quaternion< T >::rotate( T theta, vector< 3, T >& axis, const vector< 3, T >& a ) { quaternion< T > p = a; T alpha = theta / 2; quaternion< T > q = cos( alpha ) + ( sin( alpha ) * axis.normalize() ); return q * p * q.invert(); } template< typename T > quaternion< T > quaternion< T >::rotate_x( T theta, const vector< 3, T >& a ) { quaternion< T > p = a; T alpha = theta / 2; quaternion< T > q = cos( alpha ) + ( sin( alpha ) * QUATERI ); return q * p * q.invert(); } template< typename T > quaternion< T > quaternion< T >::rotate_y( T theta, const vector< 3, T >& a ) { quaternion< T > p = a; T alpha = theta / 2; quaternion< T > q = cos( alpha ) + ( sin( alpha ) * QUATERJ ); return q * p * q.invert(); } template< typename T > quaternion< T > quaternion< T >::rotate_z( T theta, const vector< 3, T >& a ) { quaternion< T > p = a; T alpha = theta / 2; quaternion< T > q = cos( alpha ) + ( sin( alpha ) * QUATERK ); return q * p * q.invert(); } template < typename T > matrix< 3, 3, T > quaternion< T >::get_rotation_matrix() const { matrix< 3, 3, T > result; get_rotation_matrix< 3 >( result ); return result; } template < typename T > template< size_t DIM > void quaternion< T >::get_rotation_matrix( matrix< DIM, DIM, T >& M ) const { T w2 = w() * w(); T x2 = x() * x(); T y2 = y() * y(); T z2 = z() * z(); T wx = w() * x(); T wy = w() * y(); T wz = w() * z(); T xy = x() * y(); T xz = x() * z(); T yz = y() * z(); M( 0, 0 ) = w2 + x2 - y2 - z2; M( 0, 1 ) = 2. * (xy - wz); M( 0, 2 ) = 2. * (xz + wy); M( 1, 0 ) = 2. * (xy + wz); M( 1, 1 ) = w2 - x2 + y2 - z2; M( 1, 2 ) = 2. * (yz - wx); M( 2, 0 ) = 2. * (xz - wy); M( 2, 1 ) = 2. * (yz + wx); M( 2, 2 ) = w2 - x2 - y2 + z2; } template < typename T > quaternion< T > quaternion< T >:: slerp( T a, const quaternion< T >& p, const quaternion< T >& q ) { p = p.normalize(); q = q.normalize(); T cosine = p.dot(q); quaternion< T > quat_t; // check if inverted rotation is needed if ( cosine < 0.0 ) { cosine = -cosine; quat_t = -q; } else { quat_t = q; } if( cosine.abs() < 1 - 1e-13 ) { // standard slerp T sine = sqrt( 1. - ( cosine * cosine ) ); T angle = atan2( sine, cosine ); T coeff1 = sin( 1.0 - a ) * angle / sine; T coeff2 = sin( a * angle ) / sine; return coeff1 * p + coeff2 * quat_t; } else { // linear interpolation for very small angles quaternion< T > quat_u = ( 1. - a ) * p + a * quat_t; quat_u.normalize(); return quat_u; } } template < typename T > const quaternion< T >& quaternion< T >::operator=(const quaternion& other) { memcpy( array, other.array, 4 * sizeof( T ) ); return *this; } template < typename T > const vector< 4, T >& quaternion< T >::operator=( const vector< 4, T >& other ) { memcpy( array, other.array, 4 * sizeof( T ) ); return other; } } #endif vmmlib-1.0/include/vmmlib/lapack_types.hpp0000644000175000017500000000046111674116156020306 0ustar shevekshevek#ifndef __VMML__LAPACK_TYPES__HPP__ #define __VMML__LAPACK_TYPES__HPP__ #include "lapack_includes.hpp" namespace vmml { namespace lapack { #ifdef __APPLE__ typedef __CLPK_integer lapack_int; #else typedef integer lapack_int; #endif } // namespace lapack } // namespace vmml #endif vmmlib-1.0/include/vmmlib/tucker3_exporter.hpp0000644000175000017500000002514311674116156021143 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * * Export tool for Tucker3 tensor and quantized Tucker3 tensor * */ #ifndef __VMML__TUCK3_EXPORTER__HPP__ #define __VMML__TUCK3_EXPORTER__HPP__ #include /* FIXME: * * - T_internal * - const input argument for tucker3 data */ namespace vmml { template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value = float, typename T_coeff = float > class tucker3_exporter { public: typedef float T_internal; //FIXME! should match with tucker3 tensor typedef tucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > tucker3_type; typedef qtucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > qtucker3_type; typedef tensor3< R1, R2, R3, T_coeff > t3_core_type; typedef typename t3_core_type::iterator t3_core_iterator; typedef typename t3_core_type::const_iterator t3_core_const_iterator; typedef matrix< I1, R1, T_coeff > u1_type; typedef typename u1_type::iterator u1_iterator; typedef typename u1_type::const_iterator u1_const_iterator; typedef matrix< I2, R2, T_coeff > u2_type; typedef typename u2_type::iterator u2_iterator; typedef typename u2_type::const_iterator u2_const_iterator; typedef matrix< I3, R3, T_coeff > u3_type; typedef typename u3_type::iterator u3_iterator; typedef typename u3_type::const_iterator u3_const_iterator; typedef tensor3< R1, R2, R3, char > t3_core_signs_type; template< typename T > static void export_to( std::vector< T >& data_, tucker3_type& tuck3_data_ ); //previous version, but works only with 16bit quantization static void export_quantized_to( std::vector& data_out_, qtucker3_type& tuck3_data_ ); //use this version, works with a better quantization for the core tensor: //logarithmic quantization and separate high energy core vale //suitable for voxelwise reconstruction static void export_hot_quantized_to( std::vector& data_out_, qtucker3_type& tuck3_data_ ); //use this version for the ttm export/import (core: backward cyclic), without plain hot value static void export_ttm_quantized_to( std::vector& data_out_, qtucker3_type& tuck3_data_ ); }; //end tucker3 exporter class #define VMML_TEMPLATE_STRING template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value, typename T_coeff > #define VMML_TEMPLATE_CLASSNAME tucker3_exporter< R1, R2, R3, I1, I2, I3, T_value, T_coeff > VMML_TEMPLATE_STRING template< typename T > void VMML_TEMPLATE_CLASSNAME::export_to( std::vector< T >& data_, tucker3_type& tuck3_data_ ) { data_.clear(); u1_type* u1 = new u1_type; u2_type* u2 = new u2_type; u3_type* u3 = new u3_type; t3_core_type core; tuck3_data_.get_u1( *u1 ); tuck3_data_.get_u2( *u2 ); tuck3_data_.get_u3( *u3 ); tuck3_data_.get_core( core ); tuck3_data_.cast_members(); u1_const_iterator it = u1->begin(), it_end = u1->end(); for( ; it != it_end; ++it ) { data_.push_back( static_cast< T >( *it) ); } u2_const_iterator u2_it = u2->begin(), u2_it_end = u2->end(); for( ; u2_it != u2_it_end; ++u2_it ) { data_.push_back(static_cast< T >(*u2_it) ); } u3_const_iterator u3_it = u3->begin(), u3_it_end = u3->end(); for( ; u3_it != u3_it_end; ++u3_it ) { data_.push_back(static_cast< T >( *u3_it) ); } t3_core_iterator it_core = core.begin(), it_core_end = core.end(); for( ; it_core != it_core_end; ++it_core ) { data_.push_back(static_cast< T >( *it_core) ); } delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::export_quantized_to( std::vector& data_out_, qtucker3_type& tuck3_data_ ) { //quantize tucker3 components (u1-u3 and core) size_t len_t_comp = sizeof( T_internal ); size_t len_export_data = tuck3_data_.SIZE * sizeof(T_coeff) + 8 * len_t_comp; char * data = new char[ len_export_data ]; size_t end_data = 0; //quantize basis matrices and copy min-max values T_internal u_min, u_max; tuck3_data_.quantize_basis_matrices( u_min, u_max); memcpy( data, &u_min, len_t_comp ); end_data = len_t_comp; memcpy( data + end_data, &u_max, len_t_comp ); end_data += len_t_comp; u1_type* u1 = new u1_type; u2_type* u2 = new u2_type; u3_type* u3 = new u3_type; t3_core_type core; tuck3_data_.get_u1( *u1 ); tuck3_data_.get_u2( *u2 ); tuck3_data_.get_u3( *u3 ); tuck3_data_.get_core( core ); //quantize core and copy min-max values T_internal core_min, core_max; tuck3_data_.quantize_core( core_min, core_max ); memcpy( data + end_data, &core_min, len_t_comp ); end_data += len_t_comp; memcpy( data + end_data, &core_max, len_t_comp ); end_data += len_t_comp; //copy data for u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( data + end_data, *u1, len_u1 ); end_data += len_u1; //copy data for u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( data + end_data, *u2, len_u2 ); end_data += len_u2; //copy data for u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( data + end_data, *u3, len_u3 ); end_data += len_u3; //copy data for core size_t len_core_slice = R1 * R2 * sizeof( T_coeff ); for (size_t r3 = 0; r3 < R3; ++r3 ) { memcpy( data + end_data, core.get_frontal_slice_fwd( r3 ), len_core_slice ); end_data += len_core_slice; } data_out_.clear(); for( size_t byte = 0; byte < len_export_data; ++byte ) { data_out_.push_back( data[byte] ); } delete[] data; delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::export_hot_quantized_to( std::vector& data_out_, qtucker3_type& tuck3_data_ ) { tuck3_data_.enable_quantify_hot(); //quantize tucker3 components (u1-u3 and core) size_t len_t_comp = sizeof( T_internal ); size_t len_export_data = R1*R2*R3 + (R1*I1 + R2*I2 + R3*I3) * sizeof(T_coeff) + 4 * len_t_comp; char * data = new char[ len_export_data ]; size_t end_data = 0; //quantize basis matrices and copy min-max values T_internal u_min, u_max; tuck3_data_.quantize_basis_matrices( u_min, u_max); memcpy( data, &u_min, len_t_comp ); end_data = len_t_comp; memcpy( data + end_data, &u_max, len_t_comp ); end_data += len_t_comp; //quantize core and copy min-max values T_internal core_min, core_max; tuck3_data_.quantize_core( core_min, core_max ); //memcpy( data + end_data, &core_min, len_t_comp ); end_data += len_t_comp; min_value is always zero in log quant memcpy( data + end_data, &core_max, len_t_comp ); end_data += len_t_comp; u1_type* u1 = new u1_type; u2_type* u2 = new u2_type; u3_type* u3 = new u3_type; t3_core_type core; t3_core_signs_type signs; tuck3_data_.get_u1( *u1 ); tuck3_data_.get_u2( *u2 ); tuck3_data_.get_u3( *u3 ); tuck3_data_.get_core( core ); tuck3_data_.get_core_signs( signs ); T_internal hottest_value = tuck3_data_.get_hottest_value(); //copy first value of core tensor separately as a float memcpy( data + end_data, &hottest_value, len_t_comp ); end_data += len_t_comp; //copy data for u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( data + end_data, *u1, len_u1 ); end_data += len_u1; //copy data for u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( data + end_data, *u2, len_u2 ); end_data += len_u2; //copy data for u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( data + end_data, *u3, len_u3 ); end_data += len_u3; //copy data for core size_t len_core_el = 1; //currently 1 bit for sign and 7 bit for values //colume-first iteration unsigned char core_el; for (size_t r3 = 0; r3 < R3; ++r3 ) { for (size_t r2 = 0; r2 < R2; ++r2 ) { for (size_t r1 = 0; r1 < R1; ++r1 ) { core_el = (core.at( r1, r2, r3 ) | (signs.at( r1, r2, r3) * 0x80 )); /*std::cout << "value: " << int(_core.at( r1, r2, r3 )) << " bit " << int( core_el ) << " sign: " << int(_signs.at( r1, r2, r3)) << std::endl;*/ memcpy( data + end_data, &core_el, len_core_el ); ++end_data; } } } data_out_.clear(); for( size_t byte = 0; byte < len_export_data; ++byte ) { data_out_.push_back( data[byte] ); } delete[] data; delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::export_ttm_quantized_to( std::vector& data_out_, qtucker3_type& tuck3_data_ ) { tuck3_data_.enable_quantify_log(); //quantize tucker3 components (u1-u3 and core) size_t len_t_comp = sizeof( T_internal ); size_t len_export_data = R1*R2*R3 + (R1*I1 + R2*I2 + R3*I3) * sizeof(T_coeff) + 3 *len_t_comp; char * data = new char[ len_export_data ]; size_t end_data = 0; //quantize basis matrices and copy min-max values T_internal u_min, u_max; tuck3_data_.quantize_basis_matrices( u_min, u_max); memcpy( data, &u_min, len_t_comp ); end_data = len_t_comp; memcpy( data + end_data, &u_max, len_t_comp ); end_data += len_t_comp; //quantize core and copy min-max values T_internal core_min, core_max; tuck3_data_.quantize_core( core_min, core_max ); //memcpy( data + end_data, &core_min, len_t_comp ); end_data += len_t_comp; min_value is always zero in log quant memcpy( data + end_data, &core_max, len_t_comp ); end_data += len_t_comp; u1_type* u1 = new u1_type; u2_type* u2 = new u2_type; u3_type* u3 = new u3_type; t3_core_type core; t3_core_signs_type signs; tuck3_data_.get_u1( *u1 ); tuck3_data_.get_u2( *u2 ); tuck3_data_.get_u3( *u3 ); tuck3_data_.get_core( core ); tuck3_data_.get_core_signs( signs ); //copy data for u1 size_t len_u1 = I1 * R1 * sizeof( T_coeff ); memcpy( data + end_data, *u1, len_u1 ); end_data += len_u1; //copy data for u2 size_t len_u2 = I2 * R2 * sizeof( T_coeff ); memcpy( data + end_data, *u2, len_u2 ); end_data += len_u2; //copy data for u3 size_t len_u3 = I3 * R3 * sizeof( T_coeff ); memcpy( data + end_data, *u3, len_u3 ); end_data += len_u3; //copy data for core size_t len_core_el = 1; //currently 1 bit for sign and 7 bit for values //colume-first iteration //backward cylcling after lathauwer et al. unsigned char core_el; for (size_t r2 = 0; r2 < R2; ++r2 ) { for (size_t r3 = 0; r3 < R3; ++r3 ) { for (size_t r1 = 0; r1 < R1; ++r1 ) { core_el = (core.at( r1, r2, r3 ) | (signs.at( r1, r2, r3) * 0x80 )); /*std::cout << "value: " << int(_core.at( r1, r2, r3 )) << " bit " << int( core_el ) << " sign: " << int(_signs.at( r1, r2, r3)) << std::endl;*/ memcpy( data + end_data, &core_el, len_core_el ); ++end_data; } } } data_out_.clear(); for( size_t byte = 0; byte < len_export_data; ++byte ) { data_out_.push_back( data[byte] ); } delete[] data; delete u1; delete u2; delete u3; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME } // namespace vmml #endif vmmlib-1.0/include/vmmlib/LICENSE0000644000175000017500000000305711674116156016127 0ustar shevekshevekCopyright (c) 2006-2012, Visualization and Multimedia Lab, University of Zurich All rights reserved. (http://vmml.ifi.uzh.ch) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the Visualization and Multimedia Lab, University of Zurich nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. vmmlib-1.0/include/vmmlib/lapack.hpp0000644000175000017500000000024711674116156017064 0ustar shevekshevek#ifndef __VMML__VMMLIB_LAPACK__HPP__ #define __VMML__VMMLIB_LAPACK__HPP__ #include #include #endif vmmlib-1.0/include/vmmlib/tucker3_tensor.hpp0000644000175000017500000004375511674116156020616 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * @author Jonas Boesch * * The Tucker3 tensor class is consists of the same components (core tensor, basis matrices u1-u3) as the tucker3 model described in: * - Tucker, 1966: Some mathematical notes on three-mode factor analysis, Psychometrika. * - De Lathauwer, De Moor, Vandewalle, 2000a: A multilinear singular value decomposition, SIAM J. Matrix Anal. Appl. * - De Lathauwer, De Moor, Vandewalle, 2000b: On the Best rank-1 and Rank-(R_1, R_2, ..., R_N) Approximation and Applications of Higher-Order Tensors, SIAM J. Matrix Anal. Appl. * - Kolda & Bader, 2009: Tensor Decompositions and Applications, SIAM Review. * * see also quantized Tucker3 tensor (qtucker3_tensor.hpp) */ #ifndef __VMML__TUCKER3_TENSOR__HPP__ #define __VMML__TUCKER3_TENSOR__HPP__ #include namespace vmml { template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value = float, typename T_coeff = double > class tucker3_tensor { public: typedef float T_internal; typedef tucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > tucker3_type; typedef t3_hooi< R1, R2, R3, I1, I2, I3, T_coeff > t3_hooi_type; typedef tensor3< I1, I2, I3, T_value > t3_type; typedef tensor3< R1, R2, R3, T_coeff > t3_core_type; typedef matrix< I1, R1, T_coeff > u1_type; typedef matrix< I2, R2, T_coeff > u2_type; typedef matrix< I3, R3, T_coeff > u3_type; typedef tensor3< I1, I2, I3, T_internal > t3_comp_type; typedef tensor3< R1, R2, R3, T_internal > t3_core_comp_type; typedef matrix< I1, R1, T_internal > u1_comp_type; typedef matrix< I2, R2, T_internal > u2_comp_type; typedef matrix< I3, R3, T_internal > u3_comp_type; static const size_t SIZE = R1*R2*R3 + I1*R1 + I2*R2 + I3*R3; tucker3_tensor(); tucker3_tensor( t3_core_type& core ); tucker3_tensor( t3_core_type& core, u1_type& U1, u2_type& U2, u3_type& U3 ); tucker3_tensor( const t3_type& data_, u1_type& U1, u2_type& U2, u3_type& U3 ); tucker3_tensor( const tucker3_type& other ); ~tucker3_tensor(); void set_core( t3_core_type& core ) { _core = t3_core_type( core ); _core_comp.cast_from( core ); } ; void set_u1( u1_type& U1 ) { *_u1 = U1; _u1_comp->cast_from( U1 ); } ; void set_u2( u2_type& U2 ) { *_u2 = U2; _u2_comp->cast_from( U2 ); } ; void set_u3( u3_type& U3 ) { *_u3 = U3; _u3_comp->cast_from( U3 ); } ; void get_core( t3_core_type& data_ ) const { data_ = _core; } ; void get_u1( u1_type& U1 ) const { U1 = *_u1; } ; void get_u2( u2_type& U2 ) const { U2 = *_u2; } ; void get_u3( u3_type& U3 ) const { U3 = *_u3; } ; void set_core_comp( t3_core_comp_type& core ) { _core_comp = t3_core_comp_type( core ); _core.cast_from( _core_comp ); } ; void set_u1_comp( u1_comp_type& U1 ) { *_u1_comp = U1; _u1->cast_from( U1 ); } ; void set_u2_comp( u2_comp_type& U2 ) { *_u2_comp = U2; _u2->cast_from( U2 ); } ; void set_u3_comp( u3_comp_type& U3 ) { *_u3_comp = U3; _u3->cast_from( U3 ); } ; void get_core_comp( t3_core_comp_type& data_ ) const { data_ = _core_comp; } ; void get_u1_comp( u1_comp_type& U1 ) const { U1 = *_u1_comp; } ; void get_u2_comp( u2_comp_type& U2 ) const { U2 = *_u2_comp; } ; void get_u3_comp( u3_comp_type& U3 ) const { U3 = *_u3_comp; } ; //get number of nonzeros for tensor decomposition size_t nnz() const; size_t nnz( const T_value& threshold ) const; size_t nnz_core() const; size_t size_core() const; size_t size() const { return SIZE; } ; void threshold_core( const size_t& nnz_core_, size_t& nnz_core_is_ ); void threshold_core( const T_coeff& threshold_value_, size_t& nnz_core_ ); void reconstruct( t3_type& data_ ); template< typename T_init> void decompose( const t3_type& data_, T_init init ); template< typename T_init> void tucker_als( const t3_type& data_, T_init init ); template< typename T_init> void incr_block_diag_als( const t3_type& data_, T_init init ); template< size_t K1, size_t K2, size_t K3> void reduce_ranks( const tucker3_tensor< K1, K2, K3, I1, I2, I3, T_value, T_coeff >& other ); //call TuckerJI.reduce_ranks(TuckerKI) K1 -> R1, K2 -> R2, K3 -> R3 template< size_t K1, size_t K2, size_t K3> void subsampling( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& factor ); template< size_t K1, size_t K2, size_t K3> void subsampling_on_average( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& factor ); template< size_t K1, size_t K2, size_t K3> void region_of_interest( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& start_index1, const size_t& end_index1, const size_t& start_index2, const size_t& end_index2, const size_t& start_index3, const size_t& end_index3); friend std::ostream& operator << ( std::ostream& os, const tucker3_type& t3 ) { t3_core_type core; t3.get_core( core ); u1_type* u1 = new u1_type; t3.get_u1( *u1 ); u2_type* u2 = new u2_type; t3.get_u2( *u2 ); u3_type* u3 = new u3_type; t3.get_u3( *u3 ); os << "U1: " << std::endl << *u1 << std::endl << "U2: " << std::endl << *u2 << std::endl << "U3: " << std::endl << *u3 << std::endl << "core: " << std::endl << core << std::endl; delete u1; delete u2; delete u3; return os; } void cast_members(); void cast_comp_members(); protected: tucker3_type operator=( const tucker3_type& other ) { return (*this); }; private: //t3_core_type* _core ; u1_type* _u1 ; u2_type* _u2 ; u3_type* _u3 ; t3_core_type _core ; //used only internally for computations to have a higher precision t3_core_comp_type _core_comp ; u1_comp_type* _u1_comp ; u2_comp_type* _u2_comp ; u3_comp_type* _u3_comp ; }; // class tucker3_tensor #define VMML_TEMPLATE_STRING template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value, typename T_coeff > #define VMML_TEMPLATE_CLASSNAME tucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( ) { _core.zero(); _u1 = new u1_type(); _u1->zero(); _u2 = new u2_type(); _u2->zero(); _u3 = new u3_type(); _u3->zero(); _core_comp.zero(); _u1_comp = new u1_comp_type(); _u1_comp->zero(); _u2_comp = new u2_comp_type(); _u2_comp->zero(); _u3_comp = new u3_comp_type(); _u3_comp->zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( t3_core_type& core ) { _core = core; _u1 = new u1_type(); _u1->zero(); _u2 = new u2_type(); _u2->zero(); _u3 = new u3_type(); _u3->zero(); _u1_comp = new u1_comp_type(); _u1_comp->zero(); _u2_comp = new u2_comp_type(); _u2_comp->zero(); _u3_comp = new u3_comp_type(); _u3_comp->zero(); _core_comp.cast_from( core ); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( t3_core_type& core, u1_type& U1, u2_type& U2, u3_type& U3 ) { _core = core; _u1 = new u1_type( U1 ); _u2 = new u2_type( U2 ); _u3 = new u3_type( U3 ); _u1_comp = new u1_comp_type(); _u2_comp = new u2_comp_type(); _u3_comp = new u3_comp_type(); cast_comp_members(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( const t3_type& data_, u1_type& U1, u2_type& U2, u3_type& U3 ) { _u1 = new u1_type( U1 ); _u2 = new u2_type( U2 ); _u3 = new u3_type( U3 ); _u1_comp = new u1_comp_type(); _u2_comp = new u2_comp_type(); _u3_comp = new u3_comp_type(); t3_hooi_type::derive_core( data_, *_u1, *_u2, *_u3, _core ); cast_comp_members(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::tucker3_tensor( const tucker3_type& other ) { _u1 = new u1_type(); _u2 = new u2_type(); _u3 = new u3_type(); _u1_comp = new u1_comp_type(); _u2_comp = new u2_comp_type(); _u3_comp = new u3_comp_type(); other.get_core( _core ); other.get_u1( *_u1 ); other.get_u2( *_u2 ); other.get_u3( *_u3 ); cast_comp_members(); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::cast_members() { _u1->cast_from( *_u1_comp ); _u2->cast_from( *_u2_comp ); _u3->cast_from( *_u3_comp ); _core.cast_from( _core_comp); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::cast_comp_members() { _u1_comp->cast_from( *_u1 ); _u2_comp->cast_from( *_u2 ); _u3_comp->cast_from( *_u3 ); _core_comp.cast_from( _core); } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz_core() const { return _core_comp.nnz(); } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::size_core() const { return _core_comp.size(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::~tucker3_tensor( ) { delete _u1; delete _u2; delete _u3; delete _u1_comp; delete _u2_comp; delete _u3_comp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_ ) { t3_comp_type data; data.cast_from( data_ ); data.full_tensor3_matrix_multiplication( _core_comp, *_u1_comp, *_u2_comp, *_u3_comp ); //convert reconstructed data, which is in type T_internal (double, float) to T_value (uint8 or uint16) if( (sizeof(T_value) == 1) || (sizeof(T_value) == 2) ){ data_.float_t_to_uint_t( data ); } else { data_.cast_from( data ); } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::threshold_core( const size_t& nnz_core_, size_t& nnz_core_is_ ) { nnz_core_is_ = _core_comp.nnz(); T_coeff threshold_value = 0.00001; while( nnz_core_is_ > nnz_core_ ) { _core_comp.threshold( threshold_value ); nnz_core_is_ = _core_comp.nnz(); //threshold value scheme if( threshold_value < 0.01) { threshold_value *= 10; } else if ( threshold_value < 0.2) { threshold_value += 0.05; } else if ( threshold_value < 1) { threshold_value += 0.25; } else if (threshold_value < 10 ) { threshold_value += 1; } else if (threshold_value < 50 ) { threshold_value += 10; } else if (threshold_value < 200 ) { threshold_value += 50; } else if (threshold_value < 500 ) { threshold_value += 100; } else if (threshold_value < 2000 ) { threshold_value += 500; } else if (threshold_value < 5000 ) { threshold_value += 3000; } else if (threshold_value >= 5000 ){ threshold_value += 5000; } } _core.cast_from( _core_comp); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::threshold_core( const T_coeff& threshold_value_, size_t& nnz_core_ ) { _core_comp.threshold( threshold_value_ ); nnz_core_ = _core_comp.nnz(); _core.cast_from( _core_comp); } VMML_TEMPLATE_STRING template< typename T_init> void VMML_TEMPLATE_CLASSNAME::decompose( const t3_type& data_, T_init init ) { tucker_als( data_, init ); } VMML_TEMPLATE_STRING template< typename T_init > void VMML_TEMPLATE_CLASSNAME::tucker_als( const t3_type& data_, T_init init ) { t3_comp_type data; data.cast_from( data_ ); typedef t3_hooi< R1, R2, R3, I1, I2, I3, T_internal > hooi_type; hooi_type::als( data, *_u1_comp, *_u2_comp, *_u3_comp, _core_comp, init ); cast_members(); } VMML_TEMPLATE_STRING template< typename T_init > void VMML_TEMPLATE_CLASSNAME::incr_block_diag_als( const t3_type& data_, T_init init ) { t3_comp_type data; data.cast_from( data_ ); //for number of increments, do a block of tucker with size R1=R2=R3 and set core only in diagonal, all other core values = zero; first approach typedef t3_hooi< R1, R2, R3, I1, I2, I3, T_internal > hooi_type; hooi_type::als( data, *_u1_comp, *_u2_comp, *_u3_comp, _core_comp, init ); cast_members(); } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3> void VMML_TEMPLATE_CLASSNAME::reduce_ranks( const tucker3_tensor< K1, K2, K3, I1, I2, I3, T_value, T_coeff >& other ) //TuckerJI.rank_recuction(TuckerKI) K1 -> R1, K2 -> R2, K3 -> R3; I1, I2, I3 stay the same { assert(R1 <= K1); assert(R2 <= K2); assert(R3 <= K3); //reduce basis matrices matrix< I1, K1, T_coeff >* u1 = new matrix< I1, K1, T_coeff >(); other.get_u1( *u1); for( size_t r1 = 0; r1 < R1; ++r1 ) { _u1->set_column( r1, u1->get_column( r1 )); } matrix< I2, K2, T_coeff >* u2 = new matrix< I2, K2, T_coeff >(); other.get_u2( *u2 ); for( size_t r2 = 0; r2 < R2; ++r2) { _u2->set_column( r2, u2->get_column( r2 )); } matrix< I3, K3, T_coeff >* u3 = new matrix< I3, K3, T_coeff >(); other.get_u3( *u3 ); for( size_t r3 = 0; r3 < R3; ++r3) { _u3->set_column( r3, u3->get_column( r3 )); } //reduce core tensor3 other_core; other.get_core( other_core ); for( size_t r3 = 0; r3 < R3; ++r3 ) { for( size_t r1 = 0; r1 < R1; ++r1 ) { for( size_t r2 = 0; r2 < R2; ++r2 ) { _core.at( r1, r2, r3 ) = other_core.at( r1, r2, r3 ); } } } cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3> void VMML_TEMPLATE_CLASSNAME::subsampling( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& factor ) { assert(I1 <= K1); assert(I1 <= K2); assert(I1 <= K3); //subsample basis matrices matrix< K1, R1, T_coeff >* u1 = new matrix< K1, R1, T_coeff >(); other.get_u1( *u1 ); for( size_t i1 = 0, i = 0; i1 < K1; i1 += factor, ++i ) { _u1->set_row( i, u1->get_row( i1 )); } matrix< K2, R2, T_coeff >* u2 = new matrix< K2, R2, T_coeff >(); other.get_u2( *u2 ); for( size_t i2 = 0, i = 0; i2 < K2; i2 += factor, ++i) { _u2->set_row( i, u2->get_row( i2 )); } matrix< K3, R3, T_coeff >* u3 = new matrix< K3, R3, T_coeff >() ; other.get_u3( *u3 ); for( size_t i3 = 0, i = 0; i3 < K3; i3 += factor, ++i) { _u3->set_row( i, u3->get_row( i3 )); } other.get_core( _core ); cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3> void VMML_TEMPLATE_CLASSNAME::subsampling_on_average( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& factor ) { assert(I1 <= K1); assert(I1 <= K2); assert(I1 <= K3); //subsample basis matrices matrix< K1, R1, T_coeff >* u1 = new matrix< K1, R1, T_coeff >(); other.get_u1( *u1 ); for( size_t i1 = 0, i = 0; i1 < K1; i1 += factor, ++i ) { vector< R1, T_internal > tmp_row = u1->get_row( i1 ); T_internal num_items_averaged = 1; for( size_t j = i1+1; (j < (factor+i1)) & (j < K1); ++j, ++num_items_averaged ) tmp_row += u1->get_row( j ); tmp_row /= num_items_averaged; _u1->set_row( i, tmp_row); } matrix< K2, R2, T_coeff >* u2 = new matrix< K2, R2, T_coeff >(); other.get_u2( *u2 ); for( size_t i2 = 0, i = 0; i2 < K2; i2 += factor, ++i) { vector< R2, T_internal > tmp_row = u2->get_row( i2 ); T_internal num_items_averaged = 1; for( size_t j = i2+1; (j < (factor+i2)) & (j < K2); ++j, ++num_items_averaged ) tmp_row += u2->get_row( j ); tmp_row /= num_items_averaged; _u2->set_row( i, u2->get_row( i2 )); } matrix< K3, R3, T_coeff >* u3 = new matrix< K3, R3, T_coeff >(); other.get_u3( *u3 ); for( size_t i3 = 0, i = 0; i3 < K3; i3 += factor, ++i) { vector< R3, T_internal > tmp_row = u3->get_row( i3 ); T_internal num_items_averaged = 1; for( size_t j = i3+1; (j < (factor+i3)) & (j < K3); ++j, ++num_items_averaged ) tmp_row += u3->get_row( j ); tmp_row /= num_items_averaged; _u3->set_row( i, u3->get_row( i3 )); } other.get_core( _core ); cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING template< size_t K1, size_t K2, size_t K3> void VMML_TEMPLATE_CLASSNAME::region_of_interest( const tucker3_tensor< R1, R2, R3, K1, K2, K3, T_value, T_coeff >& other, const size_t& start_index1, const size_t& end_index1, const size_t& start_index2, const size_t& end_index2, const size_t& start_index3, const size_t& end_index3) { assert(I1 <= K1); assert(I1 <= K2); assert(I1 <= K3); assert(start_index1 < end_index1); assert(start_index2 < end_index2); assert(start_index3 < end_index3); assert(end_index1 < K1); assert(end_index2 < K2); assert(end_index3 < K3); //region_of_interes of basis matrices matrix< K1, R1, T_internal >* u1 = new matrix< K1, R1, T_internal >(); other.get_u1_comp( *u1 ); for( size_t i1 = start_index1, i = 0; i1 < end_index1; ++i1, ++i ) { _u1_comp->set_row( i, u1->get_row( i1 )); } matrix< K2, R2, T_internal>* u2 = new matrix< K2, R2, T_internal>(); other.get_u2_comp( *u2 ); for( size_t i2 = start_index2, i = 0; i2 < end_index2; ++i2, ++i) { _u2_comp->set_row( i, u2->get_row( i2 )); } matrix< K3, R3, T_internal >* u3 = new matrix< K3, R3, T_internal>(); other.get_u3_comp( *u3 ); for( size_t i3 = start_index3, i = 0; i3 < end_index3; ++i3, ++i) { _u3_comp->set_row( i, u3->get_row( i3 )); } other.get_core_comp( _core_comp ); //cast_comp_members(); delete u1; delete u2; delete u3; } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz() const { size_t counter = 0; counter += _u1_comp->nnz(); counter += _u2_comp->nnz(); counter += _u3_comp->nnz(); counter += _core_comp.nnz(); return counter; } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz( const T_value& threshold ) const { size_t counter = 0; counter += _u1_comp->nnz( threshold ); counter += _u2_comp->nnz( threshold ); counter += _u3_comp->nnz( threshold ); counter += _core_comp.nnz( threshold ); return counter; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME } // namespace vmml #endif vmmlib-1.0/include/vmmlib/blas_includes.hpp0000644000175000017500000000033611674116156020437 0ustar shevekshevek#ifndef __VMML__BLAS_INCLUDES__HPP__ #define __VMML__BLAS_INCLUDES__HPP__ #ifdef __APPLE__ #include #else extern "C" { #include } #endif #endif /* __VMML__BLAS_INCLUDES__HPP__ */ vmmlib-1.0/include/vmmlib/jacobi_solver.hpp0000644000175000017500000001226711674116156020457 0ustar shevekshevek/* * VMMLib - Vector & Matrix Math Lib * * @author Jonas Boesch * @author Stefan Eilemann * @author Renato Pajarola * @author Andrew Willmott ( VL ) * * @license revised BSD license, check LICENSE * * parts of the source code of VMMLib were inspired by David Eberly's * Wild Magic and Andrew Willmott's VL. * */ #ifndef __VMML__JACOBI_SOLVER__HPP__ #define __VMML__JACOBI_SOLVER__HPP__ #include #include #include namespace vmml { /* * This function computes the eigenvalues and eigenvectors of a 3x3 matrix. * * @param a matrix to be diagonalized. * @param d eigenvalues of A. * @param v matrix whose columns are the normalized eigenvectors of A. * @param rotationCount number of Jacobi rotations required. * @return true if the transformation has been done. False if not. * * * modified from numerical recipies for n=3 and float values * */ template < typename T > bool solve_jacobi_3x3( matrix< 3, 3, T >& a, vector< 3, T >& d, matrix< 3, 3, T >& v, size_t& rotationCount ) { identity( v ); vector< 3, T > b, z; for ( size_t i = 0; i < 3; ++i ) { b[i] = d[i] = a( i,i ); z[i] = 0.0; } T t, theta, s, c, tau; size_t rot = 0; for ( size_t i = 1; i <= 150; ++i ) { T sm = 0.0; for ( size_t ip = 0; ip < 2; ++ip ) // < n-1 { for ( size_t iq = ip + 1; iq < 3; ++iq ) // < n { sm += fabs( a( iq, ip ) ); } } if ( sm == 0.0 ) { rotationCount = rot; return true; } T tresh = ( i < 4 ) ? 0.2 * sm / 9.0 : 0.0; for ( ssize_t ip = 0; ip < 2; ++ip ) // ip < n - 1 { for ( ssize_t iq = ip + 1; iq < 3; ++iq ) { T g = 100.0 * fabs( a( iq,ip ) ); // this has to be fabs( x ) + g == fabs( x ) and NOT // g == 0.0 because of floating point evilness // ( inaccuracies when comparing (anyfloat) to 0.0 ) if ( i > 4 && fabs( d[ip] ) + g == fabs( d[ip] ) && fabs( d[iq] ) + g == fabs( d[iq] ) ) { a( iq, ip ) = 0.0; } else { if ( fabs( a( iq, iq ) ) > tresh ) { T h = d[iq] - d[ip]; if ( fabs( h ) + g == fabs( h ) ) { if ( h != 0.0 ) t = ( a( iq, ip ) ) / h; else t = 0.0; } else { if( a( iq, ip ) != 0.0 ) theta = 0.5 * h / ( a( iq, ip ) ); else theta = 0.0; t = 1.0 / ( fabs( theta ) + sqrt( 1.0 + theta * theta ) ); if ( theta < 0.0 ) t = -t; } c = 1.0 / sqrt( 1 + t * t ); s = t * c; tau = s / ( 1.0 + c ); h = t * a( iq, ip ); z[ip] -= h; z[iq] += h; d[ip] -= h; d[iq] += h; a( iq, ip ) = 0.0; for ( ssize_t j = 0; j <= ip - 1; ++j ) { g = a( ip, j ); h = a( iq, j ); a( ip, j ) = g - s * ( h + g * tau ); a( iq, j ) = h + s * ( g - h * tau ); } for ( ssize_t j = ip + 1; j <= iq - 1; ++j ) { g = a( j, ip ); h = a( iq, j ); a( j, ip ) = g - s * ( h + g * tau ); a( iq, j ) = h + s * ( g - h * tau ); } for ( size_t j = iq + 1; j < 3; ++j ) { g = a( j, ip ); h = a( j, iq ); a( j, ip ) = g - s * ( h + g * tau ); a( j, iq ) = h + s * ( g - h * tau ); } for ( size_t j = 0; j < 3; ++j ) { g = v( ip, j ); h = v( iq, j ); v( ip, j ) = g - s * ( h + g * tau ); v( iq, j ) = h + s * ( g - h * tau ); } ++rot; } } } } for ( size_t ip = 0; ip < 3; ++ip ) { b[ip] += z[ip]; d[ip] = b[ip]; z[ip] = 0.0; } } return false; } } // namespace vmml #endif vmmlib-1.0/include/vmmlib/cp3_tensor.hpp0000644000175000017500000002101311674116156017702 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * @author Jonas Boesch * * The cp3 tensor class is consists of three basis matrices u1-u3 and R lambda values for a given rank-R approximation * CP stands for Candecomp/Parafac (1970) * - Carroll & Chang, 1970: Analysis of Individual Differences in Multidimensional Scaling via an N-way generalization of ``Eckart--Young'' decompositions, Psychometrika. * - Harshman, 1970: Foundations of the PARAFAC procedure: Models and conditions for an 'explanatory' multi-modal factor analysis,UCLA Working Papers in Phonetics. * - De Lathauwer, De Moor, Vandewalle, 2000: A multilinear singular value decomposition, SIAM J. Matrix Anal. Appl. * - Kolda & Bader, 2009: Tensor Decompositions and Applications, SIAM Review. * */ #ifndef __VMML__CP3_TENSOR__HPP__ #define __VMML__CP3_TENSOR__HPP__ #include #include #include namespace vmml { template< size_t R, size_t I1, size_t I2, size_t I3, typename T_value = float, typename T_coeff = float > class cp3_tensor { public: typedef float T_internal; typedef tensor3< I1, I2, I3, T_value > t3_type; typedef typename t3_type::iterator t3_iterator; typedef typename t3_type::const_iterator t3_const_iterator; typedef tensor3< I1, I2, I3, T_internal > t3_comp_type; typedef tensor3< I1, I2, I3, T_coeff > t3_coeff_type; typedef typename t3_coeff_type::iterator t3_coeff_iterator; typedef typename t3_coeff_type::const_iterator t3_coeff_const_iterator; typedef matrix< I1, R, T_coeff > u1_type; typedef typename u1_type::iterator u1_iterator; typedef typename u1_type::const_iterator u1_const_iterator; typedef matrix< I2, R, T_coeff > u2_type; typedef typename u2_type::iterator u2_iterator; typedef typename u2_type::const_iterator u2_const_iterator; typedef matrix< I3, R, T_coeff > u3_type; typedef typename u3_type::iterator u3_iterator; typedef typename u3_type::const_iterator u3_const_iterator; typedef matrix< I1, R, T_internal > u1_comp_type; typedef matrix< I2, R, T_internal > u2_comp_type; typedef matrix< I3, R, T_internal > u3_comp_type; typedef vector< R, T_internal > lambda_comp_type; typedef vector< R, T_coeff > lambda_type; cp3_tensor( u1_type& U1, u2_type& U2, u3_type& U3, lambda_type& lambdas_ ); cp3_tensor(); ~cp3_tensor(); void get_lambdas( lambda_type& data_ ) const { data_ = *_lambdas; } ; void get_u1( u1_type& U1 ) const { U1 = *_u1; } ; void get_u2( u2_type& U2 ) const { U2 = *_u2; } ; void get_u3( u3_type& U3 ) const { U3 = *_u3; } ; void set_core( const lambda_type& lambdas_ ) { _lambdas = lambda_type( lambdas_ ); _lambdas_comp.cast_from( _lambdas ); } ; void set_u1( u1_type& U1 ) { *_u1 = U1; _u1_comp->cast_from( U1 ); } ; void set_u2( u2_type& U2 ) { *_u2 = U2; _u1_comp->cast_from( U2 ); } ; void set_u3( u3_type& U3 ) { *_u3 = U3; _u1_comp->cast_from( U3 ); } ; void set_lambda_comp( lambda_comp_type& lambdas_ ) { _lambdas_comp = lambda_comp_type( lambdas_ ); _lambdas.cast_from( _lambdas_comp ); } ; void set_u1_comp( u1_comp_type& U1 ) { *_u1_comp = U1; _u1->cast_from( U1 ); } ; void set_u2_comp( u2_comp_type& U2 ) { *_u2_comp = U2; _u1->cast_from( U2 ); } ; void set_u3_comp( u3_comp_type& U3 ) { *_u3_comp = U3; _u1->cast_from( U3 ); } ; void get_lambda_comp( lambda_comp_type& data_ ) const { data_ = _lambdas_comp; } ; void get_u1_comp( u1_comp_type& U1 ) const { U1 = *_u1_comp; } ; void get_u2_comp( u2_comp_type& U2 ) const { U2 = *_u2_comp; } ; void get_u3_comp( u3_comp_type& U3 ) const { U3 = *_u3_comp; } ; void export_to( std::vector< T_coeff >& data_ ) const; void import_from( std::vector< T_coeff >& data_ ); void reconstruct( t3_type& data_ ) const; template< typename T_init > void decompose( const t3_type& data_, T_init init, const size_t max_iterations_ = 100 ); template< typename T_init > void cp_als( const t3_type& data_, T_init init, const size_t max_iterations_ = 100 ); size_t nnz() const; protected: cp3_tensor( const cp3_tensor< R, I1, I1, I1, T_value, T_coeff >& other ) {}; cp3_tensor< R, I1, I1, I1, T_value, T_coeff > operator=( const cp3_tensor< R, I1, I1, I1, T_value, T_coeff >& other ) { return *this; }; void cast_members(); void cast_comp_members(); private: lambda_type* _lambdas ; u1_type* _u1 ; u2_type* _u2 ; u3_type* _u3 ; lambda_comp_type* _lambdas_comp ; u1_comp_type* _u1_comp ; u2_comp_type* _u2_comp ; u3_comp_type* _u3_comp ; }; // class cp3_tensor #define VMML_TEMPLATE_STRING template< size_t R, size_t I1, size_t I2, size_t I3, typename T_value, typename T_coeff > #define VMML_TEMPLATE_CLASSNAME cp3_tensor< R, I1, I2, I3, T_value, T_coeff > VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::cp3_tensor( u1_type& U1, u2_type& U2, u3_type& U3, lambda_type& lambdas_ ) { set_lambdas(lambdas_); set_u1( U1); set_u2( U2); set_u3( U3); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::cp3_tensor() { _lambdas = new vector< R, T_coeff>(); _lambdas->set( 0 ); _u1 = new u1_type(); _u1->zero(); _u2 = new u2_type(); _u2->zero(); _u3 = new u3_type(); _u3->zero(); _lambdas_comp = new vector< R, T_internal>; _lambdas_comp->set( 0 ); _u1_comp = new u1_comp_type; _u1_comp->zero(); _u2_comp = new u2_comp_type; _u2_comp->zero(); _u3_comp = new u3_comp_type; _u3_comp->zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::~cp3_tensor() { delete _u1; delete _u2; delete _u3; delete _lambdas; delete _u1_comp; delete _u2_comp; delete _u3_comp; delete _lambdas_comp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::cast_members() { _u1->cast_from( *_u1_comp ); _u2->cast_from( *_u2_comp ); _u3->cast_from( *_u3_comp ); _lambdas->cast_from( *_lambdas_comp ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::cast_comp_members() { _u1_comp->cast_from( *_u1 ); _u2_comp->cast_from( *_u2 ); _u3_comp->cast_from( *_u3 ); _lambdas_comp->cast_from( _lambdas ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_ ) const { //FIXME: check data types t3_comp_type data; data.cast_from( data_ ); typedef t3_hopm< R, I1, I2, I3, T_internal > hopm_type; hopm_type::reconstruct( data, *_u1_comp, *_u2_comp, *_u3_comp, *_lambdas_comp ); //convert reconstructed data, which is in type T_internal (double, float) to T_value (uint8 or uint16) if( (sizeof(T_value) == 1) || (sizeof(T_value) == 2) ){ data_.float_t_to_uint_t( data ); } else { data_.cast_from( data ); } } VMML_TEMPLATE_STRING template< typename T_init > void VMML_TEMPLATE_CLASSNAME::decompose( const t3_type& data_, T_init init, const size_t max_iterations_ ) { cp_als( data_, init, max_iterations_ ); } VMML_TEMPLATE_STRING template< typename T_init > void VMML_TEMPLATE_CLASSNAME::cp_als( const t3_type& data_, T_init init, const size_t max_iterations_ ) { t3_comp_type data; data.cast_from( data_ ); typedef t3_hopm< R, I1, I2, I3, T_internal > hopm_type; hopm_type::als( data, *_u1_comp, *_u2_comp, *_u3_comp, *_lambdas_comp, init, max_iterations_ ); cast_members(); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::export_to( std::vector< T_coeff >& data_ ) const { u1_const_iterator it = _u1.begin(), it_end = _u1.end(); for( ; it != it_end; ++it ) { data_.push_back( *it ); } u2_const_iterator u2_it = _u2.begin(), u2_it_end = _u2.end(); for( ; u2_it != u2_it_end; ++u2_it ) { data_.push_back( *u2_it ); } u3_const_iterator u3_it = _u3.begin(), u3_it_end = _u3.end(); for( ; u3_it != u3_it_end; ++u3_it ) { data_.push_back( *u3_it ); } //TODO: iterate over lambdas } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::import_from( std::vector< T_coeff >& data_ ) { size_t i = 0; //iterator over data_ u1_iterator it = _u1.begin(), it_end = _u1.end(); for( ; it != it_end; ++it, ++i ) { *it = data_.at(i); } u2_iterator u2_it = _u2.begin(), u2_it_end = _u2.end(); for( ; u2_it != u2_it_end; ++u2_it, ++i ) { *u2_it = data_.at(i); } u3_iterator u3_it = _u3.begin(), u3_it_end = _u3.end(); for( ; u3_it != u3_it_end; ++u3_it, ++i ) { *u3_it = data_.at(i); } //TODO: import lambdas } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz() const { size_t counter = 0; counter += _u1_comp->nnz(); counter += _u2_comp->nnz(); counter += _u3_comp->nnz(); counter += _lambdas_comp->nnz(); return counter; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME } // namespace vmml #endif vmmlib-1.0/include/vmmlib/lapack_gaussian_elimination.hpp0000644000175000017500000001012111674116156023336 0ustar shevekshevek#ifndef __VMML__VMMLIB_LAPACK_GAUSSIAN_ELIMINATION__HPP__ #define __VMML__VMMLIB_LAPACK_GAUSSIAN_ELIMINATION__HPP__ #include #include #include #include #include #include /** * * this is a wrapper for the following lapack routines: * * xGESV * * */ namespace vmml { // XYYZZZ // X = data type: S - float, D - double // YY = matrix type, GE - general, TR - triangular // ZZZ = function name namespace lapack { // // // // SGESV/DGESV // // template< typename float_t > struct xgesv_params { lapack_int n; // order of matrix A = M * N lapack_int nrhs; // number of columns of B float_t* a; // input A, output P*L*U lapack_int lda; // leading dimension of A (for us: number of rows) lapack_int* ipiv; // pivot indices, integer array of size N float_t* b; // input b, output X lapack_int ldb; // leading dimension of b lapack_int info; friend std::ostream& operator << ( std::ostream& os, const xgesv_params< float_t >& p ) { os << "n " << p.n << " nrhs " << p.nrhs << " lda " << p.lda << " ldb " << p.ldb << " info " << p.info << std::endl; return os; } }; #if 0 /* Subroutine */ int dgesv_(integer *n, integer *nrhs, doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *ldb, integer *info); #endif template< typename float_t > inline void xgesv_call( xgesv_params< float_t >& p ) { VMMLIB_ERROR( "not implemented for this type.", VMMLIB_HERE ); } template<> inline void xgesv_call( xgesv_params< float >& p ) { sgesv_( &p.n, &p.nrhs, p.a, &p.lda, p.ipiv, p.b, &p.ldb, &p.info ); } template<> inline void xgesv_call( xgesv_params< double >& p ) { dgesv_( &p.n, &p.nrhs, p.a, &p.lda, p.ipiv, p.b, &p.ldb, &p.info ); } template< size_t M, size_t N, typename float_t > struct gaussian_elimination { // computes x ( Ax = b ). x replaces b on output. void compute( matrix< N, N, float_t >& A, matrix< N, M, float_t >& b ); void compute( matrix< N, N, float_t >& A, vector< N, float_t >& b ); gaussian_elimination(); ~gaussian_elimination(); const lapack::xgesv_params< float_t >& get_params() { return p; } lapack::xgesv_params< float_t > p; }; // struct lapack_linear_least_squares template< size_t M, size_t N, typename float_t > void gaussian_elimination< M, N, float_t >:: compute( matrix< N, N, float_t >& A, matrix< N, M, float_t >& b ) { p.a = A.array; p.b = b.array; lapack::xgesv_call( p ); if ( p.info != 0 ) { if ( p.info < 0 ) VMMLIB_ERROR( "invalid value in input matrix", VMMLIB_HERE ); else VMMLIB_ERROR( "factor U is exactly singular, solution could not be computed.", VMMLIB_HERE ); } } template< size_t M, size_t N, typename float_t > void gaussian_elimination< M, N, float_t >:: compute( matrix< N, N, float_t >& A, vector< N, float_t >& b ) { p.a = A.array; p.b = b.array; lapack::xgesv_call( p ); if ( p.info != 0 ) { if ( p.info < 0 ) VMMLIB_ERROR( "invalid value in input matrix", VMMLIB_HERE ); else VMMLIB_ERROR( "factor U is exactly singular, solution could not be computed.", VMMLIB_HERE ); } } template< size_t M, size_t N, typename float_t > gaussian_elimination< M, N, float_t >:: gaussian_elimination() { p.n = N; p.nrhs = M; p.lda = N; p.ldb = N; p.ipiv = new lapack_int[ N ]; } template< size_t M, size_t N, typename float_t > gaussian_elimination< M, N, float_t >:: ~gaussian_elimination() { delete[] p.ipiv; } } // namespace lapack } // namespace vmml #endif vmmlib-1.0/include/vmmlib/tensor3_iterator.hpp0000644000175000017500000001167411674116156021145 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Jonas Boesch * @author Susanne Suter * * */ #ifndef __VMML__TENSOR3_ITERATOR__HPP__ #define __VMML__TENSOR3_ITERATOR__HPP__ #include namespace vmml { template< typename T > class tensor3_iterator { public: typedef typename T::value_type value_type; typedef typename T::pointer pointer; typedef typename T::reference reference; typedef typename std::forward_iterator_tag iterator_category; typedef size_t difference_type; typedef typename matrix< T::ROWS, T::COLS, typename T::value_type >::iterator matrix_iterator; typedef typename T::front_slice_type slice_type; tensor3_iterator() : _tensor3( 0 ), _matrix_index( 0 ) {}; tensor3_iterator( T& t_, bool begin_ ) : _tensor3( &t_ ), _matrix_index( 0 ) { if ( begin_ ) { _matrix_index = 0; slice_type& slice_ = _tensor3->get_frontal_slice_fwd( _matrix_index ); _matrix_it = slice_.begin(); _matrix_it_end = slice_.end(); } else { _matrix_index = T::SLICES - 1; slice_type& slice_ = _tensor3->get_frontal_slice_fwd( _matrix_index ); _matrix_it = slice_.end(); _matrix_it_end = slice_.begin(); } } value_type& operator*() { return *_matrix_it; } const value_type& operator*() const { return *_matrix_it; } bool operator==( const tensor3_iterator& it_ ) const { return it_._tensor3 == _tensor3 // && it_._matrix_index == _matrix_index && it_._matrix_it == _matrix_it; } bool operator!=( const tensor3_iterator& it_ ) const { return ! operator==(it_); } void operator++() { if ( _tensor3 == 0 ) { VMMLIB_ERROR( "attempt to increase singular iterator", VMMLIB_HERE ); } if ( _matrix_it != _matrix_it_end ) ++_matrix_it; if ( _matrix_it == _matrix_it_end && _matrix_index < T::SLICES - 1 ) { ++_matrix_index; //slice_type& slice_ = _tensor3->get_frontal_slice( _matrix_index ); _matrix_it = _tensor3->get_frontal_slice_fwd( _matrix_index ).begin(); _matrix_it_end = _tensor3->get_frontal_slice_fwd( _matrix_index ).end(); } } protected: matrix_iterator _matrix_it; matrix_iterator _matrix_it_end; T* _tensor3; size_t _matrix_index; }; //end tensor3_iterator class template< typename T > class tensor3_const_iterator { public: typedef typename T::value_type value_type; typedef typename T::pointer pointer; typedef typename T::reference reference; typedef typename std::forward_iterator_tag iterator_category; typedef size_t difference_type; typedef typename matrix< T::ROWS, T::COLS, typename T::value_type >::const_iterator matrix_iterator; typedef typename T::front_slice_type slice_type; tensor3_const_iterator() : _tensor3( 0 ), _matrix_index( 0 ) {}; tensor3_const_iterator( const T& t_, bool begin_ ) : _tensor3( &t_ ), _matrix_index( 0 ) { if ( begin_ ) { _matrix_index = 0; const slice_type& slice_ = _tensor3->get_frontal_slice_fwd( _matrix_index ); _matrix_it = slice_.begin(); _matrix_it_end = slice_.end(); } else { _matrix_index = T::SLICES - 1; const slice_type& slice_ = _tensor3->get_frontal_slice_fwd( _matrix_index ); _matrix_it = slice_.end(); _matrix_it_end = slice_.begin(); } } const value_type& operator*() const { return *_matrix_it; } bool operator==( const tensor3_const_iterator& it_ ) const { return it_._matrix_it == _matrix_it; } bool operator!=( const tensor3_const_iterator& it_ ) const { return it_._matrix_it != _matrix_it; } void operator++() { if ( _tensor3 == 0 ) { VMMLIB_ERROR( "attempt to increase singular iterator", VMMLIB_HERE ); } if ( _matrix_it != _matrix_it_end ) ++_matrix_it; if ( _matrix_it == _matrix_it_end && _matrix_index < T::SLICES - 1 ) { ++_matrix_index; //const slice_type& slice_ = _tensor3->get_frontal_slice( _matrix_index ); _matrix_it = _tensor3->get_frontal_slice_fwd( _matrix_index ).begin(); _matrix_it_end = _tensor3->get_frontal_slice_fwd( _matrix_index ).end(); } } protected: matrix_iterator _matrix_it; matrix_iterator _matrix_it_end; const T* _tensor3; size_t _matrix_index; }; //end tensor3_const_iterator class }// end vmml namespace #endif vmmlib-1.0/include/vmmlib/qtucker3_tensor.hpp0000644000175000017500000004234611674116156020772 0ustar shevekshevek/* * VMMLib - Tensor Classes * * @author Susanne Suter * * Quantized version of Tucker3 tensor * - 16bit linear factor matrices quantization * - 8bit logarithmic core tensor quantization * * reference: * - Suter, Iglesias, Marton, Agus, Elsener, Zollikofer, Gopi, Gobbetti, and Pajarola: * "Interactive Multiscale Tensor Reconstruction for Multiresolution Volume Visualization", * IEEE Transactions on Visualization and Computer Graphics. 2011. * */ #ifndef __VMML__QTUCKER3_TENSOR__HPP__ #define __VMML__QTUCKER3_TENSOR__HPP__ #define CORE_RANGE 127 #include namespace vmml { template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value = float, typename T_coeff = double > class qtucker3_tensor { public: typedef float T_internal; typedef qtucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > tucker3_type; typedef tensor3< I1, I2, I3, T_value > t3_type; typedef tensor3< I1, I2, I3, T_coeff > t3_coeff_type; typedef tensor3< R1, R2, R3, T_coeff > t3_core_type; typedef matrix< I1, R1, T_coeff > u1_type; typedef matrix< I2, R2, T_coeff > u2_type; typedef matrix< I3, R3, T_coeff > u3_type; typedef tensor3< I1, I2, I3, T_internal > t3_comp_type; typedef tensor3< R1, R2, R3, T_internal > t3_core_comp_type; typedef matrix< I1, R1, T_internal > u1_comp_type; typedef matrix< I2, R2, T_internal > u2_comp_type; typedef matrix< I3, R3, T_internal > u3_comp_type; typedef tensor3< R1, R2, R3, char > t3_core_signs_type; static const size_t SIZE = R1*R2*R3 + I1*R1 + I2*R2 + I3*R3; qtucker3_tensor(); qtucker3_tensor( t3_core_type& core ); qtucker3_tensor( t3_core_type& core, u1_type& U1, u2_type& U2, u3_type& U3 ); qtucker3_tensor( const t3_type& data_, u1_type& U1, u2_type& U2, u3_type& U3 ); qtucker3_tensor( const tucker3_type& other ); ~qtucker3_tensor(); void enable_quantify_hot() { _is_quantify_hot = true; _is_quantify_log = false; _is_quantify_linear = false;}; void disable_quantify_hot() { _is_quantify_hot = false; } ; void enable_quantify_linear() { _is_quantify_linear = true; _is_quantify_hot = false;}; void disable_quantify_linear() { _is_quantify_linear = false; } ; void enable_quantify_log() { _is_quantify_log = true; _is_quantify_hot = false;}; void disable_quantify_log() { _is_quantify_log = false; } ; void get_core_signs( t3_core_signs_type& signs_ ) { signs_ = _signs; }; void set_core_signs( const t3_core_signs_type signs_ ) { _signs = signs_; } ; T_internal get_hottest_value() { return _hottest_core_value; }; void set_hottest_value( const T_internal value_ ) { _hottest_core_value = value_; } ; void set_core( t3_core_type& core ) { _core = t3_core_type( core ); _core_comp.cast_from( core ); } ; void set_u1( u1_type& U1 ) { *_u1 = U1; _u1_comp->cast_from( U1 ); } ; void set_u2( u2_type& U2 ) { *_u2 = U2; _u2_comp->cast_from( U2 ); } ; void set_u3( u3_type& U3 ) { *_u3 = U3; _u3_comp->cast_from( U3 ); } ; void get_core( t3_core_type& data_ ) const { data_ = _core; } ; void get_u1( u1_type& U1 ) const { U1 = *_u1; } ; void get_u2( u2_type& U2 ) const { U2 = *_u2; } ; void get_u3( u3_type& U3 ) const { U3 = *_u3; } ; void set_core_comp( t3_core_comp_type& core ) { _core_comp = t3_core_comp_type( core ); _core.cast_from( _core_comp ); } ; void set_u1_comp( u1_comp_type& U1 ) { *_u1_comp = U1; _u1->cast_from( U1 ); } ; void set_u2_comp( u2_comp_type& U2 ) { *_u2_comp = U2; _u2->cast_from( U2 ); } ; void set_u3_comp( u3_comp_type& U3 ) { *_u3_comp = U3; _u3->cast_from( U3 ); } ; void get_core_comp( t3_core_comp_type& data_ ) const { data_ = _core_comp; } ; void get_u1_comp( u1_comp_type& U1 ) const { U1 = *_u1_comp; } ; void get_u2_comp( u2_comp_type& U2 ) const { U2 = *_u2_comp; } ; void get_u3_comp( u3_comp_type& U3 ) const { U3 = *_u3_comp; } ; //get number of nonzeros for tensor decomposition size_t nnz() const; size_t nnz( const T_value& threshold ) const; size_t nnz_core() const; size_t size_core() const; size_t size() const { return SIZE; } ; void threshold_core( const size_t& nnz_core_, size_t& nnz_core_is_ ); void threshold_core( const T_coeff& threshold_value_, size_t& nnz_core_ ); void reconstruct( t3_type& data_, const T_internal& u_min_, const T_internal& u_max_, const T_internal& core_min_, const T_internal& core_max_ ); void reconstruct( t3_type& data_, const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_, const T_internal& core_min_, const T_internal& core_max_ ); template< typename T_init> void decompose( const t3_type& data_, T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_, T_internal& core_min_, T_internal& core_max_, T_init init ); template< typename T_init> void decompose( const t3_type& data_, T_internal& u_min_, T_internal& u_max_, T_internal& core_min_, T_internal& core_max_, T_init init ); template< typename T_init> void tucker_als( const t3_type& data_, T_init init ); friend std::ostream& operator << ( std::ostream& os, const tucker3_type& t3 ) { t3_core_type core; t3.get_core( core ); u1_type* u1 = new u1_type; t3.get_u1( *u1 ); u2_type* u2 = new u2_type; t3.get_u2( *u2 ); u3_type* u3 = new u3_type; t3.get_u3( *u3 ); os << "U1: " << std::endl << *u1 << std::endl << "U2: " << std::endl << *u2 << std::endl << "U3: " << std::endl << *u3 << std::endl << "core: " << std::endl << core << std::endl; delete u1; delete u2; delete u3; return os; } void cast_members(); void cast_comp_members(); void quantize_basis_matrices( T_internal& u_min_, T_internal& u_max_ ); void quantize_basis_matrices( T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_ ); void quantize_core( T_internal& core_min_, T_internal& core_max_ ); void dequantize_basis_matrices( const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_ ); void dequantize_core( const T_internal& core_min_, const T_internal& core_max_ ); protected: tucker3_type operator=( const tucker3_type& other ) { return (*this); }; template< typename T_init> void decompose( const t3_type& data_, T_init init ); void reconstruct( t3_type& data_ ); private: //t3_core_type* _core ; u1_type* _u1 ; u2_type* _u2 ; u3_type* _u3 ; t3_core_type _core ; //used only internally for computations to have a higher precision t3_core_comp_type _core_comp ; u1_comp_type* _u1_comp ; u2_comp_type* _u2_comp ; u3_comp_type* _u3_comp ; T_internal _hottest_core_value; t3_core_signs_type _signs; bool _is_quantify_hot; bool _is_quantify_log; bool _is_quantify_linear; }; // class qtucker3_tensor #define VMML_TEMPLATE_STRING template< size_t R1, size_t R2, size_t R3, size_t I1, size_t I2, size_t I3, typename T_value, typename T_coeff > #define VMML_TEMPLATE_CLASSNAME qtucker3_tensor< R1, R2, R3, I1, I2, I3, T_value, T_coeff > VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::qtucker3_tensor( ) : _is_quantify_hot( false ), _hottest_core_value( 0 ) , _is_quantify_linear( false ), _is_quantify_log( false ) { _core.zero(); _u1 = new u1_type(); _u1->zero(); _u2 = new u2_type(); _u2->zero(); _u3 = new u3_type(); _u3->zero(); _core_comp.zero(); _u1_comp = new u1_comp_type(); _u1_comp->zero(); _u2_comp = new u2_comp_type(); _u2_comp->zero(); _u3_comp = new u3_comp_type(); _u3_comp->zero(); _signs.zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::qtucker3_tensor( t3_core_type& core ) : _is_quantify_hot( false ), _hottest_core_value( 0 ) , _is_quantify_linear( false ), _is_quantify_log( false ) { _core = core; _u1 = new u1_type(); _u1->zero(); _u2 = new u2_type(); _u2->zero(); _u3 = new u3_type(); _u3->zero(); _u1_comp = new u1_comp_type(); _u1_comp->zero(); _u2_comp = new u2_comp_type(); _u2_comp->zero(); _u3_comp = new u3_comp_type(); _u3_comp->zero(); _core_comp.cast_from( core ); _signs.zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::qtucker3_tensor( t3_core_type& core, u1_type& U1, u2_type& U2, u3_type& U3 ) : _is_quantify_hot( false ), _hottest_core_value( 0 ) , _is_quantify_linear( false ), _is_quantify_log( false ) { _core = core; _u1 = new u1_type( U1 ); _u2 = new u2_type( U2 ); _u3 = new u3_type( U3 ); _u1_comp = new u1_comp_type(); _u2_comp = new u2_comp_type(); _u3_comp = new u3_comp_type(); cast_comp_members(); _signs.zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::qtucker3_tensor( const t3_type& data_, u1_type& U1, u2_type& U2, u3_type& U3 ) : _is_quantify_hot( false ), _hottest_core_value( 0 ) , _is_quantify_linear( false ), _is_quantify_log( false ) { _u1 = new u1_type( U1 ); _u2 = new u2_type( U2 ); _u3 = new u3_type( U3 ); _u1_comp = new u1_comp_type(); _u2_comp = new u2_comp_type(); _u3_comp = new u3_comp_type(); t3_hooi< R1, R2, R3, I1, I2, I3, T_coeff >::derive_core( data_, *_u1, *_u2, *_u3, _core ); cast_comp_members(); _signs.zero(); } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::qtucker3_tensor( const tucker3_type& other ) : _is_quantify_hot( false ), _hottest_core_value( 0 ) , _is_quantify_linear( false ), _is_quantify_log( false ) { _u1 = new u1_type(); _u2 = new u2_type(); _u3 = new u3_type(); _u1_comp = new u1_comp_type(); _u2_comp = new u2_comp_type(); _u3_comp = new u3_comp_type(); other.get_core( _core ); other.get_u1( *_u1 ); other.get_u2( *_u2 ); other.get_u3( *_u3 ); cast_comp_members(); _signs.zero(); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::cast_members() { _u1->cast_from( *_u1_comp ); _u2->cast_from( *_u2_comp ); _u3->cast_from( *_u3_comp ); _core.cast_from( _core_comp); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::cast_comp_members() { _u1_comp->cast_from( *_u1 ); _u2_comp->cast_from( *_u2 ); _u3_comp->cast_from( *_u3 ); _core_comp.cast_from( _core); } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz_core() const { return _core_comp.nnz(); } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::size_core() const { return _core_comp.size(); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::quantize_basis_matrices(T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_ ) { _u1_comp->quantize( *_u1, u1_min_, u1_max_ ); _u2_comp->quantize( *_u2, u2_min_, u2_max_ ); _u3_comp->quantize( *_u3, u3_min_, u3_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::quantize_basis_matrices(T_internal& u_min_, T_internal& u_max_) { u_min_ = _u1_comp->get_min(); T_internal u2_min = _u2_comp->get_min(); T_internal u3_min = _u3_comp->get_min(); if ( u2_min < u_min_) { u_min_ = u2_min; } if ( u3_min < u_min_) { u_min_ = u3_min; } u_max_ = _u1_comp->get_max(); T_internal u2_max = _u2_comp->get_max(); T_internal u3_max = _u3_comp->get_max(); if ( u2_max > u_max_ ) { u_max_ = u2_max; } if ( u3_max > u_max_ ) { u_max_ = u3_max; } _u1_comp->quantize_to( *_u1, u_min_, u_max_ ); _u2_comp->quantize_to( *_u2, u_min_, u_max_ ); _u3_comp->quantize_to( *_u3, u_min_, u_max_ ); #if 0 std::cout << "quantized (1u): " << std::endl << "u1-u3: " << std::endl << *_u1 << std::endl << *_u1_comp << std::endl << *_u2 << std::endl << *_u2_comp << std::endl << *_u3 << std::endl << *_u3_comp << std::endl << " core " << std::endl << _core << std::endl << " core_comp " << std::endl << _core_comp << std::endl; #endif } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::quantize_core( T_internal& core_min_, T_internal& core_max_ ) { if ( _is_quantify_hot ) { _hottest_core_value = _core_comp.at(0,0,0); _core_comp.at( 0, 0, 0 ) = 0; _core_comp.quantize_log( _core, _signs, core_min_, core_max_, T_coeff(CORE_RANGE) ); } else if ( _is_quantify_linear ) { _core_comp.quantize( _core, core_min_, core_max_ ); } else if ( _is_quantify_log ) { _core_comp.quantize_log( _core, _signs, core_min_, core_max_, T_coeff(CORE_RANGE) ); } else { _core_comp.quantize( _core, core_min_, core_max_ ); std::cout << "quant.method not specified" << std::endl; } } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::dequantize_basis_matrices( const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_ ) { _u1->dequantize( *_u1_comp, u1_min_, u1_max_ ); _u2->dequantize( *_u2_comp, u2_min_, u2_max_ ); _u3->dequantize( *_u3_comp, u3_min_, u3_max_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::dequantize_core( const T_internal& core_min_, const T_internal& core_max_ ) { if ( _is_quantify_hot ) { _core.dequantize_log( _core_comp, _signs, core_min_, core_max_ ); _core.at(0,0,0) = _hottest_core_value; _core_comp.at(0,0,0) = _hottest_core_value; } else if ( _is_quantify_linear ) { _core.dequantize( _core_comp, core_min_, core_max_ ); } else if ( _is_quantify_log ) { _core.dequantize_log( _core_comp, _signs, core_min_, core_max_ ); } else { _core.dequantize( _core_comp, core_min_, core_max_ ); } } VMML_TEMPLATE_STRING VMML_TEMPLATE_CLASSNAME::~qtucker3_tensor( ) { delete _u1; delete _u2; delete _u3; delete _u1_comp; delete _u2_comp; delete _u3_comp; } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_, const T_internal& u_min_, const T_internal& u_max_, const T_internal& core_min_, const T_internal& core_max_ ) { dequantize_basis_matrices( u_min_, u_max_, u_min_, u_max_, u_min_, u_max_ ); dequantize_core( core_min_, core_max_ ); #if 0 std::cout << "dequantized (1u): " << std::endl << "u1-u3: " << std::endl << *_u1 << std::endl << *_u1_comp << std::endl << *_u2 << std::endl << *_u2_comp << std::endl << *_u3 << std::endl << *_u3_comp << std::endl << " core " << std::endl << _core << std::endl << " core_comp " << std::endl << _core_comp << std::endl; #endif reconstruct( data_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_, const T_internal& u1_min_, const T_internal& u1_max_, const T_internal& u2_min_, const T_internal& u2_max_, const T_internal& u3_min_, const T_internal& u3_max_, const T_internal& core_min_, const T_internal& core_max_ ) { dequantize_basis_matrices( u1_min_, u1_max_, u2_min_, u2_max_, u3_min_, u3_max_ ); dequantize_core( core_min_, core_max_ ); reconstruct( data_ ); } VMML_TEMPLATE_STRING void VMML_TEMPLATE_CLASSNAME::reconstruct( t3_type& data_ ) { t3_comp_type data; data.cast_from( data_ ); data.full_tensor3_matrix_multiplication( _core_comp, *_u1_comp, *_u2_comp, *_u3_comp ); //convert reconstructed data, which is in type T_internal (double, float) to T_value (uint8 or uint16) if( (sizeof(T_value) == 1) || (sizeof(T_value) == 2) ){ data_.float_t_to_uint_t( data ); } else { data_.cast_from( data ); } } VMML_TEMPLATE_STRING template< typename T_init> void VMML_TEMPLATE_CLASSNAME::decompose( const t3_type& data_, T_init init ) { tucker_als( data_, init ); } VMML_TEMPLATE_STRING template< typename T_init> void VMML_TEMPLATE_CLASSNAME::decompose( const t3_type& data_, T_internal& u1_min_, T_internal& u1_max_, T_internal& u2_min_, T_internal& u2_max_, T_internal& u3_min_, T_internal& u3_max_, T_internal& core_min_, T_internal& core_max_, T_init init ) { decompose( data_, init ); quantize_basis_matrices( u1_min_, u1_max_, u2_min_, u2_max_, u3_min_, u3_max_ ); quantize_core(core_min_, core_max_ ); } VMML_TEMPLATE_STRING template< typename T_init> void VMML_TEMPLATE_CLASSNAME::decompose( const t3_type& data_, T_internal& u_min_, T_internal& u_max_, T_internal& core_min_, T_internal& core_max_, T_init init ) { decompose( data_, init ); quantize_basis_matrices( u_min_, u_max_ ); quantize_core(core_min_, core_max_ ); } VMML_TEMPLATE_STRING template< typename T_init > void VMML_TEMPLATE_CLASSNAME::tucker_als( const t3_type& data_, T_init init ) { t3_comp_type data; data.cast_from( data_ ); typedef t3_hooi< R1, R2, R3, I1, I2, I3, T_internal > hooi_type; hooi_type::als( data, *_u1_comp, *_u2_comp, *_u3_comp, _core_comp, init ); cast_members(); } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz() const { size_t counter = 0; counter += _u1_comp->nnz(); counter += _u2_comp->nnz(); counter += _u3_comp->nnz(); counter += _core_comp.nnz(); return counter; } VMML_TEMPLATE_STRING size_t VMML_TEMPLATE_CLASSNAME::nnz( const T_value& threshold ) const { size_t counter = 0; counter += _u1_comp->nnz( threshold ); counter += _u2_comp->nnz( threshold ); counter += _u3_comp->nnz( threshold ); counter += _core_comp.nnz( threshold ); return counter; } #undef VMML_TEMPLATE_STRING #undef VMML_TEMPLATE_CLASSNAME } // namespace vmml #endif vmmlib-1.0/include/vmmlib/vmmlib_config.hpp0000644000175000017500000000204111674116156020436 0ustar shevekshevek#ifndef __VMML__VMMLIB_CONFIG__HPP__ #define __VMML__VMMLIB_CONFIG__HPP__ // #define VMMLIB_NO_SFINAE // enabling this switch will have the following effect: // operator T* will not be compiled, but for vectors, // operator[] will instead be used. This means you can // use vec[2] as before, but things like glVertex3fv( vec ) // will not work anymore. //#define VMMLIB_NO_CONVERSION_OPERATORS //#define VMMLIB_DONT_FORCE_ALIGNMENT #ifndef VMMLIB_CUSTOM_CONFIG # ifndef NDEBUG # define VMMLIB_SAFE_ACCESSORS # endif # define VMMLIB_THROW_EXCEPTIONS # ifdef VMMLIB_DONT_FORCE_ALIGNMENT # define VMMLIB_ALIGN( var ) var # else # ifdef __GNUC__ # define VMMLIB_ALIGN( var ) var __attribute__((aligned(16))) # elif defined WIN32 # define VMMLIB_ALIGN( var ) __declspec (align (16)) var # else # error "Alignment macro undefined" # endif # endif #else // we define VMMLIB_ALIGN in case it's not defined in the custom config # ifndef VMMLIB_ALIGN # define VMMLIB_ALIGN( var ) var # endif #endif #endif vmmlib-1.0/include/vmmlib/lapack_sym_eigs.hpp0000644000175000017500000002662711674116156020775 0ustar shevekshevek#ifndef __VMML__VMMLIB_LAPACK_SYM_EIGS__HPP__ #define __VMML__VMMLIB_LAPACK_SYM_EIGS__HPP__ #include #include #include #include #include #include #include /** * * a wrapper for lapack's DSYEVX routine. * DSYEVX computes selected eigenvalues and, optionally, eigenvectors * of a real symmetric matrix A. Eigenvalues and eigenvectors can be * selected by specifying either a range of values or a range of indices * for the desired eigenvalues. * * returns a boolean to indicate success of the operation. * if the return value is false, you can get the parameters using * get_params(). * error states: * * INFO (output) INTEGER * = 0: successful exit. * < 0: if INFO = -i, the i-th argument had an illegal value. * > 0: if DBDSQR did not converge, INFO specifies how many * superdiagonals of an intermediate bidiagonal form B * did not converge to zero. See the description of WORK * above for details. * * more information in: http://www.netlib.org/lapack/double/dsyevx.f (see also: * http://www.netlib.org/lapack/double/dsyev.f , but needs more space) ** */ namespace vmml { namespace lapack { // XYYZZZ // X = data type: S - float, D - double // YY = matrix type, GE - general, TR - triangular // ZZZ = function name template< typename float_t > struct eigs_params { char jobz; char range; char uplo; lapack_int n; float_t* a; lapack_int lda; //leading dimension of input array float_t* vl; float_t* vu; lapack_int il; lapack_int iu; float_t abstol; lapack_int m; //number of found eigenvalues float_t* w; //first m eigenvalues float_t* z; //first m eigenvectors lapack_int ldz; //leading dimension of z float_t* work; lapack_int lwork; lapack_int* iwork; lapack_int* ifail; lapack_int info; friend std::ostream& operator << ( std::ostream& os, const eigs_params< float_t >& p ) { os << " (1)\tjobz " << p.jobz << std::endl << " (2)\trange " << p.range << std::endl << " (3)\tuplo " << p.uplo << std::endl << " (4)\tn " << p.n << std::endl << " (5)\ta " << *p.a << std::endl << " (6)\tlda " << p.lda << std::endl << " (7)\tvl " << p.vl << std::endl << " (8)\tvu " << p.vu << std::endl << " (9)\til " << p.il << std::endl << " (10)\tiu " << p.iu << std::endl << " (11)\tabstol " << p.abstol << std::endl << " (12)\tm " << p.m << std::endl << " (13)\tw " << p.w << std::endl << " (14)\tz " << p.z << std::endl << " (15)\tldz " << p.ldz << std::endl << " (16)\twork " << *p.work << std::endl << " (17)\tlwork " << p.lwork << std::endl << " (18)\tiwork " << *p.iwork << std::endl << " (19)\tifail " << *p.ifail << std::endl << " (20)\tinfo " << p.info << std::endl; return os; } }; #if 0 /* Subroutine */ int dsyevx_( char *jobz, char *range, char *uplo, integer *n, doublereal *a, integer *lda, doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z, integer *ldz, doublereal *work, integer* lwork, integer* iwork, integer* ifail, integer* info ); #endif template< typename float_t > inline void sym_eigs_call( eigs_params< float_t >& p ) { VMMLIB_ERROR( "not implemented for this type.", VMMLIB_HERE ); } template<> inline void sym_eigs_call( eigs_params< float >& p ) { //std::cout << "calling lapack sym x eigs (single precision) " << std::endl; ssyevx_( &p.jobz, &p.range, &p.uplo, &p.n, p.a, &p.lda, p.vl, p.vu, &p.il, &p.iu, &p.abstol, &p.m, p.w, p.z, &p.ldz, p.work, &p.lwork, p.iwork, p.ifail, &p.info ); } template<> inline void sym_eigs_call( eigs_params< double >& p ) { //std::cout << "calling lapack sym x eigs (double precision) " << std::endl; dsyevx_( &p.jobz, &p.range, &p.uplo, &p.n, p.a, &p.lda, p.vl, p.vu, &p.il, &p.iu, &p.abstol, &p.m, p.w, p.z, &p.ldz, p.work, &p.lwork, p.iwork, p.ifail, &p.info ); } } // namespace lapack template< size_t N, typename float_t > struct lapack_sym_eigs { typedef matrix< N, N, float_t > m_input_type; typedef matrix< N, N, float_t > evectors_type; typedef vector< N, float_t > evalues_type; typedef vector< N, float_t > evector_type; typedef typename evalues_type::iterator evalue_iterator; typedef typename evalues_type::const_iterator evalue_const_iterator; typedef std::pair< float_t, size_t > eigv_pair_type; lapack_sym_eigs(); ~lapack_sym_eigs(); // version of reduced sym. eigenvalue decomposition, // computes only the x largest magn. eigenvalues and their corresponding eigenvectors template< size_t X> bool compute_x( const m_input_type& A, matrix< N, X, float_t >& eigvectors, vector< X, float_t >& eigvalues ); // partial sym. eigenvalue decomposition // returns only the largest magn. eigenvalue and the corresponding eigenvector bool compute_1st( const m_input_type& A, evector_type& eigvector, float_t& eigvalue ); //computes all eigenvalues and eigenvectors for matrix A bool compute_all( const m_input_type& A, evectors_type& eigvectors, evalues_type& eigvalues ); inline bool test_success( lapack::lapack_int info ); lapack::eigs_params< float_t > p; const lapack::eigs_params< float_t >& get_params(){ return p; }; // comparison functor struct eigenvalue_compare { inline bool operator()( const eigv_pair_type& a, const eigv_pair_type& b ) { return fabs( a.first ) > fabs( b.first ); } }; }; // struct lapack_sym_eigs template< size_t N, typename float_t > lapack_sym_eigs< N, float_t >::lapack_sym_eigs() { p.jobz = 'V'; // Compute eigenvalues and eigenvectors. p.range = 'A'; // all eigenvalues will be found. p.uplo = 'U'; // Upper triangle of A is stored; or Lower triangle of A is stored. p.n = N; p.a = 0; //If UPLO = 'U', the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. p.lda = N; p.vl = 0; //Not referenced if RANGE = 'A' or 'I'. p.vu = 0; //Not referenced if RANGE = 'A' or 'I'. p.il = 0; //Not referenced if RANGE = 'A' or 'V'. p.iu = 0; //Not referenced if RANGE = 'A' or 'V'. p.abstol = 0.0001; //lie in an interval [a,b] of width less than or equal to ABSTOL + EPS * max( |a|,|b| ) p.m = N; //The total number of eigenvalues found. 0 <= M <= N. p.w = 0; //first m eigenvalues p.z = 0; //first m eigenvectors p.ldz = N; // The leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', LDZ >= max(1,N). p.work = new float_t; //FIXME: check if correct datatype p.iwork = new lapack::lapack_int[5*N]; //[5*N]; // INTEGER array, dimension (5*N) p.ifail = new lapack::lapack_int[N]; //[N]; p.lwork = -1; //8N // workspace query lapack::sym_eigs_call( p ); p.lwork = static_cast< lapack::lapack_int >( p.work[0] ); delete p.work; p.work = new float_t[ p.lwork ]; } template< size_t N, typename float_t > lapack_sym_eigs< N, float_t >::~lapack_sym_eigs() { delete[] p.work; delete[] p.iwork; delete[] p.ifail; } template< size_t N, typename float_t > bool lapack_sym_eigs< N, float_t >::compute_all( const m_input_type& A, evectors_type& eigvectors, evalues_type& eigvalues ) { // lapack destroys the contents of the input matrix m_input_type AA( A ); p.range = 'A'; // all eigenvalues will be found. p.a = AA.array; p.ldz = N; p.w = eigvalues.array; p.z = eigvectors.array; //debug std::cout << p << std::endl; lapack::sym_eigs_call< float_t >( p ); return p.info == 0; } template< size_t N, typename float_t > template< size_t X > bool lapack_sym_eigs< N, float_t >::compute_x( const m_input_type& A, matrix< N, X, float_t >& eigvectors, vector< X, float_t >& eigvalues ) { //(1) get all eigenvalues and eigenvectors evectors_type* all_eigvectors = new evectors_type(); evalues_type all_eigvalues; compute_all( A, *all_eigvectors, all_eigvalues ); //(2) sort the eigenvalues //std::pair< data, original_index >; std::vector< eigv_pair_type > eig_permutations; evalue_const_iterator it = all_eigvalues.begin(), it_end = all_eigvalues.end(); size_t counter = 0; for( ; it != it_end; ++it, ++counter ) { eig_permutations.push_back( eigv_pair_type( *it, counter ) ); } std::sort( eig_permutations.begin(), eig_permutations.end(), eigenvalue_compare() ); //sort the eigenvectors according to eigenvalue permutations evectors_type* sorted_eigvectors = new evectors_type(); evalues_type sorted_eigvalues; typename std::vector< eigv_pair_type >::const_iterator it2 = eig_permutations.begin(), it2_end = eig_permutations.end(); evalue_iterator evalues_it = sorted_eigvalues.begin(); for( counter = 0; it2 != it2_end; ++it2, ++evalues_it, ++counter ) { *evalues_it = it2->first; sorted_eigvectors->set_column( counter, all_eigvectors->get_column( it2->second )); } //(3) select the largest magnitude eigenvalues and the corresponding eigenvectors typename vector< X, float_t >::iterator it3 = eigvalues.begin(), it3_end = eigvalues.end(); evalues_it = sorted_eigvalues.begin(); for( ; it3 != it3_end; ++it3, ++evalues_it ) { *it3 = *evalues_it; } sorted_eigvectors->get_sub_matrix( eigvectors ); delete all_eigvectors; delete sorted_eigvectors; return p.info == 0; } template< size_t N, typename float_t > bool lapack_sym_eigs< N, float_t >::compute_1st( const m_input_type& A, evector_type& eigvector, float_t& eigvalue ) { //(1) get all eigenvalues and eigenvectors evectors_type* all_eigvectors = new evectors_type(); evalues_type all_eigvalues; compute_all( A, *all_eigvectors, all_eigvalues ); //(2) sort the eigenvalues //std::pair< data, original_index >; std::vector< eigv_pair_type > eig_permutations; evalue_const_iterator it = all_eigvalues.begin(), it_end = all_eigvalues.end(); size_t counter = 0; for( ; it != it_end; ++it, ++counter ) { eig_permutations.push_back( eigv_pair_type( *it, counter ) ); } std::sort( eig_permutations.begin(), eig_permutations.end(), eigenvalue_compare() ); //(2) select the largest magnitude eigenvalue and the corresponding eigenvector typename std::vector< eigv_pair_type >::const_iterator it2 = eig_permutations.begin(); eigvalue = it2->first; all_eigvectors->get_column( it2->second, eigvector ); delete all_eigvectors; return p.info == 0; } } // namespace vmml #endif vmmlib-1.0/include/vmmlib/matrix_functors.hpp0000644000175000017500000000651311674116156021062 0ustar shevekshevek#ifndef __VMML__MATRIX_FUNCTORS__HPP__ #define __VMML__MATRIX_FUNCTORS__HPP__ #include #include #include namespace vmml { template< typename T > struct set_to_zero_functor { inline void operator()( T& matrix_ ) const { matrix_ = static_cast< typename T::value_type >( 0.0 ); } }; // struct set_to_zero template< typename T > struct set_to_identity_functor { inline typename enable_if< T::ROWS == T::COLS >::type* operator()( T& matrix_ ) { set_to_zero_functor< T >()( matrix_ ); for( size_t index = 0; index < T::ROWS; ++index ) { matrix_( index, index ) = static_cast< typename T::value_type >( 1.0 ); } return 0; // for sfinae } }; // struct set_to_identity // this functor compares to matrices, and also returns true/equal if // the matrices have the same values but some rows/columns are inverted template< typename T > struct matrix_equals_allow_inverted_rows : std::binary_function< const T&, const T&, bool > { bool operator()( const T& matrix0, const T& matrix1 ) { const size_t r = matrix0.get_number_of_rows(); bool ok = true; for( size_t index = 0; ok && index < r; ++index ) { if ( matrix0.get_row( index ) != matrix1.get_row( index ) && matrix0.get_row( index ) != - matrix1.get_row( index ) ) { ok = false; } } return ok; } bool operator()( const T& matrix0, const T& matrix1, typename T::value_type tolerance ) { const size_t r = matrix0.get_number_of_rows(); bool ok = true; for( size_t index = 0; ok && index < r; ++index ) { if ( ! matrix0.get_row( index ).equals( matrix1.get_row( index ), tolerance ) && ! matrix0.get_row( index ).equals( - matrix1.get_row( index ), tolerance ) ) { ok = false; } } return ok; } }; // struct matrix_equals_allow_inverted_rows template< typename T > struct matrix_equals_allow_inverted_columns : std::binary_function< const T&, const T&, bool > { bool operator()( const T& matrix0, const T& matrix1 ) { const size_t r = matrix0.get_number_of_columns(); bool ok = true; for( size_t index = 0; ok && index < r; ++index ) { if ( matrix0.get_column( index ) != matrix1.get_column( index ) && matrix0.get_column( index ) != - matrix1.get_column( index ) ) { ok = false; } } return ok; } bool operator()( const T& matrix0, const T& matrix1, typename T::value_type tolerance ) { const size_t r = matrix0.get_number_of_columns(); bool ok = true; for( size_t index = 0; ok && index < r; ++index ) { if ( ! matrix0.get_column( index ).equals( matrix1.get_column( index ), tolerance ) && ! matrix0.get_column( index ).equals( - matrix1.get_column( index ), tolerance ) ) { ok = false; } } return ok; } }; // struct matrix_equals_allow_inverted_columns } // namespace vmml #endif vmmlib-1.0/tests/0000755000175000017500000000000011674116154013344 5ustar shevekshevekvmmlib-1.0/tests/svd_test.cpp0000644000175000017500000000627711674116154015717 0ustar shevekshevek#include "svd_test.hpp" #include #include #include #include #include #include #include #include namespace vmml { bool svd_test::run() { bool ok = true; matrix< 6, 3, double > A; matrix< 6, 3, double > U; double AData[] = { .814723686393178936349102, .278498218867048397129338, .957166948242945569980122, .905791937075619224550849, .546881519204983845838797, .485375648722841224191882, .126986816293506055153273, .957506835434297598474984, .800280468888800111670889, .913375856139019393076239, .964888535199276531351131, .141886338627215335961296, .632359246225409510344662, .157613081677548283465740, .421761282626274991436333, .975404049994095245779135e-1, .970592781760615697095318, .915735525189067089968376 }; A = AData; U = AData; vector< 3, double > Wdiag; matrix< 3, 3, double > Vt; svdecompose( U, Wdiag, Vt ); matrix< 6, 3, double > UCorrect; double UCorrectData[] = { -.435998653539668934442375, .248052501692949872724725, -.641901537841745417622974, -.413858526085397582239267, .365805126224619969743657, .390978936345444602618038e-1, -.425433159981805031346624, -.515921235828120217092874, .609523103830292567462124e-1, -.438488038465469687210430, .318922843372823172636288, .722667517578294060776045, -.254348647932865379317491, .315487795595138620363684, -.242833948045244552016442, -.447959737368597288309502, -.580721547093578371878664, -.387545997618539139750737e-1, }; UCorrect = UCorrectData; vector< 3, double > WdiagCorrect; double WdiagCorrectData[] = { 2.65122386125434195136563, 1.05972597504600218876192, .782403321995605693928155 }; WdiagCorrect = WdiagCorrectData; matrix< 3, 3, double > VtCorrect; double VtCorrectData[] = { -.52396587, .85123574, .29282775e-1, -.62351537, -.40676365, .66766152, -.58024852, -.33157359, -.74388884, }; VtCorrect = VtCorrectData; ok = U == UCorrect; if ( ok ) ok = Wdiag == WdiagCorrect; if ( ok ) ok = Vt == VtCorrect; log( "singular value decomposition, maximum precision", ok, true ); double tolerance = 1e-8; ok = U.equals( UCorrect, tolerance ); if ( ok ) ok = Wdiag.equals( WdiagCorrect, tolerance ); if ( ok ) ok = Vt.equals( VtCorrect, tolerance ); log( "singular value decomposition, tolerance 1e-8", ok ); if ( ! ok ) { std::stringstream ss; ss << "U " << U << "\n" << "U correct " << UCorrect << "\n" << "U diff " << UCorrect - U << "\n" << "Wdiag " << Wdiag << "\n" << "Wdiag correct" << WdiagCorrect << "\n" << "Wdiag diff " << WdiagCorrect - Wdiag << "\n" << "Vt " << Vt << "\n" << "Vt correct" << VtCorrect << "\n" << "Vt diff " << VtCorrect - Vt << "\n" << std::endl; log_error( ss.str() ); } return ok; } } vmmlib-1.0/tests/matrix_test.cpp0000644000175000017500000007402111674116154016417 0ustar shevekshevek#include "matrix_test.hpp" #include #include #include namespace vmml { bool matrix_test::run() { bool ok = true; matrix< 2, 3, double > m0; double data[] = { 1, 2, 3, 4, 5, 6 }; // iterator set test { matrix< 2, 3, double > m_correct; m_correct( 0, 0 ) = 1; m_correct( 0, 1 ) = 2; m_correct( 0, 2 ) = 3; m_correct( 1, 0 ) = 4; m_correct( 1, 1 ) = 5; m_correct( 1, 2 ) = 6; m0.set( data, data + 6 ); bool ok = m0 == m_correct; if ( ok ) { matrix< 4, 4, double > m_c2; m_c2( 0, 0 ) = 1; m_c2( 0, 1 ) = 2; m_c2( 0, 2 ) = 3; m_c2( 0, 3 ) = 4; m_c2( 1, 0 ) = 5; m_c2( 1, 1 ) = 6; m_c2( 1, 2 ) = 7; m_c2( 1, 3 ) = 8; m_c2( 2, 0 ) = 9; m_c2( 2, 1 ) = 10; m_c2( 2, 2 ) = 11; m_c2( 2, 3 ) = 12; m_c2( 3, 0 ) = 13; m_c2( 3, 1 ) = 14; m_c2( 3, 2 ) = 15; m_c2( 3, 3 ) = 16; double m2_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; matrix< 4, 4, double > m2; m2.set( m2_data, m2_data + 16 ); ok = m2 == m_c2; //std::cout << m2 << std::endl; //std::cout << m_c2 << std::endl; } log( "iterator set", ok ); } m0.set( data, data + 6 ); // test operator== / operator != { bool ok = true; matrix< 2, 3, double > m0_copy; m0.set( data, data + 6 ); m0_copy.set( data, data + 6 ); ok = m0 == m0_copy; if ( ok ) { ok = ! ( m0 != m0_copy ); } log( "operator==, operator!=", ok ); if ( ! ok ) { std::stringstream error; error << m0 << m0_copy << std::endl; log_error( error.str() ); } } // test equal { bool ok = true; matrix< 2, 3, double > m0_copy; m0.set( data, data + 6 ); m0_copy.set( data, data + 6 ); m0( 0, 0 ) += 0.00000005; bool oper_ok = m0 == m0_copy; bool eq_ok = m0.equals( m0_copy, 0.0000001 ); if ( ! oper_ok && eq_ok ) ok = true; else ok = false; log( "equals( ..., tolerance )", ok ); if ( ! ok ) { std::stringstream error; error << m0 << m0_copy << std::endl; log_error( error.str() ); } } // test copy ctor { bool ok = true; matrix< 2, 3, double > m0_copy( m0 ); ok = m0 == m0_copy; if ( ok ) { ok = ! ( m0 != m0_copy ); } log( "copy constructor", ok ); if ( ! ok ) { std::stringstream error; error << m0 << m0_copy << std::endl; log_error( error.str() ); } } // test ::IDENTITY / ::ZERO { bool ok = true; matrix< 5, 5, double > identity( matrix< 5, 5, double >::IDENTITY ); matrix< 5, 2, double > zero( matrix< 5, 2, double >::ZERO ); double id_data[] = { 1,0,0,0,0, 0,1,0,0,0, 0,0,1,0,0, 0,0,0,1,0, 0,0,0,0,1 }; matrix< 5, 5, double > id_correct; id_correct = id_data; double zero_data[] = { 0,0,0,0,0, 0,0,0,0,0 }; matrix< 5, 2, double > zero_correct; zero_correct = zero_data; ok = identity == id_correct; if ( ok ) ok = zero == zero_correct; log( "static IDENTITY, ZERO members", ok ); if ( ! ok ) { std::stringstream error; error << "identity " << identity << "zero " << zero << std::endl; log_error( error.str() ); } } // test operator+, operator += { bool ok = true; matrix< 2, 2, double > m0, m1; double m0_data[] = { 1, 2, 3, 4 }; double m1_data[] = { 2, 3, 4, 5 }; m0 = m0_data; m1 = m1_data; matrix< 2, 2, double > result; double result_data[] = { 3, 5, 7, 9 }; result = result_data; ok = result == m0 + m1; if ( ok ) { m0 = m0_data; m0 += m1; ok = result == m0; } log( "matrix addition: operator+, operator+=", ok ); } // test operator+, operator += { bool ok = true; matrix< 2, 2, double > m0, m1; double m0_data[] = { 3, 5, 7, 9 }; double m1_data[] = { 2, 3, 4, 5 }; m0 = m0_data; m1 = m1_data; matrix< 2, 2, double > result; double result_data[] = { 1, 2, 3, 4 }; result = result_data; ok = result == m0 - m1; if ( ok ) { m0 = m0_data; m0 -= m1; ok = result == m0; } log( "matrix subtraction: operator-, operator-=", ok ); } // test operator[] { bool ok = true; m0 = data; ok = m0[ 1 ][ 1 ] == 5; if ( ok ) ok = m0[ 1 ][ 1 ] == m0.at( 1, 1 ); if ( ok ) { m0[ 1 ][ 2 ] = 23; ok = m0.at( 1, 2 ) == 23; } log( "operator[]", ok ); if ( ! ok ) { std::stringstream error; error << " m0 " << m0 << " m0[ 1 ][ 1 ] " << m0[ 1 ][ 1 ] << " m0.at( 1, 1 ) " << m0.at( 1, 1 ) << std::endl; log_error( error.str() ); } } // test getRow/setRow/getColumn/setColumn { bool ok = true; matrix< 2, 3, double > M; double Mdata[] = { 1, 2, 3, 4, 5, 6 }; M = Mdata; matrix< 1, 3, double > M_row; M.get_row( 1, M_row ); matrix< 2, 1, double > M_column; M.get_column( 2, M_column ); for( size_t column = 0; ok && column < 3; ++column ) { ok = M.at( 1, column ) == M_row.at( 0, column ); } for( size_t row = 0; ok && row < 2; ++row ) { ok = M.at( row, 2 ) == M_column.at( row, 0 ); } double Mdata_row[] = { 3, 2, 5, 4, 5, 6 }; matrix< 2, 3, double > Mr; Mr = Mdata_row; M = Mdata; M_row.at( 0, 0 ) = 3; M_row.at( 0, 1 ) = 2; M_row.at( 0, 2 ) = 5; M.set_row( 0, M_row ); for( size_t column = 0; ok && column < 3; ++column ) { ok = M == Mr; } double Mdata_column[] = { 1, 5, 3, 4, 2, 6 }; matrix< 2, 3, double > Mc; Mc = Mdata_column; M = Mdata; M_column.at( 0, 0 ) = 5; M_column.at( 1, 0 ) = 2; M.set_column( 1, M_column ); for( size_t row = 0; ok && row < 2; ++row ) { ok = M == Mc; } log( "get/set_row(),get/set_column()", ok ); if ( ! ok ) { std::stringstream error; error << "M " << M << "M_row " << M_row << "Mr " << Mr << "M_column " << M_column << "Mc " << Mc << std::endl; log_error( error.str() ); } } // test transpose functionality { bool ok = true; m0 = data; matrix< 3, 2, double > m1; matrix< 3, 2, double > m0t = transpose( m0 ); m1.set( data, data + 6, false ); ok = m1 == m0t; log( "transpose(), transpose_to()", ok ); if ( !ok ) { std::stringstream error; error << m1 << m0t << std::endl; log_error( error.str() ); } } // test multiplication { bool ok = true; matrix< 2, 3, double > mul0; double mul0data[] = { 1, 0, 2, -1, 3, 1 }; mul0 = mul0data; matrix< 3, 2, double > mul1; double mul1data[] = { 3, 1, 2, 1, 1, 0 }; mul1 = mul1data; matrix< 2, 2, double > result; result.multiply( mul0, mul1 ); matrix< 2, 2, double > correct_result; double correct_result_data[] = { 5, 1, 4, 2 }; correct_result = correct_result_data; ok = result == correct_result; if ( ok ) { result = mul0 * mul1; ok = result == correct_result; } if ( ok ) { matrix< 2, 2, double > id2; identity( id2 ); if ( result * id2 != result ) { ok = false; } } if ( ok ) { #if 1 matrix< 2, 2, double > mul0, mul1; matrix< 2, 2, double > correct_result; double res_data[] = { 3, 1, 4, 1 }; correct_result = res_data; #endif mul0.set( mul0data, mul0data + 4 ); mul1.set( mul1data, mul1data + 4 ); mul0 *= mul1; ok = mul0 == correct_result; } log( "matrix multiplication ( multiply(), operator*, operator*= )", ok ); if ( ! ok ) { std::stringstream error; error << "result = M0 * M1 \n" << "M0 " << mul0 << "M1 " << mul1 << "result " << result << std::endl; log_error( error.str() ); } } // test matrix * column vector multiplication { bool ok = true; matrix< 4, 4, double > transform; double transformData[] = { 0.6555, 0.2769, 0.6948, 0.4387, 0.1712, 0.0462, 0.3171, 0.3816, 0.7060, 0.0971, 0.9502, 0.7655, 0, 0, 0, 1 }; transform = transformData; vector< 4, double > v; double vData[] = { 0.1869, 0.4898, 0.4456, 1 }; v = vData; vector< 4, double > v_result; v_result = transform * v; vector< 4, double > v_correct_result; double vResultData[] = { 1.0064414500000000707302660885034, .57752579999999997806270357614267, 1.3684200999999998060729922144674, 1. }; v_correct_result = vResultData; ok = v_result.equals( v_correct_result, 1e-12 ); log( "matrix * vector multiplication", ok ); if ( ! ok ) { std::stringstream ss; ss << "A " << transform << "v " << v << "\n" << "v_result " << v_result << "\n" << "correct result " << v_correct_result << "\n" << std::endl; log_error( ss.str() ); } } // test matrix4x4 * vector3 multiplication { bool ok = true; matrix< 4, 4, double > transform; double transformData[] = { 0.6555, 0.2769, 0.6948, 0.4387, 0.1712, 0.0462, 0.3171, 0.3816, 0.7060, 0.0971, 0.9502, 0.7655, 0, 0, 0, 1 }; transform = transformData; vector< 3, double > v; double vData[] = { 0.1869, 0.4898, 0.4456 }; v = vData; vector< 3, double > v_result; v_result = transform * v; vector< 3, double > v_correct_result; double vResultData[] = { 1.0064414500000000707302660885034, .57752579999999997806270357614267, 1.3684200999999998060729922144674, 1. }; v_correct_result = vResultData; ok = v_result.equals( v_correct_result, 1e-12 ); log( "matrix4x4 * vector3 ( m4x4 * v4( v3.xyz, 1.0 ) ) multiplication", ok ); if ( ! ok ) { std::stringstream ss; ss << "A " << transform << "v " << v << "\n" << "v_result " << v_result << "\n" << "correct result " << v_correct_result << "\n" << "diff " << v_result - v_correct_result << "\n" << std::endl; log_error( ss.str() ); } } #ifdef VMMLIB_SAFE_ACCESSORS ok = true; { matrix< 3, 2 > m; try { m.at( 3, 2 ); ok = false; } catch(...) {} try { if ( ok ) m.at( 1, 1 ); } catch(...) { ok = false; } try { if ( ok ) { m[ 3 ][ 2 ]; ok = false; } } catch(...) {} log( "safe accessors (debug option)", ok ); } #endif // getSubMatrix { matrix< 2, 3, double > m_src; double m_src_data[] = { 1, 2, 3, 4, 5, 6 }; m_src = m_src_data; matrix< 1, 2, double > m_sub; m_src.get_sub_matrix( m_sub, 1, 1 ); matrix< 1, 2, double > result; double res_data[] = { 5, 6 }; result = res_data; bool ok = m_sub == result; log( "get_sub_matrix()", ok ); } { matrix< 2, 3, double > m_src; double m_src_data[] = { 1, 2, 3, 4, 5, 6 }; m_src = m_src_data; matrix< 2, 2, double > m_sub; double m_sub_data[] = { 7, 8, 9, 0 }; m_sub = m_sub_data; m_src.set_sub_matrix( m_sub, 0, 1 ); matrix< 2, 3, double > result; double res_data[] = { 1, 7, 8, 4, 9, 0 }; result = res_data; bool ok = m_src == result; log( "set_sub_matrix()", ok ); } // matrix inversion for 2x2 { bool ok = true; matrix< 2, 2, double > M, M_inverse, M_inverse_correct; double Mdata[] = #if 1 { 1., 3., 4., 2. }; #else { .81472368639317893634910205946653, .12698681629350605515327288230765, .90579193707561922455084868488484, .91337585613901939307623933927971 }; #endif M = Mdata; double M_inverse_correct_data[] = #if 1 { -0.2, 0.3, 0.4, -0.1 }; #else { 1.4518186460466018239401364553487, -.20184661818884985784450236678822, -1.4397639425722887906999858387280, 1.2950101881184494789778227641364 }; #endif M_inverse_correct = M_inverse_correct_data; M.inverse( M_inverse ); ok = M_inverse == M_inverse_correct; log( "matrix inversion for 2x2 matrices, maximum precision", ok, true ); if ( ! ok ) { ok = M_inverse.equals( M_inverse_correct, 1e-15 ); log( "matrix inversion 2x2, tolerance: 1e-15.", ok ); } if ( ! ok ) { std::stringstream error; error << "matrix M " << M << "inverse (computed)" << M_inverse << "inverse (correct)" << M_inverse_correct << " diffs " << M_inverse - M_inverse_correct << std::endl; log_error( error.str() ); } } // matrix inversion for 3x3 { bool ok = true; matrix< 3, 3 > M, M_inverse, M_inverse_correct; double Mdata[] = { 8, 1, 6, 3, 5, 7, 4, 9, 2 }; M.set( Mdata, Mdata + 9 ); double M_inverse_correct_data[] = { .14722222222222222222222222222222, -.14444444444444444444444444444444, .63888888888888888888888888888889e-1, -.61111111111111111111111111111111e-1, .22222222222222222222222222222222e-1, .10555555555555555555555555555556, -.19444444444444444444444444444444e-1, .18888888888888888888888888888889, -.10277777777777777777777777777778 }; M_inverse_correct.set( M_inverse_correct_data, M_inverse_correct_data + 9 ); M.inverse( M_inverse ); ok = M_inverse == M_inverse_correct; log( "matrix inversion for 3x3 matrices, maximum precision", ok, true ); if ( ! ok ) { ok = M_inverse.equals( M_inverse_correct, 1e-15 ); log( "matrix inversion 3x3, tolerance: 1e-15.", ok ); } if ( ! ok ) { std::stringstream error; error << "matrix M " << M << "inverse (computed)" << M_inverse << "inverse (correct)" << M_inverse_correct << std::endl; log_error( error.str() ); } } // matrix inversion for 4x4 { bool ok = true; matrix< 4, 4, double > M, M_inverse, M_inverse_correct; double Mdata[] = { 17., 24., 1., 8., 23., 5., 7., 14., 4., 6., 13., 20., 10., 12., 19., 21. }; M.set( Mdata, Mdata + 16 ); double M_inverse_correct_data[] = { -5.780346820809248e-03, 4.962205424633170e-02, -4.811027123165852e-02, 1.493997332147622e-02, 4.277456647398844e-02, -3.797243219208537e-02, -1.013783903957314e-02, 1.867496665184526e-02, -3.930635838150288e-02, -1.333926189417519e-02, -1.333036905291240e-01, 1.508225878168074e-01, 1.387283236994219e-02, 1.013783903957314e-02, 1.493108048021343e-01, -1.066251667407737e-01 }; M_inverse_correct.set( M_inverse_correct_data, M_inverse_correct_data + 16 ); M.inverse( M_inverse ); ok = M_inverse == M_inverse_correct; log( "matrix inversion for 4x4 matrices, maximum precision", ok, true ); if ( ! ok ) { ok = M_inverse.equals( M_inverse_correct, 1e-9 ); log( "matrix inversion 4x4, tolerance: 1e-15.", ok ); } if ( ! ok ) { std::stringstream error; error << "matrix M " << M << "inverse (computed)" << M_inverse << "inverse (correct)" << M_inverse_correct << "diff " << M_inverse - M_inverse_correct << std::endl; log_error( error.str() ); } } // set( .... ) { bool ok = true; double mData[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; matrix< 4, 4, double > m4x4; matrix< 4, 4, double > m4x4C; m4x4C = mData; m4x4.set( mData, mData + 16, true ); ok = m4x4 == m4x4C; m4x4C = transpose( m4x4C ); m4x4.set( mData, mData + 16, false ); ok = m4x4 == m4x4C; log( "set( iterator_t, bool ) ", ok ); } // test direct sum { matrix< 2, 1, double > upper_left; double ul_data[] = { 1, 2 }; upper_left = ul_data; matrix< 2, 3, double > lower_right; double lr_data[] = { 3, 4, 5, 6, 7, 8 }; lower_right = lr_data; matrix< 4, 4, double > result; matrix< 4, 4, double > correct_result; double corr_res_data[] = { 1, 0, 0, 0, 2, 0, 0, 0, 0, 3, 4, 5, 0, 6, 7, 8 }; correct_result = corr_res_data; result.direct_sum( upper_left, lower_right ); bool ok = result == correct_result; log( "direct_sum", ok ); } // test determinants { matrix< 2, 2, double > m22; matrix< 3, 3, double > m33; matrix< 4, 4, double > m44; double data[] = { 1,2,0,0, 2,1,2,0, 0,2,1,2, 0,0,2,1 }; m44.set( data, data+16 ); m44.get_sub_matrix( m33 ); m33.get_sub_matrix( m22 ); double det44 = m44.det(); double det33 = m33.det(); double det22 = m22.det(); bool ok = det44 == 5.0 && det33 == -7.0 && det22 == -3.0; log( "determinant for 2x2, 3x3 and 4x4 matrices", ok ); } // test convolution { matrix< 4, 4, int > data; int test_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2 }; matrix< 3, 3, int > kernel; int test_kernel[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; data = test_data; kernel = test_kernel; data.convolve(kernel); matrix< 4, 4, int > correct_result; int corr_res_data[] = { 159, 192, 237, 264, 297, 296, 293, 290, 273, 250, 217, 196, 231, 198, 153, 126 }; correct_result = corr_res_data; bool ok = data == correct_result; log( "convolution", ok ); } { // bool ok = true; matrix< 4, 4, double > m; identity( m ); vector< 3, double > v; //double scale[] = { 1.0, 0.0, 0.0 }; m.pre_rotate_x( 2.3 ); //m.scale( scale ); #if 0 if ( is_positive_definite( m ) ) { } #endif std::string data; //m.getString( data ); //std::cout << data << std::endl; } #ifndef VMMLIB_NO_CONVERSION_OPERATORS { matrix< 4, 4, double > m; double* array = m; //const double* const_array = m; array[ 3 ] = 1.0; //const_array[ 3 ] = 1.0; } #endif { //test computation of norm matrix< 4, 4, int > data_2; int test_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2 }; data_2 = test_data; float_t norm_check = 22.0907220343745223090082; float_t norm = data_2.frobenius_norm(); ok = norm == norm_check; if ( ok ) { log( "matrix frobenius norm", ok ); } else { std::stringstream error; error << "matrix frobenius norm: should be: " << norm_check << " is: " << norm << std::endl; log_error( error.str() ); } } { //test khatri-rao matrix product matrix< 3, 4, int > left; matrix< 4, 4, int > right; matrix< 12, 4, int > khatri_rao; matrix< 12, 4, int > khatri_rao_check; int data_left[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; int data_right[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; left = data_left; right = data_right; int data_khatri_rao[] = { 1,4,9,16, 5,12,21,32, 9,20,33,48, 13,28,45,64, 5,12,21,32, 25,36,49,64, 45,60,77,96, 65,84,105,128, 9,20,33,48, 45,60,77,96, 81,100,121,144, 117,140,165,192 }; khatri_rao_check = data_khatri_rao; left.khatri_rao_product( right, khatri_rao ); ok = khatri_rao == khatri_rao_check; if ( ok ) { log( "khatri-rao matrix product ", ok ); } else { std::stringstream error; error << "khatri-rao matrix product: should be: " << std::endl << std::setprecision(24) << khatri_rao_check << std::endl << " is: " << std::endl << khatri_rao << std::endl; log_error( error.str() ); } } { //test kronecker product matrix< 3, 4, int > left; matrix< 4, 4, int > right; matrix< 12, 16, int > kronecker; matrix< 12, 16, int > kronecker_check; int data_left[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; int data_right[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; left = data_left; right = data_right; int data_kronecker[] = { 1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16, 5, 6, 7, 8, 10, 12, 14, 16, 15, 18, 21, 24, 20, 24, 28, 32, 9, 10, 11, 12, 18, 20, 22, 24, 27, 30, 33, 36, 36, 40, 44, 48, 13, 14, 15, 16, 26, 28, 30, 32, 39, 42, 45, 48, 52, 56, 60, 64, 5, 10, 15, 20, 6, 12, 18, 24, 7, 14, 21, 28, 8, 16, 24, 32, 25, 30, 35, 40, 30, 36, 42, 48, 35, 42, 49, 56, 40, 48, 56, 64, 45, 50, 55, 60, 54, 60, 66, 72, 63, 70, 77, 84, 72, 80, 88, 96, 65, 70, 75, 80, 78, 84, 90, 96, 91, 98, 105, 112, 104, 112, 120, 128, 9, 18, 27, 36, 10, 20, 30, 40, 11, 22, 33, 44, 12, 24, 36, 48, 45, 54, 63, 72, 50, 60, 70, 80, 55, 66, 77, 88, 60, 72, 84, 96, 81, 90, 99, 108, 90, 100, 110, 120, 99, 110, 121, 132, 108, 120, 132, 144, 117, 126, 135, 144, 130, 140, 150, 160, 143, 154, 165, 176, 156, 168, 180, 192 }; kronecker_check = data_kronecker; left.kronecker_product( right, kronecker ); ok = kronecker == kronecker_check; if ( ok ) { log( "kronecker matrix product ", ok ); } else { std::stringstream error; error << "kronecker matrix product: should be: " << std::endl << std::setprecision(24) << kronecker_check << std::endl << " is: " << std::endl << kronecker << std::endl; log_error( error.str() ); } } { //matrix type cast matrix< 2, 3, float > matrix_type_a; matrix< 2, 3, int > matrix_type_b; matrix< 2, 3, int > matrix_type_b_check; matrix_type_a.fill(2.4); matrix_type_b_check.fill(2); matrix_type_b.cast_from( matrix_type_a ); if ( matrix_type_b_check == matrix_type_b ) { log( "type cast ", true ); } else { std::stringstream error; error << "type cast - matrix type float: " << std::endl << matrix_type_a << std::endl << " matrix cast int should be: " << std::endl << matrix_type_b_check << std::endl << " is: " << matrix_type_b << std::endl; log_error( error.str() ); } } //get_min() + get_max() { matrix< 3, 2, int > m_get_min_max; m_get_min_max.zero(); m_get_min_max.at(0,1) = 4; m_get_min_max.at(2,1) = 8; int m_min = m_get_min_max.get_min(); int m_max = m_get_min_max.get_max(); if ( (m_min == 0) && (m_max == 8) ) { log( "get min/max" , true ); } else { std::stringstream error; error << "get min/max: " << std::endl << "min should be: " << std::endl << 0 << " is: " << m_min << std::endl << "max should be: " << std::endl << 29 << " is: " << m_max << std::endl; log_error( error.str() ); } } //quantize { matrix< 4, 3, float > m_raw; m_raw.fill(0.45692); m_raw.at( 2,2) = 0.67777; m_raw.at(1,0) = 0.111111; m_raw.at(2,0) = -0.23; m_raw.at(3, 0) = -0.99; m_raw.at(0,0) = -0.8; m_raw.at(2,1) = 0.0; m_raw.at(3,2) = 0.99; m_raw.at(1,0) = 0.23; matrix< 4, 3, unsigned char > m_quant; m_quant.zero(); matrix< 4, 3, unsigned char > m_quant_check; int data_unsigned[] = {24, 186, 186, 157, 186, 186, 98, 128, 215, 0, 186, 255}; m_quant_check.set(data_unsigned, data_unsigned+12); float min_value = 50; float max_value = -50; m_raw.quantize( m_quant, min_value, max_value ); matrix< 4, 3, char > m_quant_sign; m_quant_sign.zero(); matrix< 4, 3, char > m_quant_sign_check; int data_signed[] = {-102, 59, 59, 30, 59, 59, -29, 0, 87, -127, 59, 127}; m_quant_sign_check.set(data_signed, data_signed +12 ); m_raw.quantize( m_quant_sign, min_value, max_value ); //dequantize matrix< 4, 3, float > m_dequant; matrix< 4, 3, float > m_dequant_sign; m_quant.dequantize( m_dequant, min_value, max_value ); m_quant_sign.dequantize( m_dequant_sign, min_value, max_value ); if ( ( m_quant_check == m_quant ) && ( m_quant_sign_check == m_quant_sign ) && m_raw.equals(m_dequant_sign, 0.01) && m_raw.equals(m_dequant, 0.1) ) { log( "quantize/dequantize" , true ); } else { std::stringstream error; error << "quantize/dequantize " << std::endl << "raw is: " << std::endl << m_raw << std::endl << "unsigned quantized is: " << std::endl << m_quant << std::endl << "signed quantized is: " << std::endl << m_quant_sign << std::endl << "dequantized unsigned is: " << std::endl << m_dequant << std::endl << "dequantized signed is: " << std::endl << m_dequant_sign << std::endl << "min_value : " << min_value << " max_value: " << max_value << std::endl; log_error( error.str() ); } } { //number of nonzeros matrix< 4, 5, int > m_nnz; m_nnz.fill(2); m_nnz.at( 3,3 ) = 0; m_nnz.at( 2,3 ) = -4; size_t number_nonzeros = m_nnz.nnz(); matrix< 4, 4, float > m_nnz2; m_nnz2.fill( 0.9878); m_nnz2.at( 3,3 ) = 0; m_nnz2.at( 2,3 ) = -1; m_nnz2.at( 2,2 ) = 0.045; m_nnz2.at( 1,2 ) = -0.085; m_nnz2.at( 0,2 ) = 0.00000035; m_nnz2.at( 0,1 ) = -0.00000035; size_t number_nonzeros2 = m_nnz2.nnz( 0.00001 ); ok = ( number_nonzeros == 19 ) && (number_nonzeros2 == 13); log( "get number of nonzeros" , ok ); } { //threshold matrix< 4, 4, float > m_thresh; m_thresh.fill( 0.9878); m_thresh.at( 3,3 ) = 0; m_thresh.at( 2,3 ) = -1; m_thresh.at( 2,2 ) = 0.045; m_thresh.at( 1,2 ) = -0.085; m_thresh.at( 0,2 ) = 0.00000035; m_thresh.at( 0,1 ) = -0.00000035; size_t number_nonzeros_check = m_thresh.nnz( 0.00001 ); m_thresh.threshold( 0.00001 ); size_t number_nonzeros = m_thresh.nnz(); ok = number_nonzeros == number_nonzeros_check ; log( "thresholding" , ok ); } { //multiply piecewise matrix< 4, 3, float > mmp; matrix< 4, 3, float > mmp_other; matrix< 4, 3, float > mmp_check; mmp.fill( 3 ); mmp_other.fill( 2 ); mmp_check.fill( 6 ); mmp.multiply_piecewise( mmp_other ); ok = mmp == mmp_check; log( "multiply piecewise" , ok ); } { //columnwise sum matrix< 4, 3, float > m_cs; vector< 3, float > summed_cols; vector< 3, float > summed_cols_check; m_cs.fill( 3 ); summed_cols_check.set( 12 ); m_cs.columnwise_sum( summed_cols ); ok = summed_cols == summed_cols_check; log( "summed columns" , ok ); } { //columnwise sum matrix< 4, 3, float > m; m.fill( 3 ); double sum = m.sum_elements(); double sum_check = 36; ok = sum == sum_check; log( "sum elements" , ok ); } { //symmetric covariance matrix matrix< 2, 4, float > m_sc; float sc_data[] = { 11, 12, 13, 14, 21, 22, 23, 24 }; m_sc = sc_data; matrix< 2, 2, float > m_cov; m_sc.symmetric_covariance( m_cov ); matrix< 2, 2, float > m_cov_check; float cov_data[] = { 630, 1130, 1130, 2030}; m_cov_check = cov_data; ok = m_cov == m_cov_check; log( "symmetric covariance matrix" , ok ); } { //set dct (discrete cosine transform) values matrix< 4, 6, float > m_dct; m_dct.set_dct(); matrix< 4, 6, float > m_dct_check; float dct_data[] = { 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.653281509876, 0.270598053932, -0.270598053932, -0.653281509876, -0.653281509876, -0.270598053932, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.270598053932, -0.653281509876, 0.653281509876, -0.270598053932, -0.270598053932, 0.653281509876}; m_dct_check = dct_data; ok = m_dct == m_dct_check; log( "set dct coefficients (discrete cosine transform)" , ok ); } { // sum rows / sum columns matrix< 5, 7, unsigned int > m1; unsigned int m_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34 }; m1.set( m_data, m_data + 35 ); matrix< 2, 7, unsigned int> m2; matrix< 2, 7, unsigned int> m2_check; unsigned int m2_data[] = { 7, 9, 11, 13, 15, 17, 19, 35, 37, 39, 41, 43, 45, 47 }; m2_check.set( m2_data, m2_data + 14 ); m1.sum_rows( m2 ); matrix< 5, 3, unsigned int> m3; matrix< 5, 3, unsigned int> m3_check; unsigned int m3_data[] = { 1, 5, 9, 15, 19, 23, 29, 33, 37, 43, 47, 51, 57, 61, 65 }; m3_check.set( m3_data, m3_data + 15 ); m1.sum_columns( m3 ); ok = ( m2 == m2_check ) && (m3 == m3_check) ; log( "sum rows/columns" , ok ); } return ok; } } // namespace vmml vmmlib-1.0/tests/tucker3_exporter_importer_test.hpp0000644000175000017500000000066611674116154022355 0ustar shevekshevek#ifndef __VMML__TUCK3_EXPORTER_IMPORTER_TEST__HPP__ #define __VMML__TUCK3_EXPORTER_IMPORTER_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class tucker3_exporter_importer_test : public unit_test { public: tucker3_exporter_importer_test() : unit_test( "tucker3 tensor exporter/importer test" ) {} bool run(); protected: }; // class tucker3_exporter_importer_test } // namespace vmml #endif vmmlib-1.0/tests/matrix_pseudoinverse_test.cpp0000644000175000017500000000544711674116154021400 0ustar shevekshevek#include "matrix_pseudoinverse_test.hpp" #include #include #include namespace vmml { bool matrix_pseudoinverse_test::run() { bool ok = false; //test 1 (orthogonal) typedef matrix< 6, 4, float > pinv_type1; typedef matrix< 4, 6, float > pinv_t_type1; compute_pseudoinverse< pinv_type1 > compute_pinv; pinv_type1 input; float data[] = { 0.8147, 0.9058, 0.1270, 0.9134, 0.6324, 0.0975, 0.2785, 0.5469, 0.9575, 0.9649, 0.1576, 0.9706, 0.9572, 0.4854, 0.8003, 0.1419, 0.4218, 0.9157, 0.7922, 0.9595, 0.6557, 0.0357, 0.8491, 0.9340}; input.set( data, data + 24); pinv_t_type1 pseudoinverse_control; float data3[] = { 0.187956, 0.504057, 0.329735, 0.608532, -0.910448, 0.0212369, 0.19669, -0.571985, 0.159718, 0.272729, 0.675097, -0.758368, -0.428897, -0.248724, -0.486611, 0.514871, 0.679076, 0.294918, 0.170329, 0.27456, 0.126968, -0.932658, 0.139089, 0.610191 }; pseudoinverse_control.set( data3, data3 + 24); pinv_type1 pseudoinverse_transposed; compute_pinv( input, pseudoinverse_transposed ); pinv_t_type1 pseudoinverse = transpose( pseudoinverse_transposed ); ok = pseudoinverse_control.equals( pseudoinverse, 1e-4 ); //test 2 (non-symmetric transpose) typedef matrix< 4, 4, float > pinv_type2; compute_pseudoinverse< pinv_type2 > compute_pinv2; pinv_type2 input2; float data2[] = { 1, -0.446814, -0.218247, -0.077803, -0.446814, 1, -0.307783, -0.181625, -0.218247, -0.307783, 1, 0.0354524, -0.077803, -0.181625, 0.0354524, 1}; input2.set( data2, data2 + 16); pinv_type2 pseudoinverse_control2; float data4[] = { 1.5831, 0.9504, 0.6283, 0.2735, 0.9504, 1.7120, 0.7216, 0.3593, 0.6283, 0.7216, 1.3545, 0.1319, 0.2735, 0.3593, 0.1319, 1.0819 }; pseudoinverse_control2.set( data4, data4 + 16); pinv_type2 pseudoinverse_transposed2; compute_pinv2( input2, pseudoinverse_transposed2 ); pinv_type2 pseudoinverse2 = transpose( pseudoinverse_transposed2 ); ok = ok && (pseudoinverse_control2.equals( pseudoinverse2, 1e-4 )); //FIXME: check if multiply = Identity matrix if (ok) { log( "matrix compute pseudo inverse ", ok ); } else { std::stringstream error; error << "matrix compute pseudo inverse: " << std::endl << "input 1 is: " << std::endl << input << std::endl << "inverse matrix 1 should be: " << std::endl << pseudoinverse_control << std::endl << "inverse matrix 1 is: " << std::endl << pseudoinverse << std::endl << "input 2 is: " << std::endl << input2 << std::endl << "inverse matrix 2 should be: " << std::endl << pseudoinverse_control2 << std::endl << "inverse matrix 2 is: " << std::endl << pseudoinverse2 << std::endl; log_error( error.str() ); } ok = true; return ok; } } // namespace vmml vmmlib-1.0/tests/lapack_gaussian_elimination_test.hpp0000644000175000017500000000065311674116154022635 0ustar shevekshevek#ifndef __VMML__LAPACK_GAUSSIAN_ELIMINATION_TEST__HPP__ #define __VMML__LAPACK_GAUSSIAN_ELIMINATION_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class lapack_gaussian_elimination_test : public unit_test { public: lapack_gaussian_elimination_test() : unit_test( "gaussian elimination using lapack" ) {} virtual bool run(); protected: }; // class lapack_linear_least_squares_test } // namespace vmml #endif vmmlib-1.0/tests/f2c_fix.h0000644000175000017500000000020611674116154015033 0ustar shevekshevek#define integer f2c_fix_integer #define uinteger f2c_fix_uinteger typedef int f2c_fix_integer; typedef unsigned int f2c_fix_uinteger; vmmlib-1.0/tests/vmmlib_lapack_main.cpp0000644000175000017500000000315311674116154017657 0ustar shevekshevek #include #include #include "svd_lapack_vs_old.hpp" using namespace vmml; int main( int argc, const char* argv[] ) { #if 1 svd_lapack_vs_old vs; vs.run(); std::cout << vs << std::endl; return 0; #else matrix< 3, 3, double > A; matrix< 3, 1, double > b; A.identity(); A.at( 0, 0 ) = 1; A.at( 0, 1 ) = 4; A.at( 1, 0 ) = 2; A.at( 1, 1 ) = 5; A.at( 2, 0 ) = 3; A.at( 2, 1 ) = 6; b.at( 0, 0 ) = 7; b.at( 1, 0 ) = 8; b.at( 2, 0 ) = 9; lapack_linear_least_squares< 1, 3, double > llsq; llsq.compute( A, b ); std::cout << b << std::endl; #endif #if 0 matrix< 6, 3, double > A; matrix< 6, 3, double > U; matrix< 3, 3, double > Vt; vector< 3, double > sigma; double AData[] = { .814723686393178936349102, .278498218867048397129338, .957166948242945569980122, .905791937075619224550849, .546881519204983845838797, .485375648722841224191882, .126986816293506055153273, .957506835434297598474984, .800280468888800111670889, .913375856139019393076239, .964888535199276531351131, .141886338627215335961296, .632359246225409510344662, .157613081677548283465740, .421761282626274991436333, .975404049994095245779135e-1, .970592781760615697095318, .915735525189067089968376 }; A = AData; lapack_svd< 6, 3, double > lapack_svd; lapack_svd.compute( A, U, sigma, Vt ); std::cout << A << std::endl; std::cout << U << std::endl; std::cout << sigma << std::endl; std::cout << Vt << std::endl; #endif } vmmlib-1.0/tests/jacobi_test.cpp0000644000175000017500000000020311674116154016331 0ustar shevekshevek#include "jacobi_test.hpp" namespace vmml { bool jacobi_test::run() { bool ok; return ok; } } // namespace vmml vmmlib-1.0/tests/tensor3_iterator_test.hpp0000644000175000017500000000057611674116154020432 0ustar shevekshevek#ifndef __VMML__TENSOR3_ITERATOR_TEST__HPP__ #define __VMML__TENSOR3_ITERATOR_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class tensor3_iterator_test : public unit_test { public: tensor3_iterator_test() : unit_test( "tensor3 iterator test" ) {} bool run(); protected: }; // class tensor3_iterator_test } // namespace vmml #endif vmmlib-1.0/tests/t3_hosvd_test.cpp0000644000175000017500000001334511674116154016646 0ustar shevekshevek#include "t3_hosvd_test.hpp" #include "vmmlib/t3_hosvd.hpp" #include namespace vmml { bool t3_hosvd_test::run() { bool ok = false; double precision = 0.001; // hosvd test data after lathauwer et al. 2000a tensor3< 3, 3, 3, double > t3_data_hosvd; double data_hosvd[] = { 0.9073, 1.7842, 2.1236, 0.8924, 1.7753, -0.6631, 2.1488, 4.2495, 1.8260, 0.7158, 1.6970, -0.0704, -0.4898, -1.5077, 1.9103, 0.3054, 0.3207, 2.1335, -0.3698, 0.0151, 1.4429, 2.4288, 4.0337, -1.7495, 2.3753, 4.7146, -0.2716 }; t3_data_hosvd.set(data_hosvd, data_hosvd + 27); //prepare control data matrix< 3, 3, double > u1_hosvd; matrix< 3, 3, double > u2_hosvd; matrix< 3, 3, double > u3_hosvd; matrix< 3, 3, double > u1_hosvd_check; matrix< 3, 3, double > u2_hosvd_check; matrix< 3, 3, double > u3_hosvd_check; double data_u1_hosvd[] = { -0.1122204303093513, 0.7738508263292329, -0.6233469929427331, -0.5770542482332139, -0.5614452683822977, -0.5931168562830853, -0.8089591890924934, 0.293145201565186, 0.5095595364450776}; u1_hosvd_check.set( data_u1_hosvd, data_u1_hosvd + 9); double data_u2_hosvd[] = { -0.4624061014026708, 0.01022823125054092, 0.8866092604248326, -0.8866395226347692, -0.01338403108646822, -0.4622674816746957, 0.007138227200902682, -0.9998581154330659, 0.01525761170912346 }; u2_hosvd_check.set( data_u2_hosvd, data_u2_hosvd + 9); double data_u3_hosvd[] = { -0.6208224807897551, -0.498575577624314, -0.6049808598151153, 0.05741499780009954, -0.7985513947597073, 0.5991820991609654, -0.7818458705996144, 0.3372507425105363, 0.5243843736253236 }; u3_hosvd_check.set( data_u3_hosvd, data_u3_hosvd + 9); ///hosvd t3_hosvd< 3, 3, 3, 3, 3, 3, double >::hosvd( t3_data_hosvd, u1_hosvd, u2_hosvd, u3_hosvd ); if ( u1_hosvd.equals( u1_hosvd_check, precision ) && u2_hosvd.equals( u2_hosvd_check, precision ) && u3_hosvd.equals( u3_hosvd_check, precision )) { log( "HOSVD (3x3x3) compute factor matrices U1, U2, U3", true ); } else { std::stringstream error; error << "HOSVD (3x3x3): " << std::endl << "U1 should be: " << std::endl << u1_hosvd_check << std::endl << "U1 is: " << std::endl << u1_hosvd << std::endl << "U2 should be: " << std::endl << u2_hosvd_check << std::endl << "U2 is: " << std::endl << u2_hosvd << std::endl << "U3 should be: " << std::endl << u3_hosvd_check << std::endl << "U3 is: " << std::endl << u3_hosvd << std::endl; log_error( error.str() ); } //hosvd with test data from Lathauwer et al. 2000b (non-cubic) matrix< 3, 3, double > u1_2; matrix< 2, 2, double > u2_2; matrix< 2, 2, double > u3_2; matrix< 3, 3, double > u1_2_check; matrix< 2, 2, double > u2_2_check; matrix< 2, 2, double > u3_2_check; double data_u1_2[] = {-0.246452, 0.499323, 0.830625, 0.521727, -0.653918, 0.547898, 0.816738, 0.56839, -0.0993512}; u1_2_check.set( data_u1_2, data_u1_2 + 9); double data_u2_2[] = {0.171472, 0.985189, 0.985189, -0.171472}; u2_2_check.set( data_u2_2, data_u2_2 + 4); double data_u3_2[] = {-0.510464, 0.859899, 0.859899, 0.510464}; u3_2_check.set( data_u3_2, data_u3_2 + 4); double data_2[] = { 0, 1, 2, 3, 4, 5, -1, 4, -2, -5, 3, -6}; tensor3< 3, 2, 2, double > t3_data_2; t3_data_2.set(data_2, data_2 + 12); ///hosvd t3_hosvd< 3, 2, 2, 3, 2, 2, double >::hosvd( t3_data_2, u1_2, u2_2, u3_2 ); ok = u1_2.equals( u1_2_check, precision ); ok = ok && (u2_2.equals( u2_2_check, precision )); ok = ok && (u3_2.equals( u3_2_check, precision )); if ( ok ) { log( "HOSVD (3x2x2) compute factor matrices U1, U2, U3", ok ); } else { std::stringstream error; error << "HOSVD (3x2x2): " << std::endl << "U1 should be: " << std::endl << u1_2_check << std::endl << "U1 is: " << std::endl << u1_2 << std::endl << "U2 should be: " << std::endl << u2_2_check << std::endl << "U2 is: " << std::endl << u2_2 << std::endl << "U3 should be: " << std::endl << u3_2_check << std::endl << "U3 is: " << std::endl << u3_2 << std::endl; log_error( error.str() ); } //hoeigs test u1_hosvd.zero(); u2_hosvd.zero(); u3_hosvd.zero(); matrix<3, 3, double> u1_hoeigs_check; matrix<3, 3, double> u2_hoeigs_check; matrix<3, 3, double> u3_hoeigs_check; double data_u1_hoeigs[] = { 0.1122204363, 0.7738507986, -0.623347044, 0.5770543218, -0.5614452958, -0.5931168199, 0.8089591861, 0.2931452692, 0.5095595717}; u1_hoeigs_check.set( data_u1_hoeigs, data_u1_hoeigs + 9); double data_u2_hoeigs[] = { -0.4624060392, -0.01022823341, 0.8866092563, -0.886639595, 0.01338403113, -0.4622673988, 0.007138226647, 0.9998582006, 0.01525761187 }; u2_hoeigs_check.set( data_u2_hoeigs, data_u2_hoeigs + 9); double data_u3_hoeigs[] = { 0.6208223701, 0.4985756576, 0.6049809456, -0.05741500854, 0.7985514402, -0.5991820693, 0.7818458676, -0.3372507095, -0.524384439 }; u3_hoeigs_check.set( data_u3_hoeigs, data_u3_hoeigs + 9); t3_hosvd< 3, 3, 3, 3, 3, 3, double >::hoeigs( t3_data_hosvd, u1_hosvd, u2_hosvd, u3_hosvd ); if ( u1_hosvd.equals( u1_hoeigs_check, precision ) && u2_hosvd.equals( u2_hoeigs_check, precision ) && u3_hosvd.equals( u3_hoeigs_check, precision )) { log( "HOEIGS compute factor matrices U1, U2, U3", true ); } else { std::stringstream error; error << "HOEIGS: " << std::endl << "U1 should be: " << std::endl << u1_hoeigs_check << std::endl << "U1 is: " << std::endl << u1_hosvd << std::endl << "U2 should be: " << std::endl << u2_hoeigs_check << std::endl << "U2 is: " << std::endl << u2_hosvd << std::endl << "U3 should be: " << std::endl << u3_hoeigs_check << std::endl << "U3 is: " << std::endl << u3_hosvd << std::endl; log_error( error.str() ); } return ok; } } //end vmml namespace vmmlib-1.0/tests/blas_dgemm_test.cpp0000644000175000017500000001201511674116154017200 0ustar shevekshevek#include "blas_dgemm_test.hpp" #include namespace vmml { bool blas_dgemm_test::run() { bool ok = false; matrix< 3, 6, double > A; matrix< 3, 3, double > C; matrix< 3, 3, double > C_check; double AData[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 }; A = AData; blas_dgemm< 3, 6, 3, double > blas_cov; blas_cov.compute( A, C ); double CData[] = { 91, 217, 343, 217, 559, 901, 343, 901, 1459 }; C_check = CData; ok = C == C_check; log( "symmetric matrix-matrix multiplication (input left matrix) (MxK) x (KxN) = (MxN), while M=N", ok ); if ( ! ok ) { std::stringstream ss; ss << "input matrix (left matrix)\n" << A << "\n" << "covariance matrix should be\n" << C_check << "\n" << "covariance matrix is\n" << C << "\n" << std::endl; log_error( ss.str() ); } //A*B = D (MxK, KxN, MxN) (input right matrix) matrix< 6, 3, double > E; matrix< 3, 3, double > F; matrix< 3, 3, double > F_check; double EData[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 }; E = EData; blas_dgemm< 3, 6, 3, double > blas_cov3; blas_cov3.compute_t( E, F ); double FData[] = { 591, 642, 693, 642, 699, 756, 693, 756, 819 }; F_check = FData; ok = F == F_check; log( "symmetric matrix-matrix multiplication (input right matrix) (MxK) x (KxN) = (MxN), while M=N", ok ); if ( ! ok ) { std::stringstream ss; ss << "input matrix (right matrix) \n" << E << "\n" << "covariance matrix should be\n" << F_check << "\n" << "covariance matrix is\n" << F << "\n" << std::endl; log_error( ss.str() ); } //A*B = D (MxK, KxN, MxN) matrix< 6, 2, double > B; matrix< 3, 2, double > D; matrix< 3, 2, double > D_check; double BData[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; B = BData; blas_dgemm< 3, 6, 2, double > blas_v_dgemm; blas_v_dgemm.compute( A, B, D ); double DData[] = { 161, 182, 377, 434, 593, 686 }; D_check = DData; ok = D == D_check; log( "matrix-matrix multiplication (MxK) x (KxN) = (MxN)", ok ); if ( ! ok ) { std::stringstream ss; ss << "input matrix A\n" << A << "\n" << "input matrix B\n" << B << "\n" << "matrix C should be\n" << D_check << "\n" << "matrix C is\n" << D << "\n" << std::endl; log_error( ss.str() ); } //A*B = D (MxK, KxN, MxN) (input B is given as transpose) matrix< 2, 6, double > B_t; matrix< 3, 2, double > G; matrix< 3, 2, double > G_check; double BtData[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; B_t = BtData; blas_dgemm< 3, 6, 2, double > blas_dgemm5; blas_dgemm5.compute_bt( A, B_t, G ); double GData[] = { 91, 217, 217, 559, 343, 901 }; G_check = GData; ok = G == G_check; log( "matrix-matrix multiplication (input B is transpose) (MxK) x (NxK) = (MxN)", ok ); if ( ! ok ) { std::stringstream ss; ss << "input matrix A\n" << A << "\n" << "input matrix B_t\n" << B_t << "\n" << "matrix C should be\n" << G_check << "\n" << "matrix C is\n" << G << "\n" << std::endl; log_error( ss.str() ); } //A*B = H (MxK, KxN, MxN) (input A+B are given as transpose) matrix< 2, 5, double > At; matrix< 6, 2, double > Bt; matrix< 5, 6, double > H; matrix< 5, 6, double > H_check; Bt = BtData; At = BtData; blas_dgemm< 5, 2, 6, double > blas_dgemm6; blas_dgemm6.compute_t( At, Bt, H ); double HData[] = { 13, 27, 41, 55, 69, 83, 16, 34, 52, 70, 88, 106, 19, 41, 63, 85, 107, 129, 22, 48, 74, 100, 126, 152, 25, 55, 85, 115, 145, 175 }; H_check = HData; ok = H == H_check; log( "matrix-matrix multiplication (input A+B are transpose) (MxK) x (NxK) = (MxN)", ok ); if ( ! ok ) { std::stringstream ss; ss << "input matrix A\n" << A << "\n" << "input matrix B_t\n" << B << "\n" << "matrix H should be\n" << H_check << "\n" << "matrix H is\n" << H << "\n" << std::endl; log_error( ss.str() ); } //vector vector outer product vector< 5, double > vA; vector< 6, double > vB; vA = BtData; vB = BtData; blas_dgemm< 5, 1, 6, double > blas_dgemm7; blas_dgemm7.compute_vv_outer( vA, vB, H ); double H2Data[] = { 1, 2, 3, 4, 5, 6, 2, 4, 6, 8, 10, 12, 3, 6, 9, 12, 15, 18, 4, 8, 12, 16, 20, 24, 5, 10, 15, 20, 25, 30}; H_check = H2Data; ok = (H == H_check) ; log( "vector vector outer product with dgemm (M)' x (N) = (MxN)", ok ); if ( ! ok ) { std::stringstream ss; ss << "input vector A\n" << vA << "\n" << "input vector B_t\n" << vB << "\n" << "matrix H should be\n" << H_check << "\n" << "matrix H is\n" << H << "\n" << std::endl; log_error( ss.str() ); } return ok; } } // namespace vmml vmmlib-1.0/tests/svd_lapack_vs_old.hpp0000644000175000017500000000043011674116154017527 0ustar shevekshevek#ifndef __VMML__SVD_LAPACK_VS_OLD__HPP__ #define __VMML__SVD_LAPACK_VS_OLD__HPP__ #include "performance_test.hpp" namespace vmml { class svd_lapack_vs_old : public performance_test { public: virtual void run(); }; // class svd_lapack_vs_old } // namespace vmml #endif vmmlib-1.0/tests/cp3_tensor_test.hpp0000644000175000017500000000056411674116154017200 0ustar shevekshevek#ifndef __VMML__CP3_TENSOR_TEST__HPP__ #define __VMML__CP3_TENSOR_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class cp3_tensor_test : public unit_test { public: cp3_tensor_test() : unit_test( "cp3_tensor (R) x (I1xR) x (I2xR) x (I3xR)" ) {} bool run(); protected: }; // class cp3_tensor_test } // namespace vmml #endif vmmlib-1.0/tests/blas_dot_test.hpp0000644000175000017500000000052111674116154016701 0ustar shevekshevek#ifndef __VMML__BLAS_DOT_TEST__HPP__ #define __VMML__BLAS_DOT_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class blas_dot_test : public unit_test { public: blas_dot_test() : unit_test( "dot product (dot) using blas" ) {} virtual bool run(); protected: }; // class blas_dot_test } // namespace vmml #endif vmmlib-1.0/tests/t3_ihopm_test.cpp0000644000175000017500000001021111674116154016624 0ustar shevekshevek#include "t3_ihopm_test.hpp" #include "vmmlib/t3_ihopm.hpp" #include namespace vmml { bool t3_ihopm_test::run() { bool ok = false; double precision = 0.001; typedef tensor3< 4, 4, 4, double > cp_t3_type; cp_t3_type t3_cp_input; double data_in_cp[] = { 0.3780, 0.3150, 0.3386, 0.2047, 0.2913, 0.3071, 0.2835, 0.1024, 0.2362, 0.2835, 0.2677, 0.1024, 0.3543, 1.1181, 1.5354, 0.3858, 0.2520, 0.2283, 0.3228, 0.2835, 0.2677, 0.2598, 0.2992, 0.2126, 0.2441, 0.2205, 0.2441, 0.2913, 0.9213, 0.6457, 0.4331, 0.1890, 0.4409, 0.4409, 0.5591, 0.5039, 0.2362, 0.4409, 0.5984, 0.6142, 0.2520, 0.2835, 0.3465, 0.3543, 0.5748, 0.2835, 0.2992, 0.2835, 0.3386, 0.3150, 0.4488, 0.4173, 0.2756, 0.3150, 0.3465, 0.3386, 0.2835, 0.2677, 0.2362, 0.2913, 0.2598, 0.2520, 0.2756, 0.3071 }; t3_cp_input.set(data_in_cp, data_in_cp + 64); #define W 2 #define L 3 typedef matrix< 4, W*L, double > cp3_u_type; typedef vector< W*L, double> cp3_lambda_type; cp3_lambda_type lambda; cp3_u_type u1; cp3_u_type u2; cp3_u_type u3; t3_ihopm< W, L, 4, 4, 4, double, double >::incremental_als( t3_cp_input, u1, u2, u3, lambda ); //std::cout << "u1:\n" << u1 << std::endl << "u2:\n" << u2 << std::endl << "u3:\n" << u3 << std::endl << "lambda\n" << lambda << std::endl; //check test data cp3_lambda_type lambda_check; cp3_u_type u1_check; cp3_u_type u2_check; cp3_u_type u3_check; lambda_check.at(0) = 2.9053; lambda_check.at(1) = 1.4844; lambda_check.at(2) = 0.70494; lambda_check.at(3) = 0.53852; lambda_check.at(4) = 0.34382; lambda_check.at(5) = 0.34367; double data_u1_check[] = { 0.506085561468077, 0.001956847654422, -0.209569603142863, -0.394921956232513, -0.022486848229877, 0.184594118898338, 0.460495692379029, -0.028557624219977, -0.180356605196994, -0.734631384709598, -0.486345040443633, -0.556857121401639, 0.359317314562872, 0.054450501667292, -0.110310141873280, -0.269443896857940, -0.745176978684274, -0.455743051491161, 0.634596083528118, 0.998106094417997, 0.954664207457395, 0.481407689522252, -0.455712753531810, -0.669427687379266, }; u1_check.set( data_u1_check, data_u1_check + 24 ); double data_u2_check[] = { -0.496342174057493, -0.038914583436338, 0.866036783907366, -0.562676911251632, 0.417141865256690, 0.349220775883442, -0.499456882130393, -0.573265837144616, 0.302670396624642, -0.123572086450233, -0.189594213931581, -0.304319214625875, -0.569895344707819, -0.811943783843057, -0.177969059686749, 0.182161561359157, -0.405487465007436, -0.208074746650915, -0.423564121739347, -0.102952547503582, -0.355946532109365, 0.796832352855890, 0.790965621260291, 0.861475226055291, }; u2_check.set( data_u2_check, data_u2_check + 24 ); double data_u3_check[] = { -0.388210367985676, -0.916926601731041, 0.004409907552016, 0.259294452470892, -0.156403724994960, 0.498783074179373, -0.466062051276868, -0.053679545922064, 0.922185157079488, 0.262424594049043, -0.686783735606445, 0.485694863120284, -0.641760774047993, 0.342843706058446, -0.200373280225951, -0.840021412092139, 0.013805150959998, 0.142358862753370, -0.469278151463868, 0.197033770211290, -0.330765229957981, -0.397823763220280, -0.709700918078263, 0.703597824787933, }; u3_check.set( data_u3_check, data_u3_check + 24 ); ok = u1.equals( u1_check, precision ); ok = u2.equals( u2_check, precision ) && ok; ok = u3.equals( u3_check, precision ) && ok; ok = lambda.equals( lambda_check, precision ) && ok; if( ok) { log( "incremental rank-R approximation", ok ); } else { std::stringstream error; error << "incremental rank-R approximation" << std::setprecision(16) << std::endl << "lambda should be: " << lambda_check << std::endl << "lambda is: " << lambda << std::endl << "u1 should be: " << std::endl << u1_check << std::endl << "u1 is: " << std::endl << u1 << std::endl << "u2 should be: " << std::endl << u2_check << std::endl << "u2 is: " << std::endl << u2 << std::endl << "u3 should be: " << std::endl << u3_check << std::endl << "u3 is: " << std::endl << u3 << std::endl; log_error( error.str() ); } return ok; } } //end vmml namespace vmmlib-1.0/tests/blas_dgemm_test.hpp0000644000175000017500000000055611674116154017214 0ustar shevekshevek#ifndef __VMML__BLAS_DGEMM_TEST__HPP__ #define __VMML__BLAS_DGEMM_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class blas_dgemm_test : public unit_test { public: blas_dgemm_test() : unit_test( "matrix matrix multiplication (dgemm) using blas" ) {} virtual bool run(); protected: }; // class blas_dgemm_test } // namespace vmml #endif vmmlib-1.0/tests/t3_hopm_test.cpp0000644000175000017500000003132311674116154016462 0ustar shevekshevek#include "t3_hopm_test.hpp" #include "vmmlib/t3_hopm.hpp" #include namespace vmml { bool t3_hopm_test::run() { bool ok = false; double precision = 0.001; //CP decomposition typedef tensor3< 4, 4, 4, double > cp_t3_type; cp_t3_type t3_cp_input; double data_in_cp[] = { 0.3780, 0.3150, 0.3386, 0.2047, 0.2913, 0.3071, 0.2835, 0.1024, 0.2362, 0.2835, 0.2677, 0.1024, 0.3543, 1.1181, 1.5354, 0.3858, 0.2520, 0.2283, 0.3228, 0.2835, 0.2677, 0.2598, 0.2992, 0.2126, 0.2441, 0.2205, 0.2441, 0.2913, 0.9213, 0.6457, 0.4331, 0.1890, 0.4409, 0.4409, 0.5591, 0.5039, 0.2362, 0.4409, 0.5984, 0.6142, 0.2520, 0.2835, 0.3465, 0.3543, 0.5748, 0.2835, 0.2992, 0.2835, 0.3386, 0.3150, 0.4488, 0.4173, 0.2756, 0.3150, 0.3465, 0.3386, 0.2835, 0.2677, 0.2362, 0.2913, 0.2598, 0.2520, 0.2756, 0.3071 }; t3_cp_input.set(data_in_cp, data_in_cp + 64); //rank-R approximation with R = I typedef matrix< 4, 4, double > cp1_u_type; typedef vector< 4, double> cp1_lambda_type; cp1_lambda_type lambda_check; lambda_check.at(0) = 2.775859831650517; lambda_check.at(1) = 1.44181882070093; lambda_check.at(2) = 0.7936885048760115; lambda_check.at(3) = 0.6968919719973138; double data_u1_cp[] = { 0.4947326288974953, 0.04128996882377001, -0.006917444021349467, -0.3736437995072651, 0.4099981368345459, 0.09772460822979954, 0.07510639313135861, -0.6780604302654061, 0.3455791832510188, 0.09762439931096729, 0.03802566879804911, -0.2734889964561094, 0.683897786076204, 0.9895526848430239, 0.9964262276714069, 0.5708135709804885 }; cp1_u_type u1_check; u1_check.set( data_u1_cp, data_u1_cp + 16); double data_u2_cp[] = { -0.5630888350728218, 0.14726271434163, -0.9072625301681907, -0.3228950591542049, -0.4880741488189518, -0.5238284305386723, -0.1195534484016052, 0.2019274951012398, -0.5177163615839594, -0.837911590083059, 0.4012108888469344, 0.5477365401168893, -0.4203383851366125, 0.04268062240181204, 0.04014345524180109, 0.744948823823973 }; cp1_u_type u2_check; u2_check.set( data_u2_cp, data_u2_cp + 16); double data_u3_cp[] = { -0.4468035875723725, -0.8982341437458666, -0.1391760215620145, 0.2935688051497138, -0.3860250457737493, -0.2953535928400287, -0.7678559540334658, -0.2198467758156476, -0.6241497540721714, 0.2206872699438892, 0.3681560369573573, -0.8566127484887466, -0.5116525214043997, 0.2392463314041185, 0.5054586049612554, -0.362904051965515 }; cp1_u_type u3_check; u3_check.set( data_u3_cp, data_u3_cp + 16); cp1_lambda_type lambda; cp1_u_type u1; cp1_u_type u2; cp1_u_type u3; typedef t3_hopm< 4, 4, 4, 4, double > hopm_type; hopm_type::als( t3_cp_input, u1, u2, u3, lambda, hopm_type::init_hosvd(), 50 ); ok = u1.equals( u1_check, precision ); ok = u2.equals( u2_check, precision ) && ok; ok = u3.equals( u3_check, precision ) && ok; ok = lambda.equals( lambda_check, precision ) && ok; if( ok ) { log( "HOPM/CP-ALS: rank-R approximation (R = I)", ok ); } else { std::stringstream error; error << "HOPM/CP-ALS: rank-R approximation (R = I)" << std::setprecision(16) << std::endl << " lambda should be: " << lambda_check << "lambda is: " << lambda << std::endl << " u1 should be: " << std::endl << u1_check << std::endl << " u1 is: " << std::endl << u1 << std::endl << " u2 should be: " << std::endl << u2_check << std::endl << " u2 is: " << std::endl << u2 << std::endl << " u3 should be: " << std::endl << u3_check << std::endl << " u3 is: " << std::endl << u3 << std::endl; log_error( error.str() ); } //rank-R approximation (R > I) typedef matrix< 4, 2, double > cp2_u_type; typedef vector< 2, double> cp2_lambda_type; cp2_lambda_type lambda_check2; lambda_check2.at(0) = 2.905300140380859; lambda_check2.at(1) = 1.484431028366089; double data_u1_cp2[] = { 0.5060855746269226, 0.001956983935087919, 0.4604957103729248, -0.02855747938156128, 0.359317272901535, 0.05445058643817902, 0.634596049785614, 0.998106062412262 }; cp2_u_type u1_check2; u1_check2.set( data_u1_cp2, data_u1_cp2 + 8); double data_u2_cp2[] = { -0.4963421821594238, -0.03891453891992569, -0.4994568228721619, -0.5732658505439758, -0.569895327091217, -0.8119437694549561, -0.4235640466213226, -0.1029524803161621 }; cp2_u_type u2_check2; u2_check2.set( data_u2_cp2, data_u2_cp2 + 8); double data_u3_cp2[] = { -0.3882103264331818, -0.9169266819953918, -0.466062068939209, -0.05367951840162277, -0.6417607665061951, 0.3428435325622559, -0.4692781269550323, 0.1970336884260178 }; cp2_u_type u3_check2; u3_check2.set( data_u3_cp2, data_u3_cp2 + 8); cp2_lambda_type lambda_2; cp2_u_type u1_2; cp2_u_type u2_2; cp2_u_type u3_2; typedef t3_hopm< 2, 4, 4, 4, double > hopm2_type; hopm2_type::als( t3_cp_input, u1_2, u2_2, u3_2, lambda_2, hopm2_type::init_hosvd(), 50 ); precision = 0.0001; ok = u1_2.equals( u1_check2, precision ); ok = u2_2.equals( u2_check2, precision ) && ok; ok = u3_2.equals( u3_check2, precision ) && ok; ok = lambda_2.equals( lambda_check2, precision ) && ok; if( ok) { log( "HOPM/CP-ALS: rank-R approximation (R < I)", ok ); } else { std::stringstream error; error << "HOPM/CP-ALS: rank-R approximation (R < I)" << std::setprecision(16) << std::endl << " lambda should be:\n" << lambda_check2 << "lambda is:\n" << lambda_2 << std::endl << " u1 should be: " << std::endl << u1_check2 << std::endl << " u1 is: " << std::endl << u1_2 << std::endl << " u2 should be: " << std::endl << u2_check2 << std::endl << " u2 is: " << std::endl << u2_2 << std::endl << " u3 should be: " << std::endl << u3_check2 << std::endl << " u3 is: " << std::endl << u3_2 << std::endl; log_error( error.str() ); } //rank-R approximation with R > I typedef matrix< 4, 6, double > cp3_u_type; typedef vector< 6, double> cp3_lambda_type; cp3_lambda_type lambda_check3; lambda_check3.at(0) = 2.949088573455811; lambda_check3.at(1) = 1.269379019737244; lambda_check3.at(2) = 0.7361284494400024; lambda_check3.at(5) = 0.3052012622356415; lambda_check3.at(3) = 0.6072210669517517; lambda_check3.at(4) = 0.3266942501068115; double data_u1_cp3[] = { 0.4733901800329614, 0.1651671976476345, 0.03429142531960762, 0.5458835313216009, 0.003786561168133651, 0.1165964383253547, 0.4347951789645572, 0.166634467441311, -0.3642364139173337, 0.6078584294591635, -0.6301898404211475, 0.8419814543957256, 0.3151639631872558, 0.04782939064330856, 0.09616514805376049, 0.4610411401757213, -0.1384341324514788, -0.5232021638435955, 0.6982310263126678, -0.9709094192933075, -0.9256933602581305, -0.3463529515288832, 0.7639911111766255, 0.06109007098440862 }; cp3_u_type u1_check3; u1_check3.set( data_u1_cp3, data_u1_cp3 + 24); double data_u2_cp3[] = { -0.4672415036543002, 0.3213422331793286, -0.9265545290349607, 0.3166075143499547, 0.8067300709812761, -0.776617286082291, -0.5258024640955455, -0.4592700321284731, -0.3573195170303192, -0.05089615712113303, -0.1289753777336823, -0.3767214814465603, -0.6067694317031729, -0.8228066042210956, 0.1175559547231347, -0.02855775384536048, -0.4263246085807784, -0.02708859484252683, -0.3701999497089777, 0.09380564382905007, 0.00025491793523442, 0.946759588144082, -0.3883288202431613, -0.5041951253278271 }; cp3_u_type u2_check3; u2_check3.set( data_u2_cp3, data_u2_cp3 + 24); double data_u3_cp3[] = { -0.5580260829866757, 0.858622294938589, 0.1629322461162687, -0.399424471555235, 0.157199202283234, 0.3001292203805404, -0.3904421270404547, 0.04710793275822141, 0.8503159915200578, 0.3206114044275722, 0.3149977299563115, 0.857234067975567, -0.5808629004086727, -0.3794478834543623, -0.4222111559057403, 0.6514441744236624, 0.8237143771440413, -0.3939488133263827, -0.4458252203134067, -0.3414204168582224, -0.2686141053063062, 0.5597221690117998, -0.4444766200938916, 0.1409841702268896 }; cp3_u_type u3_check3; u3_check3.set( data_u3_cp3, data_u3_cp3 + 24); cp3_lambda_type lambda_3; cp3_u_type u1_3; cp3_u_type u2_3; cp3_u_type u3_3; //test norm ktensor double check_norm = 3.309332639286851; double nrm = hopm2_type::norm_ktensor( u1_2, u2_2, u3_2, lambda_2 ); precision = 0.00000001; ok = (check_norm - nrm < precision ); if( ok) { log( "norm ktensor", ok ); } else { std::stringstream error; error << "norm ktensor" << std::setprecision(16) << std::endl << "should be: " << check_norm << std::endl << "is: " << nrm << std::endl; log_error( error.str() ); } #if 0 //test hosvd with SVD t3_hopm< 6, 4, 4, 4, double >::als( t3_cp_input, u1_3, u2_3, u3_3, lambda_3, init_hosvd_e, 50 ); ok = u1_3.equals( u1_check3, precision ); ok = u2_3.equals( u2_check3, precision ) && ok; ok = u3_3.equals( u3_check3, precision ) && ok; ok = lambda_3.equals( lambda_check3, precision ) && ok; if( ok) { log( "HOPM/CP-ALS: rank-R approximation (R > I) - init with DCT", ok ); } else { std::stringstream error; error << "HOPM/CP-ALS: rank-R approximation (R > I) - init with DCT" << std::setprecision(16) << std::endl << " lambda should be:\n" << lambda_check3 << "\nlambda is:\n" << lambda_3 << std::endl << " u1 should be: " << std::endl << u1_check3 << std::endl << " u1 is: " << std::endl << u1_3 << std::endl << " u2 should be: " << std::endl << u2_check3 << std::endl << " u2 is: " << std::endl << u2_3 << std::endl << " u3 should be: " << std::endl << u3_check3 << std::endl << " u3 is: " << std::endl << u3_3 << std::endl; log_error( error.str() ); } #endif //FIXME: check test on linux #if 0 //rank-R approximation with R > I (init with DCT) #define D 5 typedef matrix< 4, D, double > cp4_u_type; typedef vector< D, double> cp4_lambda_type; cp4_lambda_type lambda_check4; lambda_check4.at(0) = 2.498177053837107; lambda_check4.at(1) = 1.562078744247265; lambda_check4.at(2) = 1.489490792770405; lambda_check4.at(3) = 1.344552972087995; lambda_check4.at(4) = 1.00387849517148; double data_u1_cp4[] = { 0.4934237561073131, 0.01845047663911101, 0.1782548118024551, -0.09798657543290282, 0.5487301760825246, 0.3947501379000385, 0.03515044879384801, 0.03535751132544677, -0.1432457637568596, 0.7087410243000387, 0.3590339322332908, -0.01781538889190339, 0.08821210931538905, -0.107110463271061, 0.3406927700691575, 0.6868769620841511, 0.9990528703627306, -0.9793843434690348, -0.9789824466549462, -0.2837424725929791 }; cp4_u_type u1_check4; u1_check4.set( data_u1_cp4, data_u1_cp4 + 24); double data_u2_cp4[] = { 0.6070441220297691, 0.8933125585845675, 0.8883053491235372, 0.1060204947494846, 0.0760074664421849, 0.4713983671605251, 0.4218304924097846, 0.3679361948033744, -0.5453786675836705, -0.3260460774679831, 0.476310434351972, 0.14017888770209, -0.07276909373517129, -0.8311900202676862, -0.6431636455439254, 0.4270941154768272, -0.06634446315267831, -0.2650306062874359, 0.0210929809448136, -0.688663448618721 }; cp4_u_type u2_check4; u2_check4.set( data_u2_cp4, data_u2_cp4 + 24); double data_u3_cp4[] = { 0.4879274471565801, 0.03925648729505715, 0.05178189302040599, 0.9909298694606465, 0.1945927925001754, 0.5390409774503466, -0.299246573525204, -0.6105174583715575, 0.1122841549455829, 0.00804843394886336, 0.3757757219193364, 0.7753824955374058, 0.7175999088679488, -0.07368107715613589, -0.9593409048890027, 0.5745904957068463, -0.5547002812806773, -0.3311154471954886, -0.004621820850501224, -0.204288756481369 }; cp4_u_type u3_check4; u3_check4.set( data_u3_cp4, data_u3_cp4 + 24); cp4_lambda_type lambda_4; cp4_u_type u1_4; cp4_u_type u2_4; cp4_u_type u3_4; typedef t3_hopm< D, 4, 4, 4, double > hopm4_type; hopm4_type::als( t3_cp_input, u1_4, u2_4, u3_4, lambda_4, hopm4_type::init_dct(), 100 ); ok = u1_4.equals( u1_check4, precision ); ok = u2_4.equals( u2_check4, precision ) && ok; ok = u3_4.equals( u3_check4, precision ) && ok; ok = lambda_4.equals( lambda_check4, precision ) && ok; if( ok) { log( "HOPM/CP-ALS with init DCT: rank-R approximation (R > I)", ok ); } else { std::stringstream error; error << "HOPM/CP-ALS with init DCT: rank-R approximation (R > I)" << std::setprecision(16) << std::endl << " lambda should be:\n" << lambda_check4 << "\nlambda is:\n" << lambda_4 << std::endl << " u1 should be: " << std::endl << u1_check4 << std::endl << " u1 is: " << std::endl << u1_4 << std::endl << " u2 should be: " << std::endl << u2_check4 << std::endl << " u2 is: " << std::endl << u2_4 << std::endl << " u3 should be: " << std::endl << u3_check4 << std::endl << " u3 is: " << std::endl << u3_4 << std::endl; log_error( error.str() ); } #endif return ok; } } //end vmml namespace vmmlib-1.0/tests/lapack_svd_test.cpp0000644000175000017500000001346511674116154017227 0ustar shevekshevek#include "lapack_svd_test.hpp" #include #include namespace vmml { bool lapack_svd_test::run() { bool ok; matrix< 6, 3, double > A; matrix< 6, 6, double > U; matrix< 6, 3, double > Umn; double AData[] = { .814723686393178936349102, .278498218867048397129338, .957166948242945569980122, .905791937075619224550849, .546881519204983845838797, .485375648722841224191882, .126986816293506055153273, .957506835434297598474984, .800280468888800111670889, .913375856139019393076239, .964888535199276531351131, .141886338627215335961296, .632359246225409510344662, .157613081677548283465740, .421761282626274991436333, .975404049994095245779135e-1, .970592781760615697095318, .915735525189067089968376 }; A = AData; vector< 3, double > sigma; matrix< 3, 3, double > V, Vt; //svdecompose( U, Wdiag, Vt ); lapack_svd< 6, 3, double > svd; svd.compute_full( A, U, sigma, V ); Vt = transpose( V ); matrix< 6, 6, double > UCorrect; matrix< 6, 6, double > UCorrect1; matrix< 6, 6, double > UCorrect2; // The reduced SVD is unique up to the signs of the singular vectors // The full SVD instead is not unique. I.e., the columns MXN in U change according to the sign. // Therefore there are two different tests data sets used. double UCorrectData_full1[] = { -.435998653539668934442375, -.248052501692949872724725, -.641901537841745417622974, 0.306824841164616279876043, -0.484835942345876347303602, 0.0844403463147926913734409, -.413858526085397582239267, -.365805126224619969743657, .390978936345444602618038e-1, -0.771262625195255790977455, -0.0348587030490726257347944, -0.311958199966299087879662, -.425433159981805031346624, .515921235828120217092874, .609523103830292567462124e-1, 0.261339720039846845622833, 0.0834226912479650445364499, -0.688374117746225255842774, -.43848803846546968721043, -0.318922843372823061613985, 0.722667517578294171798348, 0.345009020353229722832822, -0.144481192006895742263595, 0.20943275810172612416693, -.254348647932865379317491, -.315487795595138620363684, -.242833948045244552016442, 0.202942059410569142219316, 0.853964806456102953902132, 0.0797779396737642171322236, -.447959737368597288309502, .580721547093578371878664, -.387545997618539139750737e-1, -0.287223479102644174698611, 0.0814182344866708901376384, 0.60948042099844657037977 }; double UCorrectData_full2[] = { 0.4359986535396687, 0.24805250169295, 0.6419015378417452, 0.5580158557643846, -0.03137403811363688, 0.15482738995363, 0.4138585260853975, 0.3658051262246201, -0.03909789363454432, -0.5933609897059382, -0.3296179636619447, 0.4823420141912754, 0.425433159981805, -0.5159212358281197, -0.06095231038302926, -0.09332565981912261, 0.6471420583874449, 0.348732272888299, 0.4384880384654699, 0.3189228433728231, -0.7226675175782936, 0.3944064664498654, 0.042386562745301, -0.162527036692653, 0.2543486479328654, 0.3154877955951386, 0.2428339480452447, -0.4108321578673209, 0.406509249738382, -0.6654119458960903, 0.4479597373685974, -0.5807215470935781, 0.03875459976185423, -0.05909178550922316, -0.5518409491924592, -0.3906051294016697 }; UCorrect1 = UCorrectData_full1; UCorrect2 = UCorrectData_full2; //Set correct UCorrect (according to two possible full SVD solutions) if ( U.equals( UCorrect1, 1e-8 ) ) UCorrect = UCorrect1; else UCorrect = UCorrect2; vector< 3, double > sigmaCorrect; double sigmaCorrectData[] = { 2.65122386125434195136563, 1.05972597504600218876192, .782403321995605693928155 }; sigmaCorrect = sigmaCorrectData; matrix< 3, 3, double > VtCorrect; double VtCorrectData[] = { -0.523965874838933864943158, -0.851235737679022386181771, 0.0292827748398521402195538, -0.623515371051898026344418, 0.406763653882897313618372, 0.667661524982418264073658, -0.580248519227998138525493, 0.331573594814009942055577, -0.74388884059100535139919 }; VtCorrect = VtCorrectData; matrix_equals_allow_inverted_columns< matrix< 6, 6, double > > u_compare; matrix_equals_allow_inverted_columns< matrix< 3, 3, double > > v_compare; #if 1 ok = u_compare( U, UCorrect ); if ( ok ) ok = sigma == sigmaCorrect; if ( ok ) ok = v_compare( Vt, VtCorrect ); #else ok = U == UCorrect; if ( ok ) ok = sigma == sigmaCorrect; if ( ok ) ok = Vt == VtCorrect; #endif log( "singular value decomposition using lapack xGESVD, maximum precision", ok, true ); double tolerance = 1e-8; #if 1 ok = u_compare( U, UCorrect, tolerance ); if ( ok ) ok = sigma.equals( sigmaCorrect, tolerance ); if ( ok ) ok = v_compare( Vt, VtCorrect, tolerance ); #else ok = U.equals( UCorrect, tolerance ); if ( ok ) ok = sigma.equals( sigmaCorrect, tolerance ); if ( ok ) ok = Vt.equals( VtCorrect, tolerance ); #endif log( "singular value decomposition using lapack xGESVD, tolerance 1e-8", ok ); if ( ! ok ) { std::stringstream ss; ss << "U " << U << "\n" << "U correct " << UCorrect << "\n" << "U diff " << UCorrect - U << "\n" << "U diff " << UCorrect + U << "\n" << "sigma " << sigma << "\n" << "sigma correct" << sigmaCorrect << "\n" << "sigma diff " << sigmaCorrect - sigma << "\n" << "Vt " << Vt << "\n" << "Vt correct" << VtCorrect << "\n" << "Vt diff " << VtCorrect - Vt << "\n" << "Vt diff " << VtCorrect + Vt << "\n" << std::endl; log_error( ss.str() ); } return ok; return true; } } // namespace vmml vmmlib-1.0/tests/stringtests.cpp0000644000175000017500000001062511674116154016445 0ustar shevekshevek#include #include #include #include int main( int argc, const char* argv[] ) { // matrix3 string tests std::string matrix3data = "1.0 3.2 2.1 1.5 6.4 23.5 7.5 15.3 1.0";//" 3.2 2.1 1.5 6.4 23.5 7.5 15.3" vmml::Matrix3< float > m3; bool ok = m3.set( matrix3data ); if ( ok ) { std::cout << "string " << matrix3data << std::endl; std::cout << m3 << std::endl; } else std::cout << "failed: matrix3::set( const std::string& values )" << std::endl; std::vector< std::string > tokens; std::string current_token; for( size_t i = 0; i < 9; ++i ) { vmml::stringUtils::to_string< size_t >( i, current_token ); tokens.push_back( current_token ); } ok = m3.set( tokens ); if ( ok ) std::cout << m3 << std::endl; else std::cout << "failed: matrix3::set( const std::vector< std::string >& values )" << std::endl; matrix3data.clear(); ok = m3.getString( matrix3data, " " ); if ( ok ) std::cout << matrix3data << std::endl; else std::cout << "failed: matrix3::getString( .. ) " << std::endl; // matrix4 string tests std::string matrix4data = "1.0 3.2 2.1 1.5 6.4 23.5 7.5 15.3 1.0 3.2 2.1 1.5 6.4 23.5 7.5 15.3"; vmml::Matrix4< double > m4; ok = m4.set( matrix4data ); if ( ok ) { std::cout << "string " << matrix4data << std::endl; std::cout << m4 << std::endl; } else std::cout << "failed: matrix4::set( const std::string& values )" << std::endl; tokens.clear(); for( size_t i = 0; i < 16; ++i ) { vmml::stringUtils::to_string< size_t >( i, current_token ); tokens.push_back( current_token ); } ok = m4.set( tokens ); if ( ok ) std::cout << m4 << std::endl; else std::cout << "failed: matrix4::set( const std::vector< std::string >& values )" << std::endl; matrix4data.clear(); ok = m4.getString( matrix4data, ":" ); if ( ok ) std::cout << matrix4data << std::endl; else std::cout << "failed: matrix4::getString( .. ) " << std::endl; // vector2 string tests std::string vector2data = "1.0 3.2"; vmml::Vector2< float > v2; ok = v2.set( vector2data ); if ( ok ) { std::cout << "string " << vector2data << std::endl; std::cout << v2 << std::endl; } else std::cout << "failed: vector2::set( const std::string& values )" << std::endl; tokens.clear(); for( size_t i = 0; i < 2; ++i ) { vmml::stringUtils::to_string< size_t >( i, current_token ); tokens.push_back( current_token ); } ok = v2.set( tokens ); if ( ok ) std::cout << v2 << std::endl; else std::cout << "failed: vector2::set( const std::vector< std::string >& values )" << std::endl; vector2data.clear(); ok = v2.getString( vector2data, " " ); if ( ok ) std::cout << vector2data << std::endl; else std::cout << "failed: vector2::getString( .. ) " << std::endl; // vector3 string tests std::string vector3data = "1.0:3.2:23.3:"; vmml::Vector3< float > v3; ok = v3.set( vector3data, ':' ); if ( ok ) { std::cout << "string " << vector3data << std::endl; std::cout << v3 << std::endl; } else std::cout << "failed: vector3::set( const std::string& values )" << std::endl; tokens.clear(); for( size_t i = 0; i < 3; ++i ) { vmml::stringUtils::to_string< size_t >( i, current_token ); tokens.push_back( current_token ); } ok = v3.set( tokens ); if ( ok ) std::cout << v3 << std::endl; else std::cout << "failed: vector3::set( const std::vector< std::string >& values )" << std::endl; vector3data.clear(); ok = v3.getString( vector3data, ", " ); if ( ok ) std::cout << vector3data << std::endl; else std::cout << "failed: vector3::getString( .. ) " << std::endl; // vector4 string tests std::string vector4data = "1.0,3.2,5.5555, 9797.7"; vmml::Vector4< double > v4; ok = v4.set( vector4data, ',' ); if ( ok ) { std::cout << "string " << vector4data << std::endl; std::cout << v4 << std::endl; } else std::cout << "failed: vector4::set( const std::string& values )" << std::endl; tokens.clear(); for( size_t i = 0; i < 4; ++i ) { vmml::stringUtils::to_string< float >( 0.2342343473413215125 * i, current_token ); tokens.push_back( current_token ); } ok = v4.set( tokens ); if ( ok ) std::cout << v4 << std::endl; else std::cout << "failed: vector4::set( const std::vector< std::string >& values )" << std::endl; vector4data.clear(); ok = v4.getString( vector4data, ", " ); if ( ok ) std::cout << vector4data << std::endl; else std::cout << "failed: vector4::getString( .. ) " << std::endl; } vmmlib-1.0/tests/t3_ihopm_test.hpp0000644000175000017500000000055311674116154016641 0ustar shevekshevek#ifndef __VMML__T3_IHOPM_TEST__HPP__ #define __VMML__T3_IHOPM_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class t3_ihopm_test : public unit_test { public: t3_ihopm_test() : unit_test( "tensor3 incremental rank-r CP-ALS (or iHOPM)" ) {} bool run(); protected: }; // class t3_ihopmtest } // namespace vmml #endif vmmlib-1.0/tests/lapack_sym_eigs_test.cpp0000644000175000017500000001002511674116154020237 0ustar shevekshevek#include "lapack_sym_eigs_test.hpp" #include #include namespace vmml { bool lapack_sym_eigs_test::run() { bool ok = true; matrix< 4, 4, double > A; double data[] = { -2.0000, -0.6714, 0.8698, 0.5792, -0.6714, -1.1242, -0.0365, -0.5731, 0.8698, -0.0365, -0.4660, -0.8542, 0.5792, -0.5731, -0.8542, 0.1188}; A.set( data, data+16 ); //compute all eigenvalues matrix< 4, 4, double > eigvectors; vector< 4, double > eigvalues; lapack_sym_eigs< 4, double > eig; eig.compute_all( A, eigvectors, eigvalues); double data_eigvalues[] = {-2.776873597454109, -1.505827874899289, -0.03704459256313505, 0.8483149985370052}; double data_eigvectors[] = { -0.846872951394099, -0.05486702445763353, 0.522012007849923, 0.08543580914755927, -0.2525272340154449, -0.8141033734762484, -0.45228815766001, -0.2624902204189269, 0.4028336856489185, -0.3565378545075824, 0.6942974502977717, -0.4780761764820428, 0.2382461373958975, -0.4550890739458455, 0.2022126025029584, 0.8338121947897114}; matrix< 4, 4, double > eigvectors_check; vector< 4, double > eigvalues_check; eigvalues_check = data_eigvalues; eigvectors_check.set( data_eigvectors, data_eigvectors + 16); double precision = 1.0e-10; ok = eigvalues.equals( eigvalues_check, precision ); ok = ok && eigvectors.equals( eigvectors_check, precision ); if ( ok ) { log( "symmetric eigenvalue decomposition using lapack", ok ); } else { std::stringstream error; error << "symmetric eigenvalue decomposition using lapack: " << std::endl << "eigenvalues should be: " << std::endl << eigvalues_check << std::endl << "are: " << std::endl << eigvalues << std::endl << "eigenvectors should be: " << std::endl << eigvectors_check << std::endl << "are: " << std::endl << eigvectors << std::endl; log_error( error.str() ); } //end compute all eigenvalues //compute x largest magnitude eigenvalues matrix< 4, 3, double > eigxvectors; vector< 3, double > eigxvalues; lapack_sym_eigs< 4, double > eigs; eigs.compute_x( A, eigxvectors, eigxvalues); matrix< 4, 3, double > eigxvectors_check; vector< 3, double > eigxvalues_check; vector< 4, double > eigvector_check; double first_eigvalue = -2.776873597454109; double data_eigxvalues[] = {-2.776873597454109, -1.505827874899289, 0.8483149985370052 }; double data_eigxvectors[] = { -0.846872951394099, -0.05486702445763353, 0.08543580914755927, -0.2525272340154449, -0.8141033734762484, -0.2624902204189269, 0.4028336856489185, -0.3565378545075824, -0.4780761764820428, 0.2382461373958975, -0.4550890739458455, 0.8338121947897114 }; eigxvalues_check = data_eigxvalues; eigxvectors_check.set( data_eigxvectors, data_eigxvectors + 12); eigxvectors_check.get_column( 0, eigvector_check ); //get first eigvalue and eigvector vector< 4, double > eigvector; double eigvalue; eigs.compute_1st( A, eigvector, eigvalue); ok = eigxvalues.equals( eigxvalues_check, precision ); ok = ok && eigxvectors.equals( eigxvectors_check, precision ); ok = ok && (eigvector.equals( eigvector_check, precision )); //ok = ok && (fabs(eigvalue - first_eigvalue) < precision); if ( ok ) { log( "symmetric eigenvalue decomposition (x largest eigenvalues) using lapack", ok ); } else { std::stringstream error; error << std::setprecision(10) << "symmetric eigenvalue decomposition (x largest eigenvalues) using lapack: " << std::endl << "eigenvalues should be: " << std::endl << eigxvalues_check << std::endl << "are: " << std::endl << eigxvalues << std::endl << "eigenvectors should be: " << std::endl << eigxvectors_check << "are: " << std::endl << eigxvectors << std::endl << "first eigenvalue should be: " << first_eigvalue << ", is: " << eigvalue << std::endl << "first eigenvector should be:\n" << eigvector_check << "\n is:\n" << eigvector << std::endl; log_error( error.str() ); } //end compute x largest eigenvalues return true; } } // namespace vmml vmmlib-1.0/tests/performance_test.cpp0000644000175000017500000000132111674116154017405 0ustar shevekshevek#include "performance_test.hpp" #include namespace vmml { void performance_test::new_test( const std::string& name ) { _log << "PERFORMANCE TEST: " << name << ".\n"; _timer.start(); } void performance_test::start( const std::string& name ) { _log << name << ": "; _timer.start(); } void performance_test::stop() { double sec = _timer.get_seconds(); _log << sec << " seconds.\n"; _last_times.push_back( sec ); } void performance_test::compare() { size_t size = _last_times.size(); assert( size > 1 ); double s1 = _last_times[ size - 1 ]; double s0 = _last_times[ size - 2 ]; _log << ( s1 / s0 ) * 1e2 << "% \n\n"; } } // namespace vmml vmmlib-1.0/tests/quaternion_test.cpp0000644000175000017500000001347111674116154017302 0ustar shevekshevek#include "quaternion_test.hpp" #include #include using namespace std; namespace vmml { typedef quaternion< float > quaternionf; typedef quaternion< double > quaterniond; bool quaternion_test::run() { quaternion< double > q; double QData[] = { 1., 6., 3., 8. }; for( size_t index = 0; index < 4; ++index ) { q.array[ index ] = QData[ index ]; } // operator==/!= tests { bool ok = true; quaterniond qq, qqq; qq.array[ 0 ] = qqq.array[ 0 ] = 1.0; qq.array[ 1 ] = qqq.array[ 1 ] = 6.0; qq.array[ 2 ] = qqq.array[ 2 ] = 3.0; qq.array[ 3 ] = qqq.array[ 3 ] = 8.0; if ( qq != qqq ) ok = false; if ( ok && ! ( qq == qqq ) ) ok = false; log( "operator==, operator!=", ok ); } // operator= tests { bool ok = true; quaterniond tquaternion_test = q; if ( tquaternion_test != q ) ok = false; tquaternion_test.iter_set< double* >( QData, QData + 4 ); if ( ok && tquaternion_test != q ) ok = false; log( "operator=", ok ); } // ctor tests { bool ok = true; quaterniond qq( q ); if ( q != qq ) ok = false; quaterniond t( 1., 6., 3., 8 ); if ( ok && q != t ) ok = false; vector< 3, double > xyz; double xyzData[] = { 1., 6., 3. }; xyz = xyzData; quaterniond s( xyz, 8 ); if ( ok && q != s ) ok = false; matrix< 3, 3, double > mat; double matData[] = { 1., 0., 0., 0., 0., 1., 0., -1., 0. }; mat = matData; quaterniond u( mat ); if ( u.w() != ( sqrt( 2. ) / 2. ) ) { ok = false; } if ( u.x() != - ( 1 / sqrt( 2. ) ) ) { ok = false; } if ( u.y() != 0 || u.z() != 0 ) { ok = false; } log( "constructors", ok ); } // set test { bool ok = true; quaterniond qqq; qqq.set ( 1., 6., 3., 8. ); if ( qqq != q ) ok = false; log( "set( x,y,z,w )", ok ); } // abs { bool ok = true; if ( q.abs() != sqrt( 110.0 ) ) ok = false; if ( q.squared_abs() != 110 ) ok = false; log( "abs(), squared_abs()", ok ); } //conjugate() test { bool ok = true; quaterniond conj( -1., -6., -3., 8. ); if ( q.get_conjugate() != conj ) ok = false; conj.conjugate(); if ( q != conj ) ok = false; log( "conjugate()", ok ); } // quat / scalar operations { bool ok = true; quaterniond t; t.set( 1, 2, 3, 4 ); quaterniond t3; t3.set( 3, 6, 9, 12 ); double f = 3.0; double rf = 1./ f; t *= f; if ( t != t3 ) ok = false; t.set( 1, 2, 3, 4 ); t /= rf; if ( t != t3 ) ok = false; t.set( 1, 2, 3, 4 ); if ( ( t * f ) != t3 ) ok = false; t.set( 1, 2, 3, 4 ); if ( ( t / rf ) != t3 ) ok = false; log( "quaternion / scalar operations: operator*, /, *=, /=", ok ); } { bool ok = true; quaterniond qq; qq.set( 8, 3, 6, 1 ); quaterniond qpqq; qpqq.set( 9., 9., 9., 9. ); // +, += if ( q + qq != qpqq ) ok = false; qq += q; if ( qq != qpqq ) ok = false; // -, -= qq.set( 8, 3, 6, 1 ); if ( qpqq - qq != q ) ok = false; qpqq -= qq; if ( qpqq != q ) ok = false; // *, *= qq.set( 2, 3, 4, 1 ); quaterniond q2( 3, 2, 1, 4 ); quaterniond p = qq * q2; quaterniond pCorrect( 6, 24, 12, -12 ); if ( p != pCorrect ) ok = false; p = qq; p *= q2; if ( p != pCorrect ) ok = false; log( "quaternion / quaternion operations: operator+, -, *, +=, -=, *=", ok ); } { bool ok = true; quaterniond qq( 1, 2, 3, 4 ); quaterniond q2( -6, 5, -4, 2 ); vector< 3, double > v = qq.cross( q2 ); vector< 3, double > v0( 1, 2, 3 ); vector< 3, double > v1( -6, 5, -4 ); if ( v != v0.cross( v1 ) ) ok = false; log( "cross product ( vec3 = quat x quat ).", ok ); } #if 0 Quaterniond rquaternion_test( 8. / 110., -1. / 110., -6. / 110., -3. / 110. ); if ( _quaternion.invert() != rquaternion_test ) { cout << "test: Quaternion::invert() failed!" << endl; failed(); assert( 0 ); } if ( tquaternion_test.dot( _quaternion ) != 40. ) { cout << "test: Quaternion::dot( quaternion ) failed!" << endl; failed(); assert( 0 ); } Vector3d vector3_test( -30., -4., 18. ); if ( tquaternion_test.cross( _quaternion ) != vector3_test ) { cout << "test: Quaternion::cross( quaternion ) failed!" << endl; failed(); assert( 0 ); } Vector3d yaxis( 1., 0., 0. ); Quaterniond svector3_test( 0., 18., -30., -4. ); Quaterniond result_test( _quaternion.rotate( M_PI / 2.f, yaxis, vector3_test ) ); if ( abs( result_test.abs() - svector3_test.abs() ) > 1e-13 ) { cout << "test: Quaternion::rotate( T, Vector3, Vector3 ) failed!" << endl; failed(); assert( 0 ); } if ( ok ) cout << "Quaternion: all tests passed!" << endl; #endif return true; } } vmmlib-1.0/tests/qtucker3_tensor_test.hpp0000644000175000017500000000064411674116154020253 0ustar shevekshevek#ifndef __VMML__QTUCKER3_TENSOR_TEST__HPP__ #define __VMML__QTUCKER3_TENSOR_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class qtucker3_tensor_test : public unit_test { public: qtucker3_tensor_test() : unit_test( "quantized tucker3_tensor (R1xR2xR3) x (I1xR1) x (I2xR2) x (I3xR3)" ) {} bool run(); protected: }; // class qtucker3_tensor_test } // namespace vmml #endif vmmlib-1.0/tests/jacobi_test.hpp0000644000175000017500000000045011674116154016342 0ustar shevekshevek#ifndef __VMML__JACOBI_TEST__HPP__ #define __VMML__JACOBI_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class jacobi_test : public unit_test { public: jacobi_test() : unit_test( "jacobi test" ) {} bool run(); protected: }; // class jacobi_test } // namespace vmml #endif vmmlib-1.0/tests/quaternion_test.hpp0000644000175000017500000000044511674116154017304 0ustar shevekshevek#ifndef __VMML_QUATERNION_TEST__HPP__ #define __VMML_QUATERNION_TEST__HPP__ #include #include "unit_test.hpp" namespace vmml { class quaternion_test : public unit_test { public: quaternion_test() : unit_test( "quaternion" ) {} virtual bool run(); }; } #endif vmmlib-1.0/tests/matrix_compare_perf_test.cpp0000644000175000017500000001041511674116154021136 0ustar shevekshevek#include "matrix_compare_perf_test.hpp" #include #include namespace vmml { void matrix_compare_perf_test::run() { const size_t iterations = 1e7; double Mdata4x4[] = { 17., 24., 1., 8., 23., 5., 7., 14., 4., 6., 13., 20., 10., 12., 19., 21. }; matrix< 4, 4 > m, m_inverse; m = Mdata4x4; Matrix4< double > m_old, m_old_inverse; m_old.set( Mdata4x4 ); new_test( "matrix 4x4 inversion comparison" ); start( "old" ); for( size_t i = 0; i < iterations; ++i ) { m_old.getInverse( m_old_inverse ); } stop(); start( "new" ); for( size_t i = 0; i < iterations; ++i ) { m.getInverse( m_inverse ); } stop(); compare(); double d; new_test( "operator[]" ); start( "old 1d[]" ); for( size_t i = 0; i < iterations; ++i ) { d = m_old.array[ i % 16 ]; } stop(); start( "new 1d[]()" ); for( size_t i = 0; i < iterations; ++i ) { d = m.array[ i % 16 ]; } stop(); compare(); new_test( "operator[] 2d" ); { start( "old 2d[]" ); for( size_t i = 0; i < iterations; ++i ) { d = m_old.m[ i % 4 ][ i % 4 ]; } stop(); start( "new 2d[]()" ); for( size_t i = 0; i < iterations; ++i ) { d = m[ i % 4 ][ i % 4 ]; } stop(); } compare(); new_test( "operator[]" ); start( "new []" ); for( size_t i = 0; i < iterations; ++i ) { d = m[ i % 3 ][ i % 3 ]; } stop(); start( "new at()" ); for( size_t i = 0; i < iterations; ++i ) { d = m.at( i % 3, i % 3 ); } stop(); compare(); new_test( "copy ctor" ); start( "old" ); for( size_t i = 0; i < iterations; ++i ) { Matrix4< double > mm( m_old ); } stop(); start( "new" ); for( size_t i = 0; i < iterations; ++i ) { matrix< 4, 4, double > mm( m ); } stop(); compare(); new_test( "operator==/!=" ); { Matrix4< double > mm_old( m_old ); matrix< 4, 4, double > mm( m ); bool equal; start( "old" ); for( size_t i = 0; i < iterations; ++i ) { equal = mm_old != m_old; } stop(); start( "new" ); for( size_t i = 0; i < iterations; ++i ) { equal = mm != m; } stop(); } compare(); new_test( "setting to identity" ); { Matrix4< double > mm_old; matrix< 4, 4, double > mm; start( "old" ); for( size_t i = 0; i < iterations; ++i ) { mm_old = Matrix4< double >::IDENTITY; } stop(); start( "new" ); for( size_t i = 0; i < iterations; ++i ) { mm.identity(); //mm = matrix< 4, 4, double >::IDENTITY; } stop(); } compare(); new_test( "setting to zero" ); { Matrix4< double > mm_old; matrix< 4, 4, double > mm; start( "old" ); for( size_t i = 0; i < iterations; ++i ) { mm_old = Matrix4< double >::ZERO; } stop(); start( "new" ); for( size_t i = 0; i < iterations; ++i ) { mm.zero(); //mm = matrix< 4, 4, double >::ZERO; } stop(); } compare(); new_test( "build rotation matrix for rotation around arbitrary axis" ); { Matrix4< double > mm_old; matrix< 4, 4, double > mm; Vector3< double > axis_old; vector< 3, double > axis; double axisData[] = { 1.4, 2.4, -3 }; axis_old = axisData; axis_old.normalize(); axis = axisData; axis.normalize(); double angle = 1.3333333333333333333333; start( "old" ); for( size_t i = 0; i < iterations; ++i ) { mm_old.rotate( angle, axis_old ); } stop(); start( "new" ); for( size_t i = 0; i < iterations; ++i ) { mm.rotate( angle, axis ); } stop(); } compare(); } } // namespace vmml vmmlib-1.0/tests/t3_hosvd_test.hpp0000644000175000017500000000051611674116154016647 0ustar shevekshevek#ifndef __VMML__T3_HOSVD_TEST__HPP__ #define __VMML__T3_HOSVD_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class t3_hosvd_test : public unit_test { public: t3_hosvd_test() : unit_test( "tensor3 HOSVD" ) {} bool run(); protected: }; // class t3_hosvd_test } // namespace vmml #endif vmmlib-1.0/tests/tucker3_tensor_test.cpp0000644000175000017500000001767711674116154020103 0ustar shevekshevek#include "tucker3_tensor_test.hpp" #include #include namespace vmml { bool tucker3_tensor_test::run() { bool ok = false; double precision = 0.001; typedef double T_value; typedef double T_coeff; typedef tensor3< 3, 2, 2, T_value> t3_type; typedef matrix< 3, 2, T_coeff > u1_type; typedef matrix< 2, 2, T_coeff > u2_type; typedef matrix< 2, 1, T_coeff > u3_type; typedef tensor3< 2, 2, 1, T_coeff > core_type; typedef t3_hooi< 2, 2, 1, 3, 2, 2, float > hooi_type; typedef tucker3_tensor< 2, 2, 1, 3, 2, 2, T_value, T_coeff > tuck3_type; //test data from lathauwer et al. 2000b paper (same test as in t3_hooi_test T_value data_als[] = { 0, 1, 2, 3, 4, 5, -1, 4, -2, -5, 3, -6 }; t3_type t3_data_als; t3_data_als.set( data_als, data_als + 12 ); T_coeff data_u1_hooi[] = { -0.2789474111071824, 0.4141266306147135, 0.5983607967045262, 0.7806355076145295, 0.7511009910815754, -0.4680890279285661 }; //original from paper (u1): {-0.2789, -0.4141, 0.5984, -0.7806, 0.7511, 0.4681}; u1_type u1_hooi_check; u1_hooi_check.set( data_u1_hooi, data_u1_hooi + 6); T_coeff data_u2_hooi[] = { 0.09816424894941811, 0.9951702267593202, 0.9951702267593202, -0.098164248949418 }; //original in paper (u2): 0.0982, -0.9952, 0.9952, 0.0982}; u2_type u2_hooi_check; u2_hooi_check.set( data_u2_hooi, data_u2_hooi + 4); T_coeff data_u3_hooi[] = {-0.5104644303570166, 0.8598988692516616};//original in paper (u3): {0.5105, -0.8599}; u3_type u3_hooi_check; u3_hooi_check.set( data_u3_hooi, data_u3_hooi + 2); T_coeff data_core_hooi[] = { -10.14733447424582, 0.0, 0.0, -2.760705584847321 }; core_type core_hooi_check; core_hooi_check.set( data_core_hooi, data_core_hooi + 4); //end fill test data u1_type u1_hooi; u1_hooi.zero(); u2_type u2_hooi; u2_hooi.zero(); u3_type u3_hooi; u3_hooi.zero(); core_type core_hooi; tuck3_type tuck3_hooi; tuck3_hooi.tucker_als( t3_data_als, hooi_type::init_hosvd() ); tuck3_hooi.get_u1( u1_hooi ); tuck3_hooi.get_u2( u2_hooi ); tuck3_hooi.get_u3( u3_hooi ); tuck3_hooi.get_core( core_hooi ); ok = u1_hooi.equals( u1_hooi_check, precision ); ok = ok && u2_hooi.equals( u2_hooi_check, precision ); ok = ok && u3_hooi.equals( u3_hooi_check, precision ); ok = ok && core_hooi.equals( core_hooi_check, precision); if ( ok ) { log( "Tucker ALS: rank-(2,2,1) approximation (same test as T3_HOOI)" , true ); } else { std::stringstream error; error << "Tucker ALS: rank-(2,2,1) approximation: " << std::setprecision(16) << std::endl << "U1 should be: " << std::endl << u1_hooi_check << std::endl << "U1 is: " << std::endl << u1_hooi << std::endl << "U2 should be: " << std::endl << u2_hooi_check << std::endl << "U2 is: " << std::endl << u2_hooi << std::endl << "U3 should be: " << std::endl << u3_hooi_check << std::endl << "U3 is: " << std::endl << u3_hooi << std::endl << "core should be: " << std::endl << core_hooi_check << std::endl << "core is: " << std::endl << core_hooi << std::endl; log_error( error.str() ); } //number of nonzeros size_t number_nonzeros = tuck3_hooi.nnz( ); size_t number_nonzeros2 = tuck3_hooi.nnz( 0.1 ); ok = ( number_nonzeros == 16 ) && (number_nonzeros2 == 12); log( "get number of nonzeros" , ok ); //tucker3 reconstruction typedef int T_value_3; typedef int T_coeff_3; typedef tensor3< 6, 7, 5, T_value_3 > t3r_type; typedef tensor3< 2, 3, 4, T_coeff_3 > t3r_core_type; typedef matrix< 6, 2, T_coeff_3 > u1r_type; typedef matrix< 7, 3, T_coeff_3 > u2r_type; typedef matrix< 5, 4, T_coeff_3 > u3r_type; typedef tucker3_tensor< 2, 3, 4, 6, 7, 5, T_value_3, T_coeff_3 > tuck3r_type; t3r_core_type core; core.fill_increasing_values(); u1r_type u1; u1.fill(2); u2r_type u2; u2.fill(3); u3r_type u3; u3.fill(1); t3r_type t3_reco; tuck3r_type tuck3( core, u1, u2, u3 ); tuck3.reconstruct( t3_reco ); t3r_type t3_reco_check; t3_reco_check.fill(1656); //thresholded tucker tuck3r_type tuck3_copy( tuck3 ); t3r_type t3_reco_thresh1; t3r_type t3_reco_thresh2; size_t nnz_core = 0; tuck3_copy.threshold_core( 4, nnz_core ); tuck3_copy.reconstruct( t3_reco_thresh1 ); tuck3_copy.threshold_core( 12, nnz_core ); tuck3_copy.reconstruct( t3_reco_thresh2 ); t3r_type t3_reco_thresh1_check; t3_reco_thresh1_check.fill(1596); t3r_type t3_reco_thresh2_check; t3_reco_thresh2_check.fill(1188); ok = ( t3_reco_check == t3_reco ) && ( t3_reco_thresh1 == t3_reco_thresh1_check ) && ( t3_reco_thresh2 == t3_reco_thresh2_check); log( "tucker3 reconstruction (incl. core thresholding)", ok ); //rank reduction typedef tensor3< 6, 7, 5, T_value_3 > t3rr_type; typedef tensor3< 1, 2, 3, T_coeff_3 > t3rr_core_type; typedef matrix< 6, 1, T_coeff_3 > u1rr_type; typedef matrix< 7, 2, T_coeff_3 > u2rr_type; typedef matrix< 5, 3, T_coeff_3 > u3rr_type; typedef tucker3_tensor< 1, 2, 3, 6, 7, 5, T_value_3, T_coeff_3 > tuck3rr_type; u1rr_type u1_red; u1_red.fill(2); u2rr_type u2_red; u2_red.fill(3); u3rr_type u3_red; u3_red.fill(1); T_value_3 data[] = { 0, 1, 6, 7, 12, 13 }; t3rr_core_type core_red; core_red.set(data, data + 6); t3rr_core_type core_red2; u1rr_type u1_red2; u2rr_type u2_red2; u3rr_type u3_red2; tuck3rr_type tuck3_red( core_red, u1_red, u2_red, u3_red ); tuck3_red.reduce_ranks( tuck3 ); tuck3_red.get_u1( u1_red2 ); tuck3_red.get_u2( u2_red2 ); tuck3_red.get_u3( u3_red2 ); tuck3_red.get_core( core_red2 ); if ( u1_red2 == u1_red && u2_red2 == u2_red && u3_red2 == u3_red && core_red2 == core_red) { log( "tucker3 reduce ranks", true ); } else { std::stringstream error; error << "Tucker3 reduce ranks: " << std::endl << "u1 should be: " << u1_red << std::endl << "u1 is: " << u1_red2 << std::endl << "u2 should be: " << u2_red << std::endl << "u2 is: " << u2_red2 << std::endl << "u3 should be: " << u3_red << std::endl << "u3 is: " << u3_red2 << std::endl << "core should be: " << core_red << std::endl << "core is: " << core_red2 << std::endl; log_error( error.str() ); } //factor matrices subsampling typedef tensor3< 3, 4, 3, T_value_3 > t3s_type; typedef tucker3_tensor< 2, 3, 4, 3, 4, 3, T_value_3, T_coeff_3 > tuck3s_type; t3s_type t3_sub; tuck3s_type tuck3_sub; tuck3_sub.subsampling( tuck3, 2); tuck3_sub.reconstruct( t3_sub ); t3s_type t3_sub_check; t3_sub_check.fill(1656); if ( t3_sub_check == t3_sub ) { log( "factor matrices subsampling", true ); } else { std::stringstream error; error << "factor matrices subsampling with factor 2: " << std::endl << t3_sub << std::endl; log_error( error.str() ); } //factor matrices subsampling, average data t3s_type t3_sub_avg; tuck3s_type tuck3_sub_avg; tuck3_sub_avg.subsampling_on_average( tuck3, 2); tuck3_sub_avg.reconstruct( t3_sub_avg ); t3_sub_check.fill(1656); if ( t3_sub_check == t3_sub_avg ) { log( "factor matrices subsampling on average", true ); } else { std::stringstream error; error << "factor matrices subsampling on average with factor 2: " << std::endl << t3_sub_avg << std::endl; log_error( error.str() ); } //factor matrices region of interest selection typedef tucker3_tensor< 2, 3, 4, 1, 1, 3, T_value_3, T_coeff_3 > tuck3_roi_type; typedef tensor3< 1, 1, 3, T_value_3 > t3_roi_type; t3_roi_type t3_roi; tuck3_roi_type tuck3_roi; tuck3_roi.region_of_interest( tuck3, 0, 1, 1, 2, 1, 4); tuck3_roi.reconstruct( t3_roi ); t3_roi_type t3_roi_test; t3_roi_test.fill(1656); if ( t3_roi_test == t3_roi) { log( "factor matrices region of interest selection", true ); } else { std::stringstream error; error << "factor matrices region of interest selection: " << std::endl << t3_roi << std::endl; log_error( error.str() ); } return ok; } } // namespace vmml vmmlib-1.0/tests/t3_hopm_test.hpp0000644000175000017500000000050611674116154016466 0ustar shevekshevek#ifndef __VMML__T3_HOPM_TEST__HPP__ #define __VMML__T3_HOPM_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class t3_hopm_test : public unit_test { public: t3_hopm_test() : unit_test( "tensor3 HOPM" ) {} bool run(); protected: }; // class t3_hopmtest } // namespace vmml #endif vmmlib-1.0/tests/svd_lapack_vs_old.cpp0000644000175000017500000000411711674116154017530 0ustar shevekshevek#include "svd_lapack_vs_old.hpp" #include #include #include #include #define VMMLIB_LAPACK_DEBUG_OUT namespace vmml { void svd_lapack_vs_old::run() { const size_t iterations = 100000; new_test( "svd old vs lapack (double precision)" ); { matrix< 4, 4, double > A; matrix< 4, 4, double > U; matrix< 4, 4, double > Vt; vector< 4, double > sigma; double AData[] = { .567821640725221121748234, .779167230102011165726594, .469390641058205826396943, .794284540683906969960049, .758542895630636149206794e-1, .934010684229182985838236, .119020695012413968427722e-1, .311215042044804879317610, .539501186666071497199937e-1, .129906208473730133690083, .337122644398881510241495, .528533135506212725651665, .530797553008972688992628, .568823660872192715665108, .162182308193242752381025, .165648729499780933416275 }; A = AData; U = 0.0; Vt = 0.0; sigma = 0.0; start( "old" ); for( size_t i = 0; i < iterations; ++i ) { U = AData; svdecompose( U, sigma, Vt ); } stop(); #ifdef VMMLIB_LAPACK_DEBUG_OUT std::cout << "old: A, U, S, Vt" << std::endl; std::cout << A << std::endl; std::cout << U << std::endl; std::cout << sigma << std::endl; std::cout << Vt << std::endl; #endif U = 0.0; Vt = 0.0; sigma = 0.0; start( "lapack" ); lapack_svd< 4, 4, double > lapack_svd; for( size_t i = 0; i < iterations; ++i ) { A = AData; lapack_svd.compute( A, U, sigma, Vt ); } stop(); #ifdef VMMLIB_LAPACK_DEBUG_OUT std::cout << "lapack: A, U, S, Vt" << std::endl; std::cout << A << std::endl; std::cout << U << std::endl; std::cout << sigma << std::endl; std::cout << Vt << std::endl; #endif compare(); } } } // namespace vmml vmmlib-1.0/tests/blas_dot_test.cpp0000644000175000017500000000145511674116154016703 0ustar shevekshevek#include "blas_dot_test.hpp" #include namespace vmml { bool blas_dot_test::run() { bool ok = false; vector< 4, double > A; vector< 4, double > B; double AData[] = { 1, 2, 3, 4}; A = AData; double BData[] = { 5, 6, 7, 8}; B = BData; double dot_prod = 0; double dot_prod_check = 70; blas_dot< 4, double > blas_dot1; blas_dot1.compute( A, B, dot_prod ); ok = dot_prod == dot_prod_check; log( "dot product", ok ); if ( ! ok ) { std::stringstream ss; ss << "dot product of \n" << A << "\n" << "and \n" << B << "\n" << "should be\n" << dot_prod_check << "\n" << "is\n" << dot_prod << "\n" << std::endl; log_error( ss.str() ); } return ok; } } // namespace vmml vmmlib-1.0/tests/qr_decomposition_test.hpp0000644000175000017500000000053311674116154020473 0ustar shevekshevek#ifndef __VMML__QR_DECOMPOSITION_TEST__HPP__ #define __VMML__QR_DECOMPOSITION_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class qr_decomposition_test : public unit_test { public: qr_decomposition_test() : unit_test( "QR decomposition" ) {} bool run(); protected: }; // class qr_decomposition_test } // namespace vmml #endif vmmlib-1.0/tests/t3_hooi_test.cpp0000644000175000017500000000710711674116154016460 0ustar shevekshevek#include "t3_hooi_test.hpp" #include "vmmlib/t3_hooi.hpp" #include namespace vmml { bool t3_hooi_test::run() { bool ok = false; double precision = 0.001; //test data from lathauwer et al. 2000b paper tensor3< 3, 2, 2, double> t3_data; double data[] = { 0, 1, 2, 3, 4, 5, -1, 4, -2, -5, 3, -6 }; t3_data.set( data, data + 12 ); matrix< 3, 2, double > u1; u1.zero(); matrix< 2, 2, double > u2; u2.zero(); matrix< 2, 1, double > u3; u3.zero(); matrix< 3, 2, double > u1_check; matrix< 2, 2, double > u2_check; matrix< 2, 1, double > u3_check; double data_u1[] = { -0.2789474111071824, 0.4141266306147135, 0.5983607967045262, 0.7806355076145295, 0.7511009910815754, -0.4680890279285661 }; //original from paper (u1): {-0.2789, -0.4141, 0.5984, -0.7806, 0.7511, 0.4681}; u1_check.set( data_u1, data_u1 + 6); double data_u2[] = { 0.09816424894941811, 0.9951702267593202, 0.9951702267593202, -0.098164248949418 }; //original in paper (u2): 0.0982, -0.9952, 0.9952, 0.0982}; u2_check.set( data_u2, data_u2 + 4); double data_u3[] = { -0.5104644303570166, 0.8598988692516616 };//original in paper (u3): {0.5105, -0.8599}; u3_check.set( data_u3, data_u3 + 2); tensor3< 2, 2, 1, double > core; tensor3< 2, 2, 1, double > core_check; double data_core[] = { -10.14733447424582, 0.0, 0.0, -2.760705584847321 }; core_check.set( data_core, data_core + 4); typedef t3_hooi< 2, 2, 1, 3, 2, 2, double > hooi_type; hooi_type::als( t3_data, u1, u2, u3, core, hooi_type::init_hosvd() ); ok = u1.equals( u1_check, precision ); ok = ok && ( u2.equals( u2_check, precision ) ); ok = ok && ( u3.equals( u3_check, precision ) ); ok = ok && ( u3.equals( u3_check, precision ) ); ok = ok && ( core.equals( core_check, precision ) ); if ( ok ) { log( "HOOI rank-(2,2,1) approximation" , ok ); } else { std::stringstream error; error << "HOOI rank-(2,2,1) approximation: " << std::setprecision(16) << std::endl << "U1 should be: " << std::endl << u1_check << std::endl << "U1 is: " << std::endl << u1 << std::endl << "U2 should be: " << std::endl << u2_check << std::endl << "U2 is: " << std::endl << u2 << std::endl << "U3 should be: " << std::endl << u3_check << std::endl << "U3 is: " << std::endl << u3 << std::endl << "core should be: " << std::endl << core_check << std::endl << "core is: " << std::endl << core << std::endl; log_error( error.str() ); } //(1a) derive core tensor (with pseudo inverse) core.zero(); t3_hooi< 2, 2, 1, 3, 2, 2, double >::derive_core( t3_data, u1_check, u2_check, u3_check, core ); if ( core.equals( core_check, precision )) { log( "derive core tensor", true ); } else { std::stringstream error; error << "derive core: " << std::endl << "core should be: " << std::endl << core_check << std::endl << "core is: " << std::setprecision(16) << std::endl << core << std::endl; log_error( error.str() ); } //(1b) derive core tensor with orthogonal basis core.zero(); t3_hooi< 2, 2, 1, 3, 2, 2, double >::derive_core_orthogonal_bases( t3_data, u1_check, u2_check, u3_check, core ); if ( core.equals( core_check, precision )) { log( "derive core tensor (orthogonal bases)", true ); } else { std::stringstream error; error << "derive core (orthogonal bases): " << std::endl << "core should be: " << std::endl << core_check << std::endl << "core is: " << std::setprecision(16) << std::endl << core << std::endl; log_error( error.str() ); } return ok; } } //end vmml namespace vmmlib-1.0/tests/lapack_linear_least_squares_test.cpp0000644000175000017500000000237411674116154022635 0ustar shevekshevek#include "lapack_linear_least_squares_test.hpp" #include namespace vmml { bool lapack_linear_least_squares_test::run() { typedef vector< 3, float > vec3f; { bool ok = true; matrix< 3, 2, float > A; vector< 3, float > B; vector< 2, float > X; A( 0, 0 ) = 1; A( 0, 1 ) = 4; B( 0 ) = 7; A( 1, 0 ) = 2; A( 1, 1 ) = 5; B( 1 ) = 8; A( 2, 0 ) = 3; A( 2, 1 ) = 6; B( 2 ) = 9; vmml::lapack::linear_least_squares_xgels< 3, 2, float > llsq; try { llsq.compute( A, B, X ); if ( X( 0 ) - -1.0 < 1e-6 && X( 1 ) - 2.0 < 1e-6 ) ok = true; else ok = false; } catch(...) { ok = false; std::cout << llsq.get_params() << std::endl; } log( "linear least squares using lapack xGELS", ok ); if ( ! ok ) { std::cout << A << std::endl; std::cout << B << std::endl; std::cout << X << std::endl; } } return true; } } // namespace vmml vmmlib-1.0/tests/qr_decomposition_test.cpp0000644000175000017500000000610311674116154020465 0ustar shevekshevek#include "qr_decomposition_test.hpp" #include #include #include namespace vmml { bool qr_decomposition_test::run() { bool ok = true; // tests qr decomposition using modified gram-schmidt { matrix< 3, 3, double > A, Q, R; double Adata[] = { 12, -51, 4, 6, 167, -68, -4, 24, -41 }; A.set( Adata, Adata + 9 ); qr_decompose_gram_schmidt( A, Q, R ); double Qcorrect[] = { 6./7, -69./175, 58./175, 3./7, 158./175, -6./175, -2./7, 6./35, 33./35 }; double Rcorrect[] = { 14, 21, -14, 0, 175, -70, 0, 0, -35 }; matrix< 3, 3, double > Qc, Rc; Qc.set( Qcorrect, Qcorrect + 9 ); Rc.set( Rcorrect, Rcorrect + 9 ); for( size_t index = 0; ok && index < 3; ++index ) { vector< 3, double > q = Q.get_column( index ); vector< 3, double > qc = Qc.get_column( index ); ok = q == qc; if ( ! ok ) { q *= -1.0; ok = q == qc; } } for( size_t index = 0; ok && index < 3; ++index ) { vector< 3, double > r = R.get_row( index ); vector< 3, double > rc = Rc.get_row( index ); ok = r == rc; if ( ! ok ) { r *= -1.0; ok = r == rc; } } log( "QR decomposition using modified gram-schmidt, maximal precision", ok, true ); if ( ! ok ) { ok = true; double tolerance = 1e-9; for( size_t index = 0; ok && index < 3; ++index ) { vector< 3, double > q = Q.get_column( index ); vector< 3, double > qc = Qc.get_column( index ); ok = q.equals( qc, tolerance ); if ( ! ok ) { q *= -1.0; ok = q.equals( qc, tolerance ); } } for( size_t index = 0; ok && index < 3; ++index ) { vector< 3, double > r = R.get_row( index ); vector< 3, double > rc = Rc.get_row( index ); ok = r.equals( rc, tolerance ); if ( ! ok ) { r *= -1.0; ok = r.equals( rc ); } } log( "QR decomposition using modified gram-schmidt, tolerance 1e-9", ok ); if ( ! ok ) { std::stringstream error; error << " A " << A << std::endl; error << " Q " << Q << std::endl; error << " Qc " << Qc << std::endl; error << " diff " << Q - Qc << std::endl; error << " R " << R << std::endl; error << " Rc " << Rc << std::endl; error << " diff " << R - Rc << std::endl; std::cout << error.str() << std::endl; } } } return ok; } } // namespace vmml vmmlib-1.0/tests/tucker3_tensor_test.hpp0000644000175000017500000000063511674116154020072 0ustar shevekshevek#ifndef __VMML__TUCKER3_TENSOR_TEST__HPP__ #define __VMML__TUCKER3_TENSOR_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class tucker3_tensor_test : public unit_test { public: tucker3_tensor_test() : unit_test( "tucker3_tensor (R1xR2xR3) x (I1xR1) x (I2xR2) x (I3xR3)" ) {} bool run(); protected: }; // class tucker3_tensor_test } // namespace vmml #endif vmmlib-1.0/tests/matrix_compare_perf_test.hpp0000644000175000017500000000047711674116154021152 0ustar shevekshevek#ifndef __VMML__MATRIX_COMPARE_PERF_TEST__HPP__ #define __VMML__MATRIX_COMPARE_PERF_TEST__HPP__ #include "performance_test.hpp" namespace vmml { class matrix_compare_perf_test : public performance_test { public: virtual void run(); protected: }; // class matrix_compare_perf_test } // namespace vmml #endif vmmlib-1.0/tests/qtucker3_tensor_test.cpp0000644000175000017500000001356511674116154020254 0ustar shevekshevek#include "qtucker3_tensor_test.hpp" #include #include namespace vmml { bool qtucker3_tensor_test::run() { bool ok = false; double precision = 0.001; typedef double T_value; typedef double T_coeff; typedef tensor3< 3, 2, 2, T_value> t3_type; typedef matrix< 3, 2, T_coeff > u1_type; typedef matrix< 2, 2, T_coeff > u2_type; typedef matrix< 2, 1, T_coeff > u3_type; typedef tensor3< 2, 2, 1, T_coeff > core_type; typedef t3_hooi< 2, 2, 1, 3, 2, 2, float > hooi_type; typedef qtucker3_tensor< 2, 2, 1, 3, 2, 2, T_value, T_coeff > tuck3_type; //test data from lathauwer et al. 2000b paper (same test as in t3_hooi_test T_value data_als[] = { 0, 1, 2, 3, 4, 5, -1, 4, -2, -5, 3, -6 }; t3_type t3_data_als; t3_data_als.set( data_als, data_als + 12 ); T_coeff data_u1_hooi[] = { -0.2789474111071824, 0.4141266306147135, 0.5983607967045262, 0.7806355076145295, 0.7511009910815754, -0.4680890279285661 }; //original from paper (u1): {-0.2789, -0.4141, 0.5984, -0.7806, 0.7511, 0.4681}; u1_type u1_hooi_check; u1_hooi_check.set( data_u1_hooi, data_u1_hooi + 6); T_coeff data_u2_hooi[] = { 0.09816424894941811, 0.9951702267593202, 0.9951702267593202, -0.098164248949418 }; //original in paper (u2): 0.0982, -0.9952, 0.9952, 0.0982}; u2_type u2_hooi_check; u2_hooi_check.set( data_u2_hooi, data_u2_hooi + 4); T_coeff data_u3_hooi[] = {-0.5104644303570166, 0.8598988692516616};//original in paper (u3): {0.5105, -0.8599}; u3_type u3_hooi_check; u3_hooi_check.set( data_u3_hooi, data_u3_hooi + 2); T_coeff data_core_hooi[] = { -10.14733447424582, 0.0, 0.0, -2.760705584847321 }; core_type core_hooi_check; core_hooi_check.set( data_core_hooi, data_core_hooi + 4); //end fill test data u1_type u1_hooi; u1_hooi.zero(); u2_type u2_hooi; u2_hooi.zero(); u3_type u3_hooi; u3_hooi.zero(); core_type core_hooi; tuck3_type tuck3_hooi; tuck3_hooi.tucker_als( t3_data_als, hooi_type::init_hosvd() ); tuck3_hooi.get_u1( u1_hooi ); tuck3_hooi.get_u2( u2_hooi ); tuck3_hooi.get_u3( u3_hooi ); tuck3_hooi.get_core( core_hooi ); ok = u1_hooi.equals( u1_hooi_check, precision ); ok = ok && u2_hooi.equals( u2_hooi_check, precision ); ok = ok && u3_hooi.equals( u3_hooi_check, precision ); ok = ok && core_hooi.equals( core_hooi_check, precision); if ( ok ) { log( "Tucker ALS: rank-(2,2,1) approximation (same test as T3_HOOI)" , true ); } else { std::stringstream error; error << "Tucker ALS: rank-(2,2,1) approximation: " << std::setprecision(16) << std::endl << "U1 should be: " << std::endl << u1_hooi_check << std::endl << "U1 is: " << std::endl << u1_hooi << std::endl << "U2 should be: " << std::endl << u2_hooi_check << std::endl << "U2 is: " << std::endl << u2_hooi << std::endl << "U3 should be: " << std::endl << u3_hooi_check << std::endl << "U3 is: " << std::endl << u3_hooi << std::endl << "core should be: " << std::endl << core_hooi_check << std::endl << "core is: " << std::endl << core_hooi << std::endl; log_error( error.str() ); } //number of nonzeros size_t number_nonzeros = tuck3_hooi.nnz( ); size_t number_nonzeros2 = tuck3_hooi.nnz( 0.1 ); ok = ( number_nonzeros == 16 ) && (number_nonzeros2 == 12); log( "get number of nonzeros" , ok ); //quantization typedef unsigned char T_value_2; typedef unsigned short T_coeff_2; typedef tensor3< 3, 2, 2, T_value_2 > t3q_type; typedef qtucker3_tensor< 2, 2, 2, 3, 2, 2, T_value_2, T_coeff_2 > tuck3q_type; typedef t3_hooi< 2, 2, 2, 3, 2, 2, float > hooi_type1; //fill test data T_value_2 data_hooi_3[] = { 0, 13, 122, 123, 124, 95, 10, 40, 25, 54, 33, 76}; t3q_type t3_data_hooi_3; t3_data_hooi_3.set(data_hooi_3, data_hooi_3 + 12); t3q_type t3_data_hooi_3_reco; float u1_min, u1_max, u2_min, u2_max, u3_min, u3_max, core_min, core_max; tuck3q_type tuck3_hooi_3; tuck3_hooi_3.enable_quantify_linear(); tuck3_hooi_3.decompose( t3_data_hooi_3, u1_min, u1_max, u2_min, u2_max, u3_min, u3_max, core_min, core_max, hooi_type1::init_hosvd() ); tuck3_hooi_3.reconstruct( t3_data_hooi_3_reco, u1_min, u1_max, u2_min, u2_max, u3_min, u3_max, core_min, core_max ); double rmse = t3_data_hooi_3_reco.rmse( t3_data_hooi_3 ); double rmse_check = 5.392896562454479; float u_min, u_max; tuck3_hooi_3.decompose( t3_data_hooi_3, u_min, u_max, core_min, core_max, hooi_type1::init_hosvd() ); tuck3_hooi_3.reconstruct( t3_data_hooi_3_reco, u_min, u_max, core_min, core_max ); double rmse2 = t3_data_hooi_3_reco.rmse( t3_data_hooi_3 ); if ( (rmse == rmse_check) && (rmse != 0) && (rmse2 == rmse_check)) { log( "quantized Tucker ALS ank-(2,2,1) approximation" , true ); } else { std::stringstream error; error << "quantized Tucker ALS rank-(2,2,1) approximation: " << std::setprecision(16) << std::endl << "RMSE should be: " << rmse_check << ", is: " << rmse << std::endl << "Tucker3 is : " << std::endl << tuck3_hooi_3 << std::endl; log_error( error.str() ); } //tucker3 reconstruction typedef int T_value_3; typedef int T_coeff_3; typedef tensor3< 6, 7, 5, T_value_3 > t3r_type; typedef tensor3< 2, 3, 4, T_coeff_3 > t3r_core_type; typedef matrix< 6, 2, T_coeff_3 > u1r_type; typedef matrix< 7, 3, T_coeff_3 > u2r_type; typedef matrix< 5, 4, T_coeff_3 > u3r_type; typedef qtucker3_tensor< 2, 3, 4, 6, 7, 5, T_value_3, T_coeff_3 > tuck3r_type; t3r_core_type core; core.fill_increasing_values(); u1r_type u1; u1.fill(2); u2r_type u2; u2.fill(3); u3r_type u3; u3.fill(1); t3r_type t3_reco; tuck3r_type tuck3( core, u1, u2, u3 ); tuck3.reconstruct( t3_reco, 2, 2, 3, 3, 1, 1, 0, 23 ); t3r_type t3_reco_check; t3_reco_check.fill(1656); ok = t3_reco_check == t3_reco ; log( "tucker3 reconstruction", ok ); return ok; } } // namespace vmml vmmlib-1.0/tests/Makefile0000644000175000017500000000043011674116154015001 0ustar shevekshevek .PHONY: tests TESTFILES = $(wildcard *.cpp) OBJECTS = $(TESTFILES:%.cpp=%.o) CXXFLAGS += -I../include tests: vmmltest @echo "----- Running Tests -----" @./vmmltest vmmltest: $(OBJECTS) $(CXX) -o $@ $(OBJECTS) clean: rm -rf $(OBJECTS) vmmltest $(OBJECTS): ../include vmmlib-1.0/tests/frustum_test.hpp0000644000175000017500000000044011674116154016617 0ustar shevekshevek#ifndef __VMML__FRUSTUM_TEST__HPP__ #define __VMML__FRUSTUM_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class frustum_test : unit_test { public: frustum_test() : unit_test( "frustum" ) {} bool run(); protected: }; // class frustum_test } // namespace vmml #endif vmmlib-1.0/tests/cp3_tensor_test.cpp0000644000175000017500000000514011674116154017166 0ustar shevekshevek#include "cp3_tensor_test.hpp" #include #include #include namespace vmml { bool cp3_tensor_test::run() { bool ok = false; typedef tensor3< 4,4,4, float > t3_type; typedef cp3_tensor< 3, 4, 4, 4, float, float > cp3_dec_type; typedef t3_hopm< 3, 4, 4, 4, float > t3_hopm_type; t3_type t3_cp_input; float data_in_cp[] = { /* 0.3780, 0.3150, 0.3386, 0.2047, 0.2913, 0.3071, 0.2835, 0.1024, 0.2362, 0.2835, 0.2677, 0.1024, 0.3543, 1.1181, 1.5354, 0.3858, 0.2520, 0.2283, 0.3228, 0.2835, 0.2677, 0.2598, 0.2992, 0.2126, 0.2441, 0.2205, 0.2441, 0.2913, 0.9213, 0.6457, 0.4331, 0.1890, 0.4409, 0.4409, 0.5591, 0.5039, 0.2362, 0.4409, 0.5984, 0.6142, 0.2520, 0.2835, 0.3465, 0.3543, 0.5748, 0.2835, 0.2992, 0.2835, 0.3386, 0.3150, 0.4488, 0.4173, 0.2756, 0.3150, 0.3465, 0.3386, 0.2835, 0.2677, 0.2362, 0.2913, 0.2598, 0.2520, 0.2756, 0.3071 */ 0.8147, 0.6324, 0.9575, 0.9572, 0.9058, 0.0975, 0.9649, 0.4854, 0.1270, 0.2785, 0.1576, 0.8003, 0.9134, 0.5469, 0.9706, 0.1419, 0.4218, 0.6557, 0.6787, 0.6555, 0.9157, 0.0357, 0.7577, 0.1712, 0.7922, 0.8491, 0.7431, 0.7060, 0.9595, 0.9340, 0.3922, 0.0318, 0.2769, 0.6948, 0.4387, 0.1869, 0.0462, 0.3171, 0.3816, 0.4898, 0.0971, 0.9502, 0.7655, 0.4456, 0.8235, 0.0344, 0.7952, 0.6463, 0.7094, 0.6551, 0.9597, 0.7513, 0.7547, 0.1626, 0.3404, 0.2551, 0.2760, 0.1190, 0.5853, 0.5060, 0.6797, 0.4984, 0.2238, 0.6991 }; t3_cp_input.set(data_in_cp, data_in_cp + 64); cp3_dec_type cp3_dec; cp3_dec.decompose( t3_cp_input, t3_hopm_type::init_hosvd() ); t3_type t3_cp_reco; cp3_dec.reconstruct( t3_cp_reco ); t3_type t3_cp_reco_check; float data_out_cp[] = { 0.658735, 0.555868, 0.788278, 0.785259, 1.0863, 0.0696195, 0.878343, 0.328856, 0.204135, 0.525463, 0.463267, 0.777254, 1.02116, 0.651616, 0.848481, 0.161661, 0.744683, 0.569311, 0.851989, 0.790796, 0.858943, 0.169862, 0.734341, 0.338445, 0.441856, 0.487661, 0.623644, 0.772226, 0.706845, 0.750421, 0.656499, 0.211157, 0.371909, 0.81205, 0.513955, 0.468264, 0.144107, 0.359317, 0.24075, 0.291169, 0.254145, 0.824074, 0.388849, 0.334694, 0.813514, -0.0044108, 0.792204, 0.67506, 0.632346, 0.555974, 0.726074, 0.652605, 0.559222, 0.221787, 0.517159, 0.297763, 0.449981, 0.480387, 0.575679, 0.612093, 0.534163, 0.575728, 0.539401, 0.287718 }; t3_cp_reco_check.set(data_out_cp, data_out_cp + 64); ok = t3_cp_reco.equals( t3_cp_reco_check, 0.0001 ); log( "cp3 tensor reconstruction ", ok ); return ok; } } // namespace vmml vmmlib-1.0/tests/lapack_sym_eigs_test.hpp0000644000175000017500000000060711674116154020251 0ustar shevekshevek#ifndef __VMML__LAPACK_SYM_EIGS_TEST__HPP__ #define __VMML__LAPACK_SYM_EIGS_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class lapack_sym_eigs_test : public unit_test { public: lapack_sym_eigs_test() : unit_test( "symmetric eigenvalue decomposition using lapack" ) {} virtual bool run(); protected: }; // class lapack_sym_eigs_test } // namespace vmml #endif vmmlib-1.0/tests/lapack_gaussian_elimination_test.cpp0000644000175000017500000000306011674116154022623 0ustar shevekshevek#include "lapack_gaussian_elimination_test.hpp" #include namespace vmml { bool lapack_gaussian_elimination_test::run() { typedef vector< 3, float > vec3f; { bool ok = true; matrix< 3, 3, float > A; vector< 3, float > B; vector< 3, float > X; A( 0, 0 ) = 2; A( 0, 1 ) = 1; A( 0, 2 ) = -1; B( 0 ) = 8; A( 1, 0 ) = -3; A( 1, 1 ) = -1; A( 1, 2 ) = 2; B( 1 ) = -11; A( 2, 0 ) = -2; A( 2, 1 ) = 1; A( 2, 2 ) = 2; B( 2 ) = -3; vmml::lapack::gaussian_elimination< 1, 3, float > ge; try { X = B; ge.compute( A, X ); float epsilon = 1e-6; //std::cout << " X " << X << std::endl; if ( fabs( X( 0 ) - 2.0f ) < epsilon && fabs( X( 1 ) - 3.0f ) < epsilon && fabs( X( 2 ) - -1.0f ) < epsilon ) ok = true; else ok = false; } catch(...) { ok = false; std::cout << ge.get_params() << std::endl; } log( "gaussian elimination using lapack xGESV", ok ); if ( ! ok ) { std::cout << A << std::endl; std::cout << B << std::endl; std::cout << X << std::endl; } } return true; } } // namespace vmml vmmlib-1.0/tests/svd_test.hpp0000644000175000017500000000040611674116154015710 0ustar shevekshevek#ifndef _SVDTest_H_ #define _SVDTest_H_ #include #include "unit_test.hpp" namespace vmml { class svd_test : public unit_test { public: svd_test() : unit_test( "SVD, singular value decomposition" ) {} virtual bool run(); }; }; #endif vmmlib-1.0/tests/performance_test.hpp0000644000175000017500000000130711674116154017416 0ustar shevekshevek#ifndef __VMML__PERFORMANCE_TEST__HPP__ #define __VMML__PERFORMANCE_TEST__HPP__ #include "timer.hpp" #include #include namespace vmml { class performance_test { public: virtual void run() = 0; void new_test( const std::string& name ); void start( const std::string& name ); void stop(); void compare(); friend std::ostream& operator << ( std::ostream& os, const performance_test& performance_test_ ) { os << performance_test_._log.str(); return os; } protected: std::stringstream _log; timer _timer; std::vector< double > _last_times; }; // class performance_test } // namespace vmml #endif vmmlib-1.0/tests/matrix_pseudoinverse_test.hpp0000644000175000017500000000062611674116154021377 0ustar shevekshevek#ifndef __VMML__MATRIX_PSEUDOINVERSE_TEST__HPP__ #define __VMML__MATRIX_PSEUDOINVERSE_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class matrix_pseudoinverse_test : public unit_test { public: matrix_pseudoinverse_test() : unit_test( "matrix pseudoinverse test" ) {} bool run(); protected: }; // class matrix_pseudoinverse_test } // namespace vmml #endif vmmlib-1.0/tests/unit_test.hpp0000644000175000017500000000121511674116154016072 0ustar shevekshevek#ifndef __VMML__UNIT_TEST__HPP__ #define __VMML__UNIT_TEST__HPP__ #include #include namespace vmml { class unit_test { public: unit_test( const std::string& test_name ); virtual bool run() = 0; friend std::ostream& operator << ( std::ostream& os, const unit_test& unit_test_ ) { os << unit_test_._log; return os; } protected: virtual void log( const std::string& event, bool status_ok, bool warning_only = false ); virtual void log_error( const std::string& error_msg, bool warning_only = false ); std::string _log; double _tolerance; }; // class unit_test } // namespace vmml #endif vmmlib-1.0/tests/make_stringtests.sh0000644000175000017500000000007511674116154017270 0ustar shevekshevek#!/bin/sh g++ stringtests.cpp -o stringstests -I../include vmmlib-1.0/tests/tensor3_test.cpp0000644000175000017500000011300511674116154016504 0ustar shevekshevek#include "tensor3_test.hpp" #include #include namespace vmml { bool tensor3_test::run() { bool ok = false; tensor3< 2, 3, 4, int > t3; tensor3< 2, 3, 4, int > t3_tmp; //test size if (t3.size() == 24) { log( "size()", true ); } else { std::stringstream error; error << "size should be 24, but size is: " << t3.size() << std::endl; log_error( error.str() ); } //test at() //TODO t3.at( 0,0,0 ) = 255.0; t3( 0,2,0 ) = 128.0; ok = true; if (ok) { log( "at() ", true ); } else { std::stringstream error; error << "T3, 255 @ (0, 0, 0) and 128 @ (0, 2, 0): " << std::endl << t3 << std::endl; log_error( error.str() ); } //test set tensor from input int data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 }; t3.set(data, data + 24); ok = false; int check_value = 1; for ( size_t i3 = 0; i3 < 4; ++i3 ) { for( size_t i1 = 0; i1 < 2; ++i1 ) { for( size_t i2 = 0; i2 < 3 && ok; ++i2, ++check_value ) { if( t3.at(i1, i2, i3) != check_value) { std::stringstream error; error << "T3 set from input, values from 1... 24: " << std::endl << t3 << std::endl; log_error( error.str() ); ok = false; } else { ok = true; } } } } if (ok) { log( "set() ", true ); } //test fil() t3.fill( 4.0 ); ok = false; check_value = 4; for ( size_t i3 = 0; i3 < 4; ++i3 ) { for( size_t i1 = 0; i1 < 2; ++i1 ) { for( size_t i2 = 0; i2 < 3 && ok; ++i2 ) { if( t3.at(i1, i2, i3) != check_value ) { std::stringstream error; error << "T3 with all values to 4: " << std::endl << t3 << std::endl; log_error( error.str() ); ok = false; } else { ok = true; } } } } if(ok) { log( "fill()", true ); } //operations tensor3< 2, 3, 4, int > t3_2; tensor3< 2, 3, 4, int > t3_3; tensor3< 2, 3, 4, int > t3_result; t3.fill( 2 ); t3_2.fill( 5 ); t3_3.fill( 5 ); //test equals operator if ( !(t3==t3_2) && (t3_2==t3_3) && t3 != t3_2 && !(t3_2!=t3_3)) { log( "operator== and operator!= ", true ); } else { std::stringstream error; error << "T3: " << std::endl << t3 << "T3_2: " << std::endl << t3_2 << "T3_3: " << std::endl << t3_3 << std::endl; log_error( error.str() ); } //test sum with other t3 t3_result = t3 + t3_2; t3_3.fill( 7 ); if ( t3_result == t3_3) { log( "operator+ and operator += with other tensor3", true ); } else { std::stringstream error; error << "T3_result: " << std::endl << t3_result << "T3_3: " << std::endl << t3_3 << std::endl; log_error( error.str() ); } //test subtraction t3_result = t3_2 - t3; t3_3.fill( 3 ); if ( t3_result == t3_3) { log( "operator- and operator -= with other tensor3 ", true ); } else { std::stringstream error; error << "T3_result: " << std::endl << t3_result << "T3_3: " << std::endl << t3_3 << std::endl; log_error( error.str() ); } //test sum with scalar (shift) t3_result = t3 + 4; t3_3.fill( 6 ); if ( t3_result == t3_3) { log( "operator+ and operator += with scalar", true ); } else { std::stringstream error; error << "T3_result: " << std::endl << t3_result << "T3_3: " << std::endl << t3_3 << std::endl; log_error( error.str() ); } //test subtraction with scalar (negative shift) t3_result = t3 - 2; t3_3.zero(); if ( t3_result == t3_3 ) { log( "operator- and operator -= with scalar", true ); } else { std::stringstream error; error << "T3_result: " << std::endl << t3_result << "T3_3: " << std::endl << t3_3 << std::endl; log_error( error.str() ); } //test spherical weighting tensor3< 3,3,3, double > t3_result_sw_check; double data_sw[] = { 0.176921194126, 0.243116716007, 0.176921194126, 0.243116716007, 0.367879404384, 0.243116716007, 0.176921194126, 0.243116716007, 0.176921194126, 0.243116716007, 0.367879404384, 0.243116716007, 0.367879404384, 0.9999999, 0.367879404384, 0.243116716007, 0.367879404384, 0.243116716007, 0.176921194126, 0.243116716007, 0.176921194126, 0.243116716007, 0.367879404384, 0.243116716007, 0.176921194126, 0.243116716007, 0.176921194126}; t3_result_sw_check.set(data_sw, data_sw + 27); tensor3< 3,3,3, unsigned int > t3_sw; tensor3< 3,3,3, double > t3_result_sw; t3_sw.fill( 1 ); t3_sw.apply_spherical_weights( t3_result_sw ); double precision = 1.0e-5; if ( t3_result_sw.equals( t3_result_sw_check, precision ) ) { log( "apply spherical weights", true ); } else { std::stringstream error; error << "Apply spherical weights " << std::setprecision(12) << "is: " << std::endl << t3_result_sw << "should be: " << std::endl << t3_result_sw_check << std::endl; log_error( error.str() ); } //test fill increasing values t3.fill_increasing_values(); ok = false; check_value = 0; for ( size_t i3 = 0; i3 < 4; ++i3 ) { for( size_t i1 = 0; i1 < 2; ++i1 ) { for( size_t i2 = 0; i2 < 3 && ok; ++i2, ++check_value ) { if( t3.at(i1, i2, i3) != check_value) { std::stringstream error; error << "T3 with all values from 0 to 23:: " << std::endl << t3 << std::endl; log_error( error.str() ); ok = false; } else { ok = true; } } } } if (ok) { log( "fill_increasing_values()", true ); } //test zero() t3.zero(); ok = false; check_value = 0; for ( size_t i3 = 0; i3 < 4; ++i3 ) { for( size_t i1 = 0; i1 < 2; ++i1 ) { for( size_t i2 = 0; i2 < 3 && ok; ++i2 ) { if( t3.at(i1, i2, i3) != check_value ) { std::stringstream error; error << "T3 with all values to 0: " << std::endl << t3 << std::endl; log_error( error.str() ); ok = false; } else { ok = true; } } } } if(ok) { log( "zero()", true ); } //test fill_random and fill_random_signed -> not checked, since every time new values -> cannot be tested with values t3.fill_random(); tensor3< 2, 3, 4, int16_t > t3s; t3s.fill_random_signed(); //test get_n_vector functions int i1 = 1; int i2 = 2; int i3 = 3; t3.fill_increasing_values(); t3 += 1; vmml::vector< 3, int > test_I2_data ; vmml::vector< 3, int > I2_data ; t3.get_row( i1, i3, I2_data ); test_I2_data.set(22, 23, 24); vmml::vector< 2, int > test_I1_data ; vmml::vector< 2, int > I1_data ; t3.get_column( i2, i3, I1_data ); test_I1_data.set(21, 24); vmml::vector< 4, int > test_I3_data ; vmml::vector< 4, int > I3_data ; t3.get_I3_vector( i1, i2, I3_data ); test_I3_data.set( 6, 12, 18, 24); if (I2_data == test_I2_data && I1_data == test_I1_data && I3_data == test_I3_data) { log( "get_n_vector/get_row/get_column/get_tube()", true ); } else { std::stringstream error; error << "I2_vector (22, 23, 24): " << I2_data << std::endl << "I1_vector (21, 24): " << I1_data << std::endl << "I3_vector (6, 12, 18, 24): " << I3_data << std::endl; log_error( error.str() ); } I2_data.set( 1 ); test_I2_data.set( 1, 1, 1 ); t3.set_row( i1, i3, I2_data ); vmml::vector< 3, int > I2_data_2 ; t3.get_row( i1, i3, I2_data_2 ); I1_data.set( 2 ); test_I1_data.set( 2, 2 ); t3.set_column( i2, i3, I1_data ); vmml::vector< 2, int > I1_data_2 ; t3.get_column( i2, i3, I1_data_2 ); I3_data.set( 3 ); test_I3_data.set( 3, 3, 3, 3 ); t3.set_tube( i1, i2, I3_data ); vmml::vector< 4, int > I3_data_2 ; t3.get_tube( i1, i2, I3_data_2 ); if (I2_data_2 == test_I2_data && I1_data_2 == test_I1_data && I3_data_2 == test_I3_data) { log( "set_n_vector/set_row/set_column/set_tube()", true ); } else { std::stringstream error; error << "I2_vector (1, 1, 1): " << I2_data << std::endl << "I1_vector (2, 2): " << I1_data << std::endl << "I3_vector (3, 3, 3, 3): " << I3_data << std::endl; log_error( error.str() ); } //test get_slice() functions //frontal slice matrix< 2, 3, int > mat_frontal; matrix< 2, 3, int > test_mat_frontal; int data2[] = { 13, 14, 15, 16, 17, 3 }; test_mat_frontal.set(data2, data2 + 6); t3.get_frontal_slice_fwd( 2, mat_frontal ); matrix< 2, 3, int > mat_frontal_2; matrix< 2, 3, int > test_mat_frontal_2; test_mat_frontal_2.fill(7); t3.set_frontal_slice_fwd( 2, test_mat_frontal_2); t3.get_frontal_slice_fwd( 2, mat_frontal_2); if (mat_frontal == test_mat_frontal && mat_frontal_2 == test_mat_frontal_2) { log( "get/set_frontal_slice_fwd() (I2xI1)", true ); } else { std::stringstream error; error << "after get_frontal_slice_fwd at i3 = 2: " << mat_frontal << std::endl << "after set_frontal_slice_fwd after i3 = 2: " << mat_frontal_2 << std::endl; log_error( error.str() ); } t3.set_frontal_slice_fwd( 2, test_mat_frontal); matrix< 3, 2, int > mat_frontal_bwd = transpose( mat_frontal ); matrix< 3, 2, int > test_mat_frontal_bwd = transpose( test_mat_frontal ); t3.get_frontal_slice_bwd( 2, mat_frontal_bwd ); matrix< 3, 2, int > mat_frontal_2_bwd = transpose ( mat_frontal );; matrix< 3, 2, int > test_mat_frontal_2_bwd = transpose( test_mat_frontal_2 ); t3.set_frontal_slice_bwd( 2, test_mat_frontal_2_bwd); t3.get_frontal_slice_bwd( 2, mat_frontal_2_bwd); if (mat_frontal_bwd == test_mat_frontal_bwd && mat_frontal_2_bwd == test_mat_frontal_2_bwd) { log( "get/set_frontal_slice_bwd() (I1xI2)", true ); } else { std::stringstream error; error << "after get_frontal_slice_bwd at i3 = 2 is: " << mat_frontal_bwd << std::endl << "after get_frontal_slice_bwd at i3 = 2 should be: " << test_mat_frontal_bwd << std::endl << "after set_frontal_slice_bwd after i3 = 2 is: " << mat_frontal_2_bwd << std::endl << "after set_frontal_slice_bwd after i3 = 2 should be: " << test_mat_frontal_2_bwd << std::endl; log_error( error.str() ); } //lateral slice matrix< 2, 4, int > mat_lateral; matrix< 2, 4, int > test_mat_lateral; int data3[] = { 1, 7, 7, 19, 4, 10, 7, 1 }; test_mat_lateral.set(data3, data3 + 8); t3.get_lateral_slice_bwd( 0, mat_lateral ); matrix< 2, 4, int > mat_lateral_2; matrix< 2, 4, int > test_mat_lateral_2; test_mat_lateral_2.fill(6); t3.set_lateral_slice_bwd( 0, test_mat_lateral_2 ); t3.get_lateral_slice_bwd( 0, mat_lateral_2 ); if (mat_lateral == test_mat_lateral && mat_lateral_2 == test_mat_lateral_2) { log( "get/set_lateral_slice_bwd() (I1xI3)", true ); } else { std::stringstream error; error << "after get_lateral_slice_bwd i2 = 0: " << mat_lateral << std::endl << "after set_lateral_slice_bwd i2 = 0: " << mat_lateral_2 << std::endl; log_error( error.str() ); } t3.set_lateral_slice_bwd( 0, test_mat_lateral ); matrix< 4, 2, int > mat_lateral_fwd = transpose( mat_lateral ); matrix< 4, 2, int > test_mat_lateral_fwd = transpose( test_mat_lateral ); t3.get_lateral_slice_fwd( 0, mat_lateral_fwd ); matrix< 4, 2, int > mat_lateral_2_fwd = transpose( mat_lateral_2 ); matrix< 4, 2, int > test_mat_lateral_2_fwd = transpose( test_mat_lateral_2 ); t3.set_lateral_slice_fwd( 0, test_mat_lateral_2_fwd ); t3.get_lateral_slice_fwd( 0, mat_lateral_2_fwd ); if (mat_lateral_fwd == test_mat_lateral_fwd && mat_lateral_2_fwd == test_mat_lateral_2_fwd) { log( "get/set_lateral_slice_fwd() (I3xI1)", true ); } else { std::stringstream error; error << "after get_lateral_slice_fwd i2 = 0 is: " << mat_lateral_fwd << std::endl << "after get_lateral_slice_fwd i2 = 0 should be: " << test_mat_lateral_fwd << std::endl << "after set_lateral_slice_fwd i2 = 0 is: " << mat_lateral_2_fwd << std::endl << "after set_lateral_slice_fwd i2 = 0 should be: " << test_mat_lateral_2_fwd << std::endl; log_error( error.str() ); } //horizontal slice matrix< 3, 4, int > mat_horizontal; matrix< 3, 4, int > test_mat_horizontal; //int data4[] = { 6, 5, 3, 6, 11, 3, 6, 7, 7, 6, 1, 3 }; int data4[] = { 6, 6, 6, 6, 5, 11, 7, 1, 3, 3, 7, 3 }; test_mat_horizontal.set(data4, data4 + 12); t3.get_horizontal_slice_fwd( 1, mat_horizontal ); matrix< 3, 4, int > mat_horizontal_2; matrix< 3, 4, int > test_mat_horizontal_2; test_mat_lateral_2.fill(5); t3.set_horizontal_slice_fwd( 1, test_mat_horizontal_2 ); t3.get_horizontal_slice_fwd( 1, mat_horizontal_2 ); if (mat_horizontal == test_mat_horizontal && mat_horizontal_2 == test_mat_horizontal_2 ) { log( "get/set_horizontal_slice_fwd() (I2xI3)", true ); } else { std::stringstream error; error << "after get_horizontal_slice_fwd at i1 = 0: " << mat_horizontal << std::endl << "after set_horizontal_slice_fwd at i1 = 0: " << mat_horizontal_2 << std::endl; log_error( error.str() ); } t3.get_horizontal_slice_fwd( 1, test_mat_horizontal ); matrix< 4, 3, int > mat_horizontal_bwd = transpose( mat_horizontal ); matrix< 4, 3, int > test_mat_horizontal_bwd = transpose( test_mat_horizontal ); t3.get_horizontal_slice_bwd( 1, mat_horizontal_bwd ); matrix< 4, 3, int > mat_horizontal_2_bwd = transpose( mat_horizontal_2 ); matrix< 4, 3, int > test_mat_horizontal_2_bwd = transpose( test_mat_horizontal_2 ); t3.set_horizontal_slice_bwd( 1, test_mat_horizontal_2_bwd ); t3.get_horizontal_slice_bwd( 1, mat_horizontal_2_bwd ); if (mat_horizontal_bwd == test_mat_horizontal_bwd && mat_horizontal_2_bwd == test_mat_horizontal_2_bwd ) { log( "get/set_horizontal_slice_bwd() (I3xI2)", true ); } else { std::stringstream error; error << "after get_horizontal_slice_bwd at i1 = 0 is: " << mat_horizontal_bwd << std::endl << "after get_horizontal_slice_bwd at i1 = 0 should be: " << test_mat_horizontal_bwd << std::endl << "after set_horizontal_slice_bwd at i1 = 0 is: " << mat_horizontal_2_bwd << std::endl << "after set_horizontal_slice_bwd at i1 = 0 should be: " << test_mat_horizontal_2_bwd << std::endl; log_error( error.str() ); } //test tensor3 matrix multiplication t3.fill_increasing_values(); matrix<5, 4, int> u3; u3.fill(1); tensor3<2, 3, 5, int> t3_jji; t3_jji.multiply_horizontal_bwd(t3, u3 ); tensor3<6, 3, 5, int> t3_iji; matrix<6, 2, int> u1; u1.fill(2); t3_iji.multiply_lateral_bwd(t3_jji, u1 ); tensor3<6, 7, 5, int> t3_iii; matrix<7, 3, int> u2; u2.fill(3); t3_iii.multiply_frontal_bwd(t3_iji, u2 ); t3.fill_increasing_values(); tensor3<6, 7, 5, int> t3_reco; t3_reco.full_tensor3_matrix_multiplication( t3, u1, u2, u3 ); tensor3<6, 7, 5, int> t3_reco2; t3_reco2.full_tensor3_matrix_kronecker_mult( t3, u1, u2, u3 ); ok = t3_reco == t3_reco2; tensor3<6, 7, 5, int> t3_iii_test; t3_iii_test.fill(1656); if ( t3_iii_test == t3_reco && t3_iii_test == t3_iii && ok ) { log( "tensor3 matrix multiplication along all three modes", true ); } else { std::stringstream error; error << "T3_result (all values should be 1656): " << std::endl << t3_iii << std::endl; log_error( error.str() ); } //CP reconstruction tensor3< 4,4,4, double > t3_cp_input; double data_in_cp[] = { 0.3780, 0.3150, 0.3386, 0.2047, 0.2913, 0.3071, 0.2835, 0.1024, 0.2362, 0.2835, 0.2677, 0.1024, 0.3543, 1.1181, 1.5354, 0.3858, 0.2520, 0.2283, 0.3228, 0.2835, 0.2677, 0.2598, 0.2992, 0.2126, 0.2441, 0.2205, 0.2441, 0.2913, 0.9213, 0.6457, 0.4331, 0.1890, 0.4409, 0.4409, 0.5591, 0.5039, 0.2362, 0.4409, 0.5984, 0.6142, 0.2520, 0.2835, 0.3465, 0.3543, 0.5748, 0.2835, 0.2992, 0.2835, 0.3386, 0.3150, 0.4488, 0.4173, 0.2756, 0.3150, 0.3465, 0.3386, 0.2835, 0.2677, 0.2362, 0.2913, 0.2598, 0.2520, 0.2756, 0.3071 }; t3_cp_input.set(data_in_cp, data_in_cp + 64); vector< 4, double> lambda; lambda.at(0) = 3.4996; lambda.at(1) = 1.6186; lambda.at(2) = 1.0947; lambda.at(3) = 0.80494; double data_u1_cp[] = { 0.414514672613941, -0.273871195562966, 0.622972704020820, -0.106663870725802, 0.373815968628613, -0.303860590002700, 0.583235093038218, 0.038436291238145, 0.307288348024630, -0.134400219672316, 0.462215931211866, -0.019751415378651, 0.770722439633298, 0.902551877199397, 0.241035825610295, 0.993355601880911}; matrix< 4, 4, double > u1_cp; u1_cp.set( data_u1_cp, data_u1_cp + 16); double data_u2_cp[] = { 0.363947543028453, 0.298190617522100, 0.309440303599311, 0.906460391523818, 0.582584049017999, -0.442905614843157, -0.385671235746994, 0.178817966899174, 0.700932982871312, -0.827455897125261, -0.577509589347220, -0.345891330880255, 0.191913952792576, -0.173878435335793, 0.649605319126744, -0.163440755426602 }; matrix< 4, 4, double > u2_cp; u2_cp.set( data_u2_cp, data_u2_cp + 16); double data_u3_cp[] = { 0.528860463703445, -0.453374574314148, 0.081548921839262, 0.026850375225737, 0.421141692804753, 0.103741153724736, 0.379185048676421, 0.600983237030590, 0.588063451217321, 0.731736212173060, 0.724001032600722, -0.545272439076217, 0.443990610098116, 0.498248315786364, 0.570430518994385, -0.583760373220334}; matrix< 4, 4, double > u3_cp; u3_cp.set( data_u3_cp, data_u3_cp + 16); tensor3< 4,4,4, double > t3_cp_reco_check; double data_out_cp[] = { 0.354263061197741, 0.336071353932582, 0.340120155317465, 0.148789058227363, 0.335156282115524, 0.284369809600727, 0.270075906182746, 0.127689570299207, 0.248778281916907, 0.271657788743462, 0.293346312353042, 0.118870461584074, 0.347767704804178, 1.119919940137974, 1.528048459613556, 0.399390301753092, 0.241873571540868, 0.267325817660143, 0.334780629072782, 0.301651586726927, 0.277064331887503, 0.253524404359242, 0.282150329524853, 0.268828551075853, 0.208805038309086, 0.198138779535580, 0.228624285742602, 0.217032724171575, 0.925152576629409, 0.641979031363691, 0.446794524932619, 0.178096907232692, 0.408959960261278, 0.458603477148098, 0.565021279854640, 0.533195254992912, 0.300410894904167, 0.426297991808946, 0.575920757418752, 0.513247731493541, 0.303903577435438, 0.299195909145241, 0.360430286717156, 0.385593403984964, 0.559935740903585, 0.298948990808052, 0.267704058359116, 0.313877703199338, 0.334349191835064, 0.331983603647059, 0.392220714079066, 0.406517347684063, 0.234640418580267, 0.303232696231040, 0.405821982955168, 0.393611395358567, 0.239172809919676, 0.216514108351268, 0.254464520462408, 0.296451592996035, 0.276358969906296, 0.233761715518065, 0.311620024949421, 0.277319482627673 }; t3_cp_reco_check.set(data_out_cp, data_out_cp + 64); matrix< 4, 4, double > v1; matrix< 4, 4, double > v2; matrix< 4, 4, double > v3; u1_cp.transpose_to( v1 ); u2_cp.transpose_to( v2 ); u3_cp.transpose_to( v3 ); tensor3< 4, 4, 4, double > t3_cp_reco; matrix< 4, 16, double > temp; t3_cp_reco.reconstruct_CP( lambda, v1, v2, v3, temp); precision = 1.0e-4; if ( t3_cp_reco.equals( t3_cp_reco_check, precision) ) { log( "tensor3 CP reconstruction", true ); } else { std::stringstream error; error << "tensor3 CP reconstruction: is " << std::endl << t3_cp_reco << std::endl << "should be: " << t3_cp_reco_check << std::endl; log_error( error.str() ); } //innerproduct between a tensor and a cp decomposition double innerp = t3_cp_input.tensor_inner_product( lambda, u1_cp, u2_cp, u3_cp); double innerp_check = 11.5230085; if ( (innerp - innerp_check) < precision ) { log( "tensor3 inner product t3 and cp of t3", true ); } else { std::stringstream error; error << "tensor3 inner product t3 and cp of t3: is " << std::endl << innerp << std::endl << "should be: " << innerp_check << std::endl; log_error( error.str() ); } //unfolding //matrix< I3, I1*I2, T> m_horizontal; //matrix< I1, I2*I3, T> m_lateral; //matrix< I2, I1*I3, T> m_frontal; matrix< 4, 6, int> m_horizontal; matrix< 2, 12, int> m_lateral; matrix< 3, 8, int> m_frontal; t3.horizontal_unfolding_bwd( m_horizontal); t3.lateral_unfolding_bwd( m_lateral); t3.frontal_unfolding_bwd( m_frontal); matrix< 4, 6, int> m_horizontal_test; int data5[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 }; m_horizontal_test.set(data5, data5 + 24); matrix< 2, 12, int> m_lateral_test; int data6[] = { 0, 6, 12, 18, 1, 7, 13, 19, 2, 8, 14, 20, 3, 9, 15, 21, 4, 10, 16, 22, 5, 11, 17, 23 }; m_lateral_test.set(data6, data6 + 24); matrix< 3, 8, int> m_frontal_test; int data7[] = { 0, 3, 6, 9, 12, 15, 18, 21, 1, 4, 7, 10, 13, 16, 19, 22, 2, 5, 8, 11, 14, 17, 20, 23 }; m_frontal_test.set(data7, data7 + 24); if ( m_horizontal_test == m_horizontal && m_lateral_test == m_lateral && m_frontal_test == m_frontal ) { log( "backward unfolding along all modes", true ); } else { std::stringstream error; error << "backward unfolding: " << std::endl << "unfolding_horizontal should be: " << std::endl << m_horizontal_test << std::endl << "unfolding_horizontal is: " << std::endl << m_horizontal << std::endl << "unfolding_lateral should be: " << std::endl << m_lateral_test << std::endl << "unfolding_lateral is: " << std::endl << m_lateral << std::endl << "unfolding_frontal should be: " << std::endl << m_frontal_test << std::endl << "unfolding_frontal is: " << std::endl << m_frontal << std::endl << std::endl; log_error( error.str() ); } //compute frobenius norm of a tensor3 double f_norm_check = 65.75712889109438; t3.fill_increasing_values(); double f_norm = t3.frobenius_norm(); ok = f_norm == f_norm_check; //compute frobenius norm of the difference of a tensor3 and another tensor3 f_norm_check = 10; t3.fill_increasing_values(); t3_tmp.fill_increasing_values(); t3_tmp.at(1,1,1) = 0; f_norm = t3.frobenius_norm( t3_tmp ); ok = (f_norm == f_norm_check ) && ok; if ( ok ) { log( "compute frobenius norm", true ); } else { std::stringstream error; error << "compute frobenius norm: should be: " << f_norm_check << " is: " << f_norm << std::endl; log_error( error.str() ); } //compute rmse between two tensor3 double rmse_check = 2.041241452319315; t3.fill_increasing_values(); t3_tmp.fill_increasing_values(); t3_tmp.at(1,1,1) = 0; double rmse = t3.rmse( t3_tmp ); ok = rmse == rmse_check; //psnr double psnr_check = 48.43872076218154; double psnr = t3.compute_psnr( t3_tmp, t3.get_max() ); ok = ok && (psnr == psnr_check ); //avg. frob. norm difference double afn_check = 13.42261772780059; double afn = t3.avg_frobenius_norm(); ok = ok && ( afn == afn_check ); if ( ok ) { log( "compute RMSE, PSNR, averaged frob.norm difference ", ok ); } else { std::stringstream error; error << "compute RMSE: should be: " << rmse_check << " is: " << std::setprecision(16) << rmse << std::endl << "compute PSNR: should be: " << psnr_check << " is: " << std::setprecision(16) << psnr << std::endl //<< "compute frob.norm is: " << t3.frobenius_norm(); << ", size() " << t3.size() << std::endl << "compute avg.frob.norm : should be: " << afn_check << " is: " << std::setprecision(16) << afn << std::endl; log_error( error.str() ); } //set diagonal values in a cubic tensor3, i.e., R=I1, R=I2, R=I3 tensor3< 3, 3, 3, int > t3_diag; tensor3< 3, 3, 3, int > t3_diag_check; t3_diag_check.zero(); t3_diag_check.at(1, 1, 1) = 1; t3_diag_check.at(2, 2, 2) = 2; vector< 3, int > diag_values; diag_values.at(0) = 0; diag_values.at(1) = 1; diag_values.at(2) = 2; t3_diag.diag( diag_values ); if ( t3_diag == t3_diag_check ) { log( "fill diagonal values", true ); } else { std::stringstream error; error << "fill diagonal values: should be: " << std::endl << t3_diag_check << std::endl << " is: " << std::endl << t3_diag << std::endl; log_error( error.str() ); } { //tensor3 type cast tensor3< 2, 3, 4, double > t3_type_a; tensor3< 2, 3, 4, int > t3_type_b; tensor3< 2, 3, 4, int > t3_type_b_check; t3_type_a.fill(2.4); t3_type_b_check.fill(2); t3_type_b.cast_from( t3_type_a ); if (t3_type_b_check == t3_type_b ) { log( "type cast ", true ); } else { std::stringstream error; error << "type cast - tensor3 type double: " << std::endl << t3_type_a << std::endl << " tensor3 type int should be: " << std::endl << t3_type_b_check << std::endl << " is: " << t3_type_b << std::endl; log_error( error.str() ); } } { //tensor3: from float_t to uint_t tensor3< 2, 3, 4, double > t3_type_a; tensor3< 2, 3, 4, unsigned char > t3_type_b; tensor3< 2, 3, 4, unsigned char > t3_type_b_check; t3_type_a.fill(2.4); t3_type_a.at(0,0,0) = 2.67; t3_type_a.at(0,2,0) = 2.67; t3_type_b_check.fill(2); t3_type_b_check.at(0,0,0) = 3; t3_type_b_check.at(0,2,0) = 3; t3_type_b.float_t_to_uint_t( t3_type_a ); if (t3_type_b_check == t3_type_b ) { log( "from float_t to uint_t ", true ); } else { std::stringstream error; error << "from float_t to uint_t - tensor3 type double: " << std::endl << t3_type_a << std::endl << " tensor3 type int should be: " << std::endl << t3_type_b_check << std::endl << " is: " << t3_type_b << std::endl; log_error( error.str() ); } } //export tensor3< 2, 3, 4, double > t3_export_import; t3_export_import.fill_increasing_values(); std::vector< double > export_data; t3_export_import.export_to( export_data ); double export_data_check[] = { 0, 3, 1, 4, 2, 5, 6, 9, 7, 10, 8, 11, 12, 15, 13, 16, 14, 17, 18, 21, 19, 22, 20, 23 }; precision = 1.0e-1; ok = true; for (int i = 0; i < 24 && ok; ++i ) { ok = (abs(export_data_check[i]) - abs(export_data[i])) < precision; } log( "export tensor3", ok ); //import tucker3 from vector std::vector< double > in_data = export_data; tensor3< 2, 3, 4, double > t3_import_check; t3_import_check.fill_increasing_values(); t3_export_import.zero(); t3_export_import.import_from( in_data ); if ( t3_export_import.equals( t3_import_check, precision ) ) { log( "import tensor3" , true ); } else { std::stringstream error; error << "import tensor3: " << std::endl << "import tensor3 should be: " << std::endl << t3_import_check << std::endl << "is: " << std::endl << t3_export_import << std::endl; log_error( error.str() ); } //get_min() + get_max() tensor3< 3, 2, 5, int > t3_get_min_max; t3_get_min_max.fill_increasing_values(); int t3_min = t3_get_min_max.get_min(); int t3_max = t3_get_min_max.get_max(); if ( (t3_min == 0) && (t3_max == 29) ) { log( "get min/max" , true ); } else { std::stringstream error; error << "get min/max: " << std::endl << "min should be: " << std::endl << 0 << " is: " << t3_min << std::endl << "max should be: " << std::endl << 29 << " is: " << t3_max << std::endl; log_error( error.str() ); } //quantize { tensor3< 2, 4, 3, float > t3_raw; t3_raw.fill(0.45692); t3_raw.at( 0,2,2) = 0.67777; t3_raw.at(1,0,1) = 0.111111; t3_raw.at(1,2,0) = -0.23; t3_raw.at(1,3,0) = -0.99; t3_raw.at(1,0,0) = -0.8; t3_raw.at(1,2,1) = 0.0; t3_raw.at(0,3,2) = 0.99; t3_raw.at(0,1,0) = 0.23; tensor3< 2, 4, 3, unsigned char > t3_quant; t3_quant.zero(); tensor3< 2, 4, 3, unsigned char > t3_quant_check; int data_unsigned[] = {186, 157, 186, 186, 24, 186, 98, 0, 186, 186, 186, 186, 142, 186, 128, 186, 186, 186, 215, 255, 186, 186, 186, 186}; t3_quant_check.set(data_unsigned, data_unsigned+24); float min_value = 50; float max_value = -50; t3_raw.quantize( t3_quant, min_value, max_value ); tensor3< 2, 4, 3, char > t3_quant_sign; t3_quant_sign.zero(); tensor3< 2, 4, 3, char > t3_quant_sign_check; int data_signed[] = { 59, 30, 59, 59, -102, 59, -29, -127, 59, 59, 59, 59, 14, 59, 0, 59, 59, 59, 87, 127, 59, 59, 59, 59 }; t3_quant_sign_check.set(data_signed, data_signed +24 ); t3_raw.quantize( t3_quant_sign, min_value, max_value ); //dequantize tensor3< 2, 4, 3, float > t3_dequant; tensor3< 2, 4, 3, float > t3_dequant_sign; t3_quant.dequantize( t3_dequant, min_value, max_value ); t3_quant_sign.dequantize( t3_dequant_sign, min_value, max_value ); ok = ( t3_quant_check == t3_quant ) && ( t3_quant_sign_check == t3_quant_sign ) && t3_dequant.equals(t3_dequant_sign, 0.01); #if 0 std::cout << " quantization: is " << ok << std::endl << "original: " << t3_raw << std::endl << "linear: " << t3_quant << std::endl << "linear signed: " << t3_quant_sign << std::endl << "deq. from linear: " << std::endl << t3_dequant << std::endl; #endif //logarithmic quantization float lmin_value = 50; float lmax_value = -50; tensor3< 2, 4, 3, unsigned char > t3_quant_log; t3_quant.zero(); tensor3< 2, 4, 3, float > t3_raw2(t3_raw); t3_raw2.at(0,2,1) = 200; tensor3< 2, 4, 3, unsigned char > t3_quant2; t3_quant2.zero(); t3_raw2.quantize( t3_quant2, lmin_value, lmax_value ); tensor3< 2, 4, 3, float > t3_dequant2; t3_quant2.dequantize( t3_dequant2, lmin_value, lmax_value ); unsigned char tt_range = 127; tensor3< 2, 4, 3, char > signs; t3_raw2.quantize_log( t3_quant_log, signs, lmin_value, lmax_value, tt_range ); tensor3< 2, 4, 3, float > t3_dequant_log; t3_quant_log.dequantize_log( t3_dequant_log, signs, lmin_value, lmax_value ); float deq_log_check[] = { 0.456192, 0.232188, 0.456192, 0.456192, -0.794302, 0.456192, -0.232188, -0.950592, 0.456192, 0.456192, 200, 0.456192, 0.13346, 0.456192, 0, 0.456192, 0.456192, 0.456192, 0.650535, 0.950592, 0.456192, 0.456192, 0.456192, 0.456192 }; tensor3< 2, 4, 3, float > t3_dequant_log_check; t3_dequant_log_check.set(deq_log_check, deq_log_check +24 ); ok = ok && t3_dequant_log_check.equals( t3_dequant_log, 0.001 ); #if 0 std::cout << " quantization: is " << ok << std::endl << "original: " << t3_raw2 << std::endl << "linear: " << t3_quant2 << std::endl << "log-scale: " << std::endl << t3_quant_log << std::endl << "signs (0 = neg, 1 = pos): " << std::endl << signs << std::endl << "deq. from log-scale: " << std::endl << t3_dequant_log << std::endl << "deq. from linear: " << std::endl << t3_dequant2 << std::endl; #endif if ( ok ) { log( "quantize/dequantize" , ok ); } else { std::stringstream error; error << "quantize/dequantize " << std::endl << "raw is: " << std::endl << t3_raw << std::endl << "unsigned quantized is: " << std::endl << t3_quant << std::endl << "signed quantized is: " << std::endl << t3_quant_sign << std::endl << "dequantized unsigned is: " << std::endl << t3_dequant << std::endl << "dequantized signed is: " << std::endl << t3_dequant_sign << std::endl << "min_value: " << min_value << " max_value: " << max_value << std::endl; log_error( error.str() ); } } { //number of nonzeros tensor3< 4, 5, 6, int > t3_nnz; t3_nnz.fill_increasing_values(); t3_nnz.at( 3,3,3) = 0; t3_nnz.at( 2,3,3) = -4; size_t number_nonzeros = t3_nnz.nnz(); tensor3< 4, 4, 4, float > t3_nnz2; t3_nnz2.fill( 0.9878); t3_nnz2.at( 3,3,3) = 0; t3_nnz2.at( 2,3,3) = -1; t3_nnz2.at( 2,2,3) = 0.045; t3_nnz2.at( 1,2,3) = -0.085; t3_nnz2.at( 0,2,3) = 0.00000035; t3_nnz2.at( 0,1,3) = -0.00000035; size_t number_nonzeros2 = t3_nnz2.nnz( 0.00001 ); ok = ( number_nonzeros == 118 ) && (number_nonzeros2 == 61); log( "get number of nonzeros" , ok ); } { //thresholding tensor3< 4, 5, 6, float > t3_thresh; t3_thresh.fill(0.5673); t3_thresh.at( 3,3,3) = 0; t3_thresh.at( 2,3,3) = -1; t3_thresh.at( 2,2,3) = 0.045; t3_thresh.at( 1,2,3) = -0.085; t3_thresh.at( 0,2,3) = 0.00000035; t3_thresh.at( 0,1,3) = -0.00000035; t3_thresh.at( 3,3,3) = 0; t3_thresh.at( 2,3,3) = 0.001; t3_thresh.at( 0,3,3) = 0.00001; tensor3< 4, 5, 6, float > t3_thresh2(t3_thresh); t3_thresh.threshold( 0.001f ); size_t number_nonzeros = t3_thresh.nnz(); tensor3< 4, 5, 6, unsigned char > t3_thresh_char; t3_thresh_char.fill( 6); t3_thresh_char.at(0,0,0) = 3; t3_thresh_char.threshold( 4 ); size_t number_nonzeros_char = t3_thresh_char.nnz(); ok = (number_nonzeros == 115 ) && (number_nonzeros_char == 119); log( "thresholding" , ok ); } { //get_sub_tensor3 tensor3< 4, 5, 6, int > t3_bigger; t3_bigger.fill_increasing_values(); tensor3< 2, 3, 2, int > t3_sub_check; int data_sub_check[] = {32, 33, 34, 37, 38, 39, 52, 53, 54, 57, 58, 59}; t3_sub_check.set( data_sub_check, data_sub_check + 12); tensor3< 2, 3, 2, int > t3_sub; t3_bigger.get_sub_tensor3( t3_sub, 2, 2, 1 ); ok = t3_sub == t3_sub_check; t3_sub.fill_increasing_values(); t3_bigger.set_sub_tensor3( t3_sub, 0, 1, 1 ); tensor3< 4, 5, 6, int > t3_bigger_check; t3_bigger_check = t3_bigger; t3_bigger_check.at(0, 1, 1 ) = 0; t3_bigger_check.at(0, 2, 1 ) = 1; t3_bigger_check.at(0, 3, 1 ) = 2; t3_bigger_check.at(1, 1, 1 ) = 3; t3_bigger_check.at(1, 2, 1 ) = 4; t3_bigger_check.at(1, 3, 1 ) = 5; t3_bigger_check.at(0, 1, 2 ) = 6; t3_bigger_check.at(0, 2, 2 ) = 7; t3_bigger_check.at(0, 3, 2 ) = 8; t3_bigger_check.at(1, 1, 2 ) = 9; t3_bigger_check.at(1, 2, 2 ) = 10; t3_bigger_check.at(1, 3, 2 ) = 11; ok = ok && ( t3_bigger == t3_bigger_check); if ( ok ) { log( "get/set sub tensor3" , ok ); } else { std::stringstream error; error << "get/set sub tensor3 " << std::endl << "sub tensor3 is: " << std::endl << t3_sub << std::endl << "should be: " << std::endl << t3_sub_check << std::endl; log_error( error.str() ); } } { // operator(i,j,k) tensor3< 4, 3, 4, int > t3x; t3x.zero(); t3x.get_frontal_slice_fwd( 0 )( 1, 2 ) = 12; t3x.get_frontal_slice_fwd( 0 )( 2, 1 ) = 21; if ( t3x( 1, 2, 0 ) == 12 && t3x( 2, 1, 0 ) == 21 ) { log( "operator( i1, i2, i3 )", true ); } else { std::stringstream error; error << "operator(i1,i2,i3) failed. Tensor: " << std::endl << t3x << std::endl; log_error( error.str() ); } } { // get_array_ptr tensor3< 4, 3, 4, int > t3x; t3x.zero(); t3x.get_frontal_slice_fwd( 0 )( 0, 0 ) = 23; t3x.get_frontal_slice_fwd( 0 )( 1, 0 ) = 12; int* array = t3x.get_array_ptr(); if ( array[ 0 ] == 23 && array[ 1 ] == 12 ) { log( "get_array_ptr", true ); } else { std::stringstream error; error << "get_array_ptr() failed. Tensor: \n" << t3x << std::endl; log_error( error.str() ); } } { // get_array_ptr tensor3< 4, 3, 4, int > t3x; t3x.zero(); t3x.get_frontal_slice_fwd( 0 )( 0, 0 ) = 23; t3x.get_frontal_slice_fwd( 0 )( 1, 0 ) = 12; t3x.get_frontal_slice_fwd( 0 )( 0, 1 ) = 11; t3x.get_frontal_slice_fwd( 2 )( 1, 1 ) = 13; tensor3< 4, 3, 4, int >::iterator it = t3x.begin(), it_end = t3x.end(); bool ok = *it == 23; if ( ! ok ) { std::cout << "*it should be " << 23 << " but is " << *it << std::endl; } for( size_t index = 0; index < 1; ++it, ++index ) {} if ( ok ) ok = *it == 12; if ( ! ok ) { std::cout << "*it should be " << 12 << " but is " << *it << std::endl; } for( size_t index = 0; index < 3; ++it, ++index ) {} if ( ok ) ok = *it == 11; if ( ! ok ) { std::cout << "*it should be " << 11 << " but is " << *it << std::endl; } for( size_t index = 0; index < 8 + 12 + 5; ++it, ++index ) {} if ( ok ) ok = *it == 13; if ( ! ok ) { std::cout << "*it should be " << 13 << " but is " << *it << std::endl; } if ( ok ) { log( "iterator", true ); } else { std::stringstream error; error << "iterator test failed. Tensor: \n" << t3x << std::endl; log_error( error.str() ); } } { unsigned int data_uct[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 0, 0, 0, 7, 7, 7, 7, 7, 7, 0, 0, 7, 7, 7, 7, 7, 7, 0, 0, 7, 7, 7, 7, 7, 7, 0, 0, 7, 7, 7, 7, 7, 7, 0, 0, 0, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 0, 0, 0, 7, 7, 7, 7, 7, 7, 0, 0, 7, 7, 7, 7, 7, 7, 0, 0, 7, 7, 7, 7, 7, 7, 0, 0, 7, 7, 7, 7, 7, 7, 0, 0, 0, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; tensor3< 8,8, 2, unsigned int > uct_t3_check; uct_t3_check.set( data_uct, data_uct + 128); tensor3< 8,8, 2, unsigned int > uct_t3; uct_t3.fill(7); uct_t3.remove_uct_cylinder( 0 ); ok = uct_t3 == uct_t3_check; if ( ok ) { log( "remove uct ring" , ok ); } else { std::stringstream error; error << "remove uct ring " << std::endl << "t3 is: " << std::endl << uct_t3 << std::endl << "t3 should be: " << std::endl << uct_t3_check << std::endl; log_error( error.str() ); } } { //average 8voxels to 1voxel tensor3< 5, 5, 5, unsigned int > t3; t3.fill_increasing_values(); tensor3< 2, 2, 2, unsigned int > t3_sub_check; unsigned int t3_sub_data[] = { 16, 18, 26, 28, 66, 68, 76, 78 }; t3_sub_check.set( t3_sub_data, t3_sub_data + 8 ); tensor3< 2, 2, 2, unsigned int > t3_sub; t3.average_8to1( t3_sub ); ok = ( t3_sub == t3_sub_check ) ; log( "subsample tensor3 (average 8 voxels to 1 voxel)" , ok ); } { //fill slice symmetric tensor tensor3< 3, 3, 2, unsigned char > t3; t3.fill_rand_sym_slices( 3 ); tensor3< 3, 3, 3, unsigned char > t3_2; t3_2.fill_rand_sym( 6 ); ok = t3.at( 0, 1, 0) == t3.at( 1, 0, 0 ); ok = ok && (t3.at( 1, 2, 1 ) == t3.at( 2, 1, 1)); unsigned char val_102 = t3_2.at( 1, 0, 2 ); unsigned char val_012 = t3_2.at( 0, 1, 2 ); unsigned char val_021 = t3_2.at( 0, 2, 1 ); unsigned char val_201 = t3_2.at( 2, 0, 1 ); unsigned char val_120 = t3_2.at( 1, 2, 0 ); unsigned char val_210 = t3_2.at( 2, 1, 0 ); ok = ok && val_102 == val_012 && val_102 == val_021 && val_102 == val_201; ok = ok && val_102 == val_120 && val_102 == val_210; log( "fill tensor3 with symmetric random values" , ok ); } ok = true; return ok; } } // namespace vmml vmmlib-1.0/tests/vector_test.hpp0000644000175000017500000000046611674116154016424 0ustar shevekshevek#ifndef __VMML__VECTOR_TEST__HPP__ #define __VMML__VECTOR_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class vector_test : public unit_test { public: vector_test() : unit_test( "vector (m)" ) {} bool run(); protected: }; // class vector_test } // namespace vmml #endif vmmlib-1.0/tests/unit_test.cpp0000644000175000017500000000112111674116154016061 0ustar shevekshevek#include "unit_test.hpp" namespace vmml { unit_test::unit_test( const std::string& test_name ) : _tolerance( 1e-9 ) { _log = "UNIT TEST: "; _log += test_name; _log += "\n"; } void unit_test::log( const std::string& event, bool status_ok, bool warning_only ) { if ( status_ok ) _log += "[ ok ] "; else if ( ! warning_only ) _log += "[ FAIL ] "; else _log += "[ WARN ] "; _log += event; _log += "\n"; } void unit_test::log_error( const std::string& error_msg, bool warning_only ) { _log += "[ WARN ] "; _log += error_msg; _log += "\n"; } } // namespace vmml vmmlib-1.0/tests/tensor3_test.hpp0000644000175000017500000000050311674116154016507 0ustar shevekshevek#ifndef __VMML__TENSOR3_TEST__HPP__ #define __VMML__TENSOR3_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class tensor3_test : public unit_test { public: tensor3_test() : unit_test( "tensor3 (I1xI2xI3)" ) {} bool run(); protected: }; // class tensor3_test } // namespace vmml #endif vmmlib-1.0/tests/vector_test.cpp0000644000175000017500000003272211674116154016417 0ustar shevekshevek#include "vector_test.hpp" #include #include #include #include namespace vmml { bool vector_test::run() { bool ok = true; vector< 4, double > v; double data[] = { 1, 2, 3, 4 }; v.iter_set( data, data+4 ); // tests copyFrom1DimCArray function ok = true; { size_t tmp = 1; for( size_t index = 0; ok && index < 4; ++index, ++tmp ) { ok = v.at( index ) == tmp; } tmp = 4; float dataf[] = { 4, 3, 2, 1 }; v.iter_set( dataf, dataf + 4 ); for( size_t index = 0; ok && index < 4; ++index, --tmp ) { ok = v.at( index ) == tmp; } log( "set( input_iterator begin_, input_iterator end_ )", ok ); if ( ! ok ) { std::stringstream error; error << v << std::endl; log_error( error.str() ); } } // tests operator+ function ok = true; { vector< 4, double > v_other; vector< 4, double > v_result; v = data; double datad[] = { 4, 3, 2, 1 }; v_other = datad; v_result = v + v_other; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == 5; } v_result = v; v_result += v_other; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == 5; } v = data; v_result = v + 2; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == index + 3; } v_result = v; v_result += 2; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == index + 3; } log( "operator+, operator+=", ok ); if ( ! ok ) { std::stringstream error; error << "\n" << "v " << v << "v_other " << v_other << "v_result " << v_result << std::endl; log_error( error.str() ); } } // tests operator- function ok = true; { vector< 4, double > v_other; vector< 4, double > v_result; v = data; double datad[] = { 1, 2, 3, 4 }; v_other = datad; v_result = v - v_other; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == 0; } v_result = v; v_result -= v_other; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == 0; } v_result = v - 1.0; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == index; } v_result = v; v_result -= 1.0; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == index; } log( "operator-, operator-=", ok ); if ( ! ok ) { std::stringstream error; error << "\n" << "v " << v << "v_other " << v_other << "v_result " << v_result << std::endl; log_error( error.str() ); } } // tests operator* function ok = true; { vector< 4, double > v_other; vector< 4, double > v_result; v = data; double datad[] = { 24, 12, 8, 6 }; v_other = datad; v_result = v * v_other; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == 24; } v_result = v; v_result *= v_other; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == 24; } v_result = v * 2.0; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == v.at( index ) * 2.0; } v_result = v; v_result *= 2.0; for( size_t index = 0; ok && index < 4; ++index ) { ok = v_result.at( index ) == v.at( index ) * 2.0; } log( "operator*, operator*=", ok ); if ( ! ok ) { std::stringstream error; error << "\n" << "v " << v << "v_other " << v_other << "v_result " << v_result << std::endl; log_error( error.str() ); } } // tests operator/ function ok = true; { vector< 4, double > v_other; vector< 4, double > v_result; v = data; double datad[] = { 2, 4, 6, 8 }; v_other = datad; v_result = v / v_other; for( size_t index = 0; ok && index < 4; ++index ) { ok = ( v_result.at( index ) - 0.5 ) < 1e-12; } v_result = v; v_result /= v_other; for( size_t index = 0; ok && index < 4; ++index ) { ok = ( v_result.at( index ) - 0.5 ) < 1e-12; } v_result = v / 1.5; for( size_t index = 0; ok && index < 4; ++index ) { ok = ( v_result.at( index ) - ( v.at( index ) / 1.5 ) ) < 1e-12; } v_result = v; v_result /= 1.5; for( size_t index = 0; ok && index < 4; ++index ) { ok = ( v_result.at( index ) - ( v.at( index ) / 1.5 ) ) < 1e-12; } log( "operator/, operator/=", ok ); if ( !ok ) { std::stringstream error; error << "\n" << "v " << v << "v_other " << v_other << "v_result " << v_result << std::endl; log_error( error.str() ); } } // tests norm / normSquared (length/lengthSquared) computation ok = true; { vector< 4, double > vec; vec = data; double normSquared = vec.squared_length(); ok = normSquared == 1 * 1 + 2 * 2 + 3 * 3 + 4 * 4; double norm = vec.length(); if ( ok ) ok = sqrt( normSquared ) == norm; log( "length(), squared_length()", ok ); } // tests normalize ok = true; { vector< 4, double > vec; vec = data; vec.normalize(); ok = vec.length() == 1.0; log( "normalize(), maximum precision", ok, true ); if ( ! ok ) { ok = vec.length() - 1.0 < 1e-15; log( "normalize(), tolerance 1e-15", ok ); } if ( ! ok ) { std::stringstream ss; ss << "length after normalize() " << vec.length() << std::endl; log_error( ss.str() ); } } // constructor tests { bool ok = true; double vData[] = { 1, 2, 3, 4 }; vector< 4, double > v4( 1, 2, 3, 4 ); vector< 2, double > v2C; v2C = vData; vector< 2, double > v2( 1, 2 ); if ( ok && v2 != v2C ) ok = false; vector< 3, double > v3C; v3C = vData; vector< 3, double > v3( 1, 2, 3 ); if ( ok && v3 != v3C ) ok = false; vector< 4, double > v4C; v4C = vData; if ( ok && v4 != v4C ) ok = false; double vData2[] = { 23, 23, 23, 23 }; v4C = vData2; vector< 4, double > v4_( 23 ); if ( ok && v4_ != v4C ) ok = false; v3 = vData; v4C = vData; vector< 4, double > v4from3_1( v3, vData[ 3 ] ); if ( ok && v4from3_1 != v4C ) ok = false; double hvData[] = { 1., 2., 3., 0.25 }; double xvData[] = { 4.0, 8.0, 12.0 }; vector< 4, double > homogenous; homogenous.iter_set( hvData, hvData + 4 ); vector< 3, double > nonh; nonh.iter_set( xvData, xvData + 3 ); vector< 4, double > htest( nonh ); // to-homogenous-coordinates ctor if ( ok && htest != vector< 4, double >( 4, 8., 12., 1. ) ) { ok = false; } vector< 3, double > nhtest( homogenous ); // from homogenous-coordiates ctor if ( ok && nhtest != nonh ) { ok = false; } log( "constructors ", ok ); } // set tests { bool ok = true; vector< 4, double > vec; vec.set( 2, 3, 4, 5 ); vector< 4, double > vecCorrect; double vCData[] = { 2, 3, 4, 5 }; vecCorrect = vCData; if ( vec != vecCorrect ) ok = false; vec.set( 2 ); double vCData2[] = { 2, 2, 2, 2 }; vecCorrect = vCData2; if ( vec != vecCorrect ) ok = false; vector< 3, double > v( 2, 3, 4 ); // uncommenting the following line will throw a compiler error because the number // of arguments to set is != M //v.set( 2, 3, 4, 5 ); vecCorrect = vCData; vec.set( v, 5 ); if ( vec != vecCorrect ) ok = false; log( "set() functions", ok ); } // component accessors { bool ok = true; vector< 4, double > vd( 1, 2, 3, 4 ); if ( vd.x() == 1 && vd.y() == 2 && vd.z() == 3 && vd.w() == 4 ) {} else ok = false; log( "component accessors ( x(), y(), z(), w() )", ok ); } // dot product { bool ok = true; vector< 3, float > v0( 1, 2, 3 ); vector< 3, float > v1( -6, 5, -4 ); if ( v0.dot( v1 ) != -8 ) ok = false; log( "dot product, dot()", ok ); } // cross product { bool ok = true; vector< 3, float > v0( 1, 2, 3 ); vector< 3, float > v1( -6, 5, -4 ); vector< 3, float > vcorrect( -23, -14, 17 ); if ( v0.cross( v1 ) != vcorrect ) ok = false; log( "cross product, cross()", ok ); } { // TODO vector< 3, float > v0( 1, 2, 3 ); vector< 3, float > v1( -6, 5, -4 ); vector< 3, float > v2( -2, 2, -1 ); v0.squared_distance( v1 ); vector< 3, float > n; n.compute_normal( v0, v1, v2 ); vector< 3, double > vd( 3, 2, 1 ); v0 = vd; } { vector< 4, float > vf( -1.0f, 3.0f, -99.0f, -0.9f ); vector< 4, size_t > vui( 0, 5, 2, 4 ); bool ok = true; size_t index = vf.find_min_index(); float f = vf.find_min(); if ( index != 2 || f != -99.0f ) ok = false; if ( ok ) { index = vf.find_max_index(); f = vf.find_max(); if ( index != 1 || f != 3.0f ) ok = false; } size_t ui; if ( ok ) { index = vui.find_min_index(); ui = vui.find_min(); if ( index != 0 || ui != 0 ) { ok = false; } } if ( ok ) { index = vui.find_max_index(); ui = vui.find_max(); if ( index != 1 || ui != 5 ) { ok = false; } } log( "find_min/max(), find_min_index/max_index()", ok ); } { vector< 4, float > v( -1.0f, 3.0f, -99.0f, -0.9f ); float f = 4.0f; vector< 4, float > v_scaled = f * v; ok = true; if ( v_scaled != vector< 4, float >( -4.0f, 12.0f, -396.0f, -3.6f ) ) { ok = false; } log( "operator*( float, vector )", ok ); } { vector< 3, float > vf( 3.0, 2.0, 1.0 ); vector< 3, double > vd( vf ); vector< 3, double >::const_iterator it = vd.begin(), it_end = vd.end(); vector< 3, float >::const_iterator fit = vf.begin(); bool ok = true; for( ; ok && it != it_end; ++it, ++fit ) { if ( *it != *fit ) ok = false; } vd = 0.0; vd = vf; for( ; ok && it != it_end; ++it, ++fit ) { if ( *it != *fit ) ok = false; } // to-homogenous-coords and from-homogenous-coords assignment ops // are already tested in the tests for the respective ctors, // since the ctors call the assignment ops log( "conversion operator=, conversion ctor", ok ); } { vector< 4, float > vf( 3.0, 2.0, 1.0, 1.0 ); vector< 3, float >& v3 = vf.get_sub_vector< 3 >(); bool ok = v3.x() == vf.x() && v3.y() == vf.y(); v3.normalize(); if ( ok ) ok = v3.x() == vf.x() && v3.y() == vf.y(); log( "get_sub_vector< N >()", ok ); } #ifndef VMMLIB_NO_CONVERSION_OPERATORS { vector< 4, double > v; double* array = v; //const double* const_array = v; array[ 1 ] = 2.0; //const_array[ 2 ] = 3.0; } #endif { //elementwise sqrt vector< 4, float > vsq( 9.0, 4.0, 1.0, 2.0 ); vector< 4, float > vsq_check( 3.0, 2.0, 1.0, 1.414213538169861 ); vsq.sqrt_elementwise(); bool ok = vsq == vsq_check; log( "elementwise sqrt ", ok ); } { //elementwise sqrt vector< 4, float > vr( 9.0, 4.0, 1.0, 2.0 ); vector< 4, float > vr_check( 0.1111111119389534, 0.25, 1, 0.5 ); vr.reciprocal(); bool ok = vr == vr_check; log( "reciprocal ", ok ); } { //l2 norm vector< 4, float > vr( 9.0, 4.0, 1.0, 2.0 ); double v_norm_check = 10.09950493836208; double v_norm = vr.norm(); bool ok = ((v_norm - v_norm_check) < 0.0001); log( "l2 norm ", ok ); } return ok; } } // namespace vmml vmmlib-1.0/tests/tucker3_exporter_importer_test.cpp0000644000175000017500000002540311674116154022344 0ustar shevekshevek#include "tucker3_exporter_importer_test.hpp" #include #include #include //@SUS: check hot core quantization, is it correctly implementented namespace vmml { bool tucker3_exporter_importer_test::run() { bool ok = false; double precision = 1.0e-6; typedef tensor3< 3, 2, 2, double> t3_type; typedef t3_hooi< 2, 2, 1, 3, 2, 2, float > hooi_type; typedef tucker3_tensor< 2, 2, 1, 3, 2, 2, double, double > tuck3_type; typedef tucker3_exporter<2, 2, 1, 3, 2, 2, double, double> tuck3_exporter_t; typedef tucker3_importer< 2, 2, 1, 3, 2, 2, double, double > tuck3_importer_t; typedef matrix< 3, 2, double > u1_type; typedef matrix< 2, 2, double > u2_type; typedef matrix< 2, 1, double > u3_type; typedef tensor3<2, 2, 1, double> core_type; typedef std::vector< float > out_vec_type; //prepare check data double data_u1[] = { -0.2789474111071824, 0.4141266306147135, 0.5983607967045262, 0.7806355076145295, 0.7511009910815754, -0.4680890279285661 }; //original from paper (u1): {-0.2789, -0.4141, 0.5984, -0.7806, 0.7511, 0.4681}; u1_type u1_check; u1_check.set( data_u1, data_u1 + 6); double data_u2[] = { 0.09816424894941811, 0.9951702267593202, 0.9951702267593202, -0.098164248949418 }; //original in paper (u2): 0.0982, -0.9952, 0.9952, 0.0982}; u2_type u2_check; u2_check.set( data_u2, data_u2 + 4); double data_u3[] = {-0.5104644303570166, 0.8598988692516616};//original in paper (u3): {0.5105, -0.8599}; u3_type u3_check; u3_check.set( data_u3, data_u3 + 2); double data_core[] = { -10.14733447424582, 0.0, 0.0, -2.760705584847321 }; core_type core_check; core_check.set( data_core, data_core + 4); //test data from lathauwer et al. 2000b paper (same test as in t3_hooi_test t3_type t3_data_als; double data_als[] = { 0, 1, 2, 3, 4, 5, -1, 4, -2, -5, 3, -6 }; t3_data_als.set( data_als, data_als + 12 ); tuck3_type tuck3; tuck3.tucker_als( t3_data_als, hooi_type::init_hosvd() ); //export out_vec_type export_data; tuck3_exporter_t::export_to( export_data, tuck3 ); double export_data_check[] = { -0.2789473533630371, 0.5983607769012451, 0.751101016998291, 0.4141266345977783, 0.7806354761123657, -0.4680890440940857, 0.09816429018974304, 0.9951702356338501, 0.9951702356338501, -0.09816429018974304, -0.5104644894599915, 0.8598988652229309, -10.14733409881592, -3.874301910400391e-07, 5.960464477539062e-07, -2.76070547103881}; ok = true; for (int i = 0; (i < 16) && ok; ++i ) { ok = (abs(export_data_check[i] - export_data[i])) < precision; } log( "export tucker3", ok ); //import tucker3 from vector tuck3_type tuck3i; tuck3_importer_t::import_from( export_data, tuck3i ); u1_type u1_imported; u2_type u2_imported; u3_type u3_imported; core_type core_imported; tuck3i.get_core( core_imported ); tuck3i.get_u1( u1_imported ); tuck3i.get_u2( u2_imported ); tuck3i.get_u3( u3_imported ); if ( u1_imported.equals( u1_check, precision ) && u2_imported.equals( u2_check, precision ) && u3_imported.equals( u3_check, precision ) && core_imported.equals( core_check, precision)) { log( "import tucker3" , true ); } else { std::stringstream error; error << "import tucker3: " << std::endl << "U1 should be: " << std::endl << u1_check << std::endl << "U1 is: " << std::endl << u1_imported << std::endl << "U2 should be: " << std::endl << u2_check << std::endl << "U2 is: " << std::endl << u2_imported << std::endl << "U3 should be: " << std::endl << u3_check << std::endl << "U3 is: " << std::endl << u3_imported << std::endl << "core should be: " << std::endl << core_check << std::endl << "core is: " << std::endl << core_imported << std::endl; log_error( error.str() ); } //tests for quantized exports typedef unsigned char T_value; typedef unsigned short T_coeff; typedef tensor3< 3, 2, 2, T_value> t3q_type; typedef qtucker3_tensor< 2, 2, 2, 3, 2, 2, T_value, T_coeff > tuck3q_type; typedef t3_hooi< 2, 2, 2, 3, 2, 2, float > hooi_type1; typedef tucker3_exporter< 2, 2, 2, 3, 2, 2, T_value, T_coeff > tuck3q_exporter_t; typedef tucker3_importer< 2, 2, 2, 3, 2, 2, T_value, T_coeff > tuck3q_importer_t; typedef std::vector out_vecq_type; typedef matrix< 3, 2, T_coeff > u1q_type; typedef matrix< 2, 2, T_coeff > u2q_type; typedef matrix< 2, 2, T_coeff > u3q_type; typedef tensor3< 2, 2, 2, T_coeff > coreq_type; unsigned char data_2[] = { 0, 13, 122, 123, 124, 95, 10, 40, 25, 54, 33, 76}; t3q_type t3_data2; t3_data2.set(data_2, data_2 + 12); float core_min, core_max, u_min, u_max; tuck3q_type tuck3q; tuck3q.enable_quantify_linear(); tuck3q.decompose( t3_data2, u_min, u_max, core_min, core_max, hooi_type1::init_hosvd() ); t3q_type t3_reco2; tuck3q.reconstruct( t3_reco2, u_min, u_max, core_min, core_max ); //export bytes (for one min/max value for all Us) out_vecq_type export_vec; tuck3q_exporter_t::export_quantized_to( export_vec, tuck3q ); //check exported data double export_data2_check[] = { -0.715831, 0.921996, -251.346, 39.7633, /* all min/max values -0.715833, 0.865947, -0.721095, 0.692817, -0.921997, 0.921997,*/ 24791, 0, 969, 63293, 12525, 40502, 56365, 57497, 57497, 921, 65535, 44136, 13150, 65535, 0, 56016, 56087, 54573, 56556, 64473, 65535, 52911 }; ok = true; float * float_ptr = (float*)&(export_vec[0]); //check u2 min/max float u1_min_e = *float_ptr; float_ptr++; float u1_max_e = *float_ptr; float_ptr++; ok = ((fabs(float(export_data2_check[0]) - u1_min_e)) < 1.0e-4) && ((fabs(float(export_data2_check[1]) - u1_max_e)) < 1.0e-4 ); //std::cout<<"#### U1 min value === " << u1_min_e<<", U1 max value === " << u1_max_e << std::endl; float core_min_e = *float_ptr; float_ptr++; float core_max_e = *float_ptr; float_ptr++; ok = ok ? ((fabs(float(export_data2_check[2]) - core_min_e)) < 1.0e-3) && ((fabs(float(export_data2_check[3]) - core_max_e)) < 1.0e-3 ) : ok; //std::cout<<"#### core min value === " << core_min_e <<", core max value === " << core_max_e << std::endl; //std::cout<<"#### shold be core min value === " << export_data2_check[2] <<", core max value === " << export_data2_check[3] << std::endl; unsigned short* value_ptr = (unsigned short*)float_ptr; unsigned short value; size_t index = 4; size_t end_index = index + 6; //check u1 for ( ; (index < end_index) && ok; ++index ) { value = *value_ptr; //std::cout<<"#### U1 value === " << value << ", should be " << export_data2_check[index] << std::endl; value_ptr++; ok = (fabs(float(export_data2_check[index]) - float(value))) < precision; } //check u2 end_index += 4; for ( ; (index < end_index) && ok ; ++index ) { value = *value_ptr; //std::cout<<"#### U2 value === " << value << ", should be " << export_data2_check[index] << std::endl; value_ptr++; ok = (fabs(float(export_data2_check[index]) - float(value))) < precision; } //check u3 end_index += 4; for ( ; (index < end_index) && ok; ++index ) { value = *value_ptr; //std::cout<<"#### U3 value === " << value << ", should be " << export_data2_check[index] << std::endl; value_ptr++; ok = (fabs(float(export_data2_check[index]) - float(value))) < precision; } //check core values end_index += 8; for ( ; (index < end_index) && ok; ++index ) { value = *value_ptr; //std::cout<<"#### core value === " << value << ", should be " << export_data2_check[index] << std::endl; value_ptr++; ok = (fabs(float(export_data2_check[index]) - float(value))) < precision; } log( "export tucker3 (bytes) ", ok ); //prepare check data T_coeff du1[] = { 24791, 63293, 0, 12525, 969, 40502 }; u1q_type u1q_check; u1q_check.set(du1, du1 + 6); T_coeff du2[] = { 56365, 57497, 57497, 921 }; u2q_type u2q_check; u2q_check.set(du2, du2 + 4); T_coeff du3[] = { 65535, 13150, 44136, 65535 }; u3q_type u3q_check; u3q_check.set(du3, du3 + 4); T_coeff dco[] = { 0, 56087, 56016, 54573, 56556, 65535, 64473, 52911 }; coreq_type coreq_check; coreq_check.set(dco, dco + 8); u1q_type u1q; u2q_type u2q; u3q_type u3q; coreq_type coreq; //do import from bytes tuck3q_type tuck3qi; tuck3q_importer_t::import_quantized_from( export_vec, tuck3qi ); tuck3qi.get_u1( u1q ); tuck3qi.get_u2( u2q ); tuck3qi.get_u3( u3q ); tuck3qi.get_core( coreq ); ok = u1q == u1q_check; ok = ok && (u2q == u2q_check); ok = ok && (u3q == u3q_check); ok = ok && (coreq == coreq_check); if (ok) { log( "import tucker3 (bytes)" , true ); } else { std::stringstream error; error << "import tucker3 (bytes): " << std::endl << "Tucker3 is: " << std::endl << tuck3q << std::endl; log_error( error.str() ); } //prepare check data T_coeff dcho[] = { 65285, 40, 43, 79, 4, 127, 123, 98 }; coreq_check.zero(); coreq_check.set(dcho, dcho + 8); //export bytes (with optimized quantization of core) out_vecq_type export_vec_2; tuck3q_exporter_t::export_hot_quantized_to( export_vec_2, tuck3q ); tuck3q_type tuck3qi_2; tuck3q_importer_t::import_hot_quantized_from( export_vec_2, tuck3qi_2 ); tuck3qi_2.get_u1( u1q ); tuck3qi_2.get_u2( u2q ); tuck3qi_2.get_u3( u3q ); tuck3qi_2.get_core( coreq ); ok = u1q == u1q_check; ok = ok && (u2q == u2q_check); ok = ok && (u3q == u3q_check); ok = ok && (coreq == coreq_check); if (ok) { log( "export/import tucker3 (bytes) with hot core quantization" , true ); } else { std::stringstream error; error << "export/import tucker3 (bytes) with hot core quantization: " << std::endl << "Tucker3 is: " << std::endl << tuck3qi_2 << std::endl; log_error( error.str() ); } //prepare check data T_coeff dchlo[] = { 127, 26, 28, 52, 0, 85, 82, 65 }; coreq_check.zero(); coreq_check.set(dchlo, dchlo + 8); //export bytes for TTM out_vecq_type export_vec_3; tuck3q.enable_quantify_log(); tuck3q.decompose( t3_data2, u_min, u_max, core_min, core_max, hooi_type1::init_hosvd() ); tuck3q_exporter_t::export_ttm_quantized_to( export_vec_3, tuck3q ); tuck3q_type tuck3qi_3; tuck3q_importer_t::import_ttm_quantized_from( export_vec_3, tuck3qi_3 ); tuck3qi_3.get_u1( u1q ); tuck3qi_3.get_u2( u2q ); tuck3qi_3.get_u3( u3q ); tuck3qi_3.get_core( coreq ); ok = u1q == u1q_check; ok = ok && (u2q == u2q_check); ok = ok && (u3q == u3q_check); ok = ok && (coreq == coreq_check); if (ok) { log( "export/import TTM tucker3 (bytes)" , true ); } else { std::stringstream error; error << "export/import TTM tucker3 (bytes): " << std::endl << "Tucker3 is: " << std::endl << tuck3qi_3 << std::endl; log_error( error.str() ); } return ok; } } //end vmml namespace vmmlib-1.0/tests/timer.hpp0000644000175000017500000000433211674116154015177 0ustar shevekshevek#ifndef __VMML__TIMER__HPP__ #define __VMML__TIMER__HPP__ #ifdef __APPLE__ #include #include #else #ifdef __LINUX__ #include #else #include #endif #endif /** * @brief an efficient timer class for multiple archs * * since clock() is very very slow in mac os x, this timer class uses * mach_absolute_time on macs, clock() on linux and get_time_of_day() on * all other systems. * * @author jonas boesch */ namespace vmml { class timer { public: timer(); inline void start(); inline void stop(); // returns time in seconds from start() to now. double get_seconds(); void reset(); double get_elapsed_time() const; static double get_current_time(); protected: double _total_time; double _tmp_time; #ifdef __APPLE__ uint32_t _t_begin; uint32_t _t_end; static double _time_factor; static mach_timebase_info_data_t _timebase_info; #else #ifdef __LINUX__ clock_t _t_begin; clock_t _tmp; #else timeval _t_begin; timeval _t_end; long _tmp; #endif #endif }; // class multi_timer inline void timer::start() { #ifdef __APPLE__ _t_begin = mach_absolute_time(); #else #ifdef __LINUX__ _t_begin = clock(); #else gettimeofday( &_t_begin, 0 ); #endif #endif } inline void timer::stop() { #ifdef __APPLE__ _t_end = mach_absolute_time(); _tmp_time = static_cast< double > ( _t_end - _t_begin ); _tmp_time *= _time_factor; _total_time += _tmp_time; #else #ifdef __LINUX__ _tmp = clock(); _tmp_time = static_cast< double >( _tmp - _t_begin ); _tmp_time /= CLOCKS_PER_SEC; _total_time += _tmp_time; #else gettimeofday( &_t_end, 0 ); _total_time += static_cast< double >( _t_end.tv_sec - _t_begin.tv_sec ); _tmp_time = 1e-6 * static_cast< double >( _t_end.tv_usec - _t_begin.tv_usec ); _total_time += _tmp_time; #endif #endif } } // namespace stream_process #endif vmmlib-1.0/tests/timer.cpp0000644000175000017500000000316711674116154015177 0ustar shevekshevek#include "timer.hpp" #include namespace vmml { #ifdef __APPLE__ mach_timebase_info_data_t timer::_timebase_info; double timer::_time_factor; #endif timer::timer() : _total_time( 0 ) { #ifdef __APPLE__ if ( _timebase_info.denom == 0 ) { mach_timebase_info( &_timebase_info ); _time_factor = (double) _timebase_info.numer / _timebase_info.denom; _time_factor /= 1e9; } #endif } void timer::reset() { _total_time = 0; } double timer::get_elapsed_time() const { return _total_time; } double timer::get_current_time() { #ifdef __LINUX__ return (double) clock() / CLOCKS_PER_SEC; #else #ifdef __APPLE__ return static_cast< double > ( mach_absolute_time() * _time_factor ); #else timeval now; gettimeofday( &now, 0 ); return now.tv_sec + ( (double)now.tv_usec * 1e-6 ); #endif #endif } double timer::get_seconds() { #ifdef __APPLE__ _t_end = mach_absolute_time(); _tmp_time = static_cast< double > ( _t_end - _t_begin ); _tmp_time *= _time_factor; #else #ifdef __LINUX__ _tmp = clock(); _tmp_time = static_cast< double >( _tmp - _t_begin ); _tmp_time /= CLOCKS_PER_SEC; #else gettimeofday( &_t_end, 0 ); _total_time += static_cast< double >( _t_end.tv_sec - _t_begin.tv_sec ); _tmp_time = 1e-6 * static_cast< double >( _t_end.tv_usec - _t_begin.tv_usec ); #endif #endif return _tmp_time; } } // namespace stream_process vmmlib-1.0/tests/lapack_linear_least_squares_test.hpp0000644000175000017500000000065411674116154022641 0ustar shevekshevek#ifndef __VMML__LAPACK_LINEAR_LEAST_SQUARES_TEST__HPP__ #define __VMML__LAPACK_LINEAR_LEAST_SQUARES_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class lapack_linear_least_squares_test : public unit_test { public: lapack_linear_least_squares_test() : unit_test( "linear least squares using lapack" ) {} virtual bool run(); protected: }; // class lapack_linear_least_squares_test } // namespace vmml #endif vmmlib-1.0/tests/vmmlib_performance_tests_main.cpp0000644000175000017500000000040711674116154022146 0ustar shevekshevek#include "performance_test.hpp" #include "matrix_compare_perf_test.hpp" #include int main( int argc, const char* argv[] ) { vmml::matrix_compare_perf_test mcp_test; mcp_test.run(); std::cout << mcp_test << std::endl; return 0; } vmmlib-1.0/tests/vmmlib_unit_tests_main.cpp0000644000175000017500000000472511674116154020633 0ustar shevekshevek #include "vector_test.hpp" #include "matrix_test.hpp" #include "quaternion_test.hpp" #include "qr_decomposition_test.hpp" #include "svd_test.hpp" #include #ifndef VMMLIB_BASIC_ONLY #include "lapack_linear_least_squares_test.hpp" #include "lapack_gaussian_elimination_test.hpp" #include "lapack_svd_test.hpp" #include "lapack_sym_eigs_test.hpp" #include "blas_dgemm_test.hpp" #include "blas_dot_test.hpp" #include "matrix_pseudoinverse_test.hpp" #include "tensor3_test.hpp" #include "tensor3_iterator_test.hpp" #include "t3_hosvd_test.hpp" #include "t3_hooi_test.hpp" #include "t3_hopm_test.hpp" #include "t3_ihopm_test.hpp" #include "tucker3_tensor_test.hpp" #include "qtucker3_tensor_test.hpp" #include "tucker3_exporter_importer_test.hpp" #include "cp3_tensor_test.hpp" #endif void run_and_log( vmml::unit_test& test ) { test.run(); std::cout << test << std::endl; } int main( int argc, const char* argv[] ) { vmml::vector_test vector_test_; run_and_log( vector_test_ ); vmml::matrix_test matrix_test_; run_and_log( matrix_test_ ); vmml::quaternion_test quaternion_test_; run_and_log( quaternion_test_ ); vmml::qr_decomposition_test qr_test_; run_and_log( qr_test_ ); vmml::svd_test svd_test_; run_and_log( svd_test_ ); #ifndef VMML_BASIC_ONLY vmml::lapack_svd_test lapack_svd_test_; run_and_log( lapack_svd_test_ ); vmml::lapack_linear_least_squares_test lapack_llsq_test; run_and_log( lapack_llsq_test ); vmml::lapack_gaussian_elimination_test lapack_ge_test; run_and_log( lapack_ge_test ); vmml::lapack_sym_eigs_test lapack_sym_eigs_test_; run_and_log( lapack_sym_eigs_test_ ); vmml::blas_dgemm_test blas_mm; run_and_log( blas_mm ); vmml::blas_dot_test blas_vvi; run_and_log( blas_vvi ); vmml::matrix_pseudoinverse_test m_pinv; run_and_log( m_pinv ); vmml::tensor3_test t3t; run_and_log( t3t ); vmml::tensor3_iterator_test t3it; run_and_log( t3it ); vmml::t3_hosvd_test t3hosvd; run_and_log( t3hosvd ); vmml::t3_hooi_test t3hooi; run_and_log( t3hooi ); vmml::t3_hopm_test t3hopm; run_and_log( t3hopm ); vmml::t3_ihopm_test t3ihopm; run_and_log( t3ihopm ); vmml::tucker3_tensor_test tt3t; run_and_log( tt3t ); vmml::qtucker3_tensor_test tt3tq; run_and_log( tt3tq ); vmml::tucker3_exporter_importer_test tt3ei; run_and_log( tt3ei ); vmml::cp3_tensor_test cp3t; run_and_log( cp3t ); #endif } vmmlib-1.0/tests/perf_test.cpp0000644000175000017500000000151111674116154016041 0ustar shevekshevek#if 0 #include #include #include typedef vmml::Vector3f vec3f; typedef vmml::Vector3d vec3d; typedef vmml::Vector4f vec4f; typedef vmml::Vector4d vec4d; timeval start_time, end_time; float get_random() { return static_cast< double > ( rand() ) / static_cast< double > ( RAND_MAX ); }; void start() { srand( 1 ); gettimeofday( &start_time, 0 ); }; void end() { gettimeofday( &end_time, 0 ); uint64_t start = start_time.tv_sec * 10e6 + start_time.tv_usec; uint64_t end = end_time.tv_sec * 10e6 + end_time.tv_usec; uint64_t r = end - start; uint64_t s = r / 1e6; uint64_t us = r - s; std::cout << "used " << s << " s, " << us << " us." << std::endl; }; int main( int argc, const char* argv ) { start(); end(); }; #endif vmmlib-1.0/tests/matrix_test.hpp0000644000175000017500000000047011674116154016421 0ustar shevekshevek#ifndef __VMML__MATRIX_TEST__HPP__ #define __VMML__MATRIX_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class matrix_test : public unit_test { public: matrix_test() : unit_test( "matrix (mxn)" ) {} bool run(); protected: }; // class matrix_test } // namespace vmml #endif vmmlib-1.0/tests/frustum_test.cpp0000644000175000017500000000056211674116154016617 0ustar shevekshevek#include "frustum_test.hpp" #include #include namespace vmml { bool frustum_test::run() { { // TODO frustum< float > f; frustum_culler< float > fc; matrix< 4, 4, float > mvp; fc.setup( mvp ); } return true; } } // namespace vmml vmmlib-1.0/tests/lapack_svd_test.hpp0000644000175000017500000000054311674116154017225 0ustar shevekshevek#ifndef __VMML__LAPACK_SVD_TEST__HPP__ #define __VMML__LAPACK_SVD_TEST__HPP__ #include "unit_test.hpp" namespace vmml { class lapack_svd_test : public unit_test { public: lapack_svd_test() : unit_test( "SVD, singular value decomposition using lapack" ) {} virtual bool run(); protected: }; // class lapack_svd_test } // namespace vmml #endif vmmlib-1.0/tests/t3_hooi_test.hpp0000644000175000017500000000051011674116154016454 0ustar shevekshevek#ifndef __VMML__T3_HOOI_TEST__HPP__ #define __VMML__T3_HOOI_TEST__HPP__ #include "unit_test.hpp" #include namespace vmml { class t3_hooi_test : public unit_test { public: t3_hooi_test() : unit_test( "tensor3 HOOI" ) {} bool run(); protected: }; // class t3_hooi_test } // namespace vmml #endif vmmlib-1.0/tests/tensor3_iterator_test.cpp0000644000175000017500000000225011674116154020414 0ustar shevekshevek#include "tensor3_iterator_test.hpp" #include #include #include #include namespace vmml { bool tensor3_iterator_test::run() { bool ok = false; tensor3< 2, 3, 4, uint16_t > t3; t3.fill_increasing_values(); typedef tensor3< 2, 3, 4, uint16_t > myt3; myt3::iterator it = t3.begin(), it_end = t3.end(); std::vector< uint16_t > t3_iter_order; std::vector< uint16_t > hand_iter_order; for( ; it != it_end; ++it ) { t3_iter_order.push_back( *it ); } for( size_t index = 0; index < 4; ++index ) { matrix< 2, 3, uint16_t >& m = t3.get_frontal_slice_fwd( index ); tensor3< 2, 3, 4, uint16_t >::matrix_iterator it = m.begin(), it_end = m.end(); for( ; it != it_end; ++it ) { hand_iter_order.push_back( *it ); } } ok = t3_iter_order == hand_iter_order; log( "tensor3 iterator ", ok ); ok = true; return ok; } } // namespace vmml vmmlib-1.0/Makefile0000644000175000017500000000347711674116156013657 0ustar shevekshevek VMMLIB_UNIT_TESTS =\ tests/unit_test.cpp\ tests/vector_test.cpp\ tests/matrix_test.cpp\ tests/quaternion_test.cpp\ tests/qr_decomposition_test.cpp\ tests/svd_test.cpp\ tests/lapack_svd_test.cpp\ tests/lapack_linear_least_squares_test.cpp\ tests/lapack_gaussian_elimination_test.cpp\ tests/vmmlib_unit_tests_main.cpp\ tests/lapack_sym_eigs_test.cpp\ tests/tensor3_test.cpp \ tests/tensor3_iterator_test.cpp \ tests/tucker3_tensor_test.cpp \ tests/qtucker3_tensor_test.cpp \ tests/tucker3_exporter_importer_test.cpp \ tests/cp3_tensor_test.cpp \ tests/t3_hosvd_test.cpp \ tests/t3_hooi_test.cpp \ tests/t3_hopm_test.cpp \ tests/t3_ihopm_test.cpp \ tests/matrix_pseudoinverse_test.cpp \ tests/blas_dgemm_test.cpp \ tests/blas_dot_test.cpp \ VMMLIB_UNIT_TESTS_OBJECTS = ${VMMLIB_UNIT_TESTS:%.cpp=%.o} CXXFLAGS += -I. -Iinclude -Itests -include stdint.h # Mac OS X specific stuff # on mac we want to use the frameworks, not the unix style libs ARCH = $(shell uname) ifeq "$(ARCH)" "Darwin" CXXFLAGS += -framework Accelerate LDFLAGS += -framework Accelerate else # Linux specific stuff CXXFLAGS += -include f2c.h -include f2c_fix.h LBITS := $(shell getconf LONG_BIT) ifeq ($(LBITS),64) LIBDIR=$(DESTDIR)/usr/lib64 else LIBDIR=$(DESTDIR)/usr/lib endif CXXFLAGS += LDFLAGS += # adjust libs depending on your LAPACK and BLAS distribution LIBS += -lclapack -lf2c -lcblas -llapack # LIBS += -llapack -lblas endif all: vmmlib_unit_tests .cpp.o: $(CXX) $(CXXFLAGS) -c $< -o $@ vmmlib_unit_tests: $(VMMLIB_UNIT_TESTS_OBJECTS) ifeq "$(ARCH)" "Darwin" $(CXX) $(LDFLAGS) $(VMMLIB_UNIT_TESTS_OBJECTS) -o $@ else $(CXX) $(LDFLAGS) $(VMMLIB_UNIT_TESTS_OBJECTS) -o $@ $(LIBS) endif clean: rm -rf $(VMMLIB_UNIT_TESTS_OBJECTS) vmmlib_unit_tests vmmlib-1.0/LICENSE0000644000175000017500000000305711674116156013216 0ustar shevekshevekCopyright (c) 2006-2012, Visualization and Multimedia Lab, University of Zurich All rights reserved. (http://vmml.ifi.uzh.ch) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the Visualization and Multimedia Lab, University of Zurich nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. vmmlib-1.0/CMakeLists.txt0000644000175000017500000000252511674116156014750 0ustar shevekshevek# Copyright (c) 2011 Daniel Pfeifer cmake_minimum_required(VERSION 2.8 FATAL_ERROR) project(VMMLib) enable_testing() include_directories(include) if(APPLE) find_library(LAPACK_LIBRARIES accelerate) if(LAPACK_LIBRARIES) set(LAPACK_FOUND TRUE) endif(LAPACK_LIBRARIES) else(APPLE) enable_language(Fortran) find_package(LAPACK) endif(APPLE) if(LAPACK_FOUND) add_definitions(-DVMMLIB_USE_LAPACK=1) endif(LAPACK_FOUND) add_executable(vmmlib_test tests/cp3_tensor_test.cpp tests/frustum_test.cpp tests/jacobi_test.cpp tests/lapack_gaussian_elimination_test.cpp tests/lapack_linear_least_squares_test.cpp tests/lapack_svd_test.cpp tests/lapack_sym_eigs_test.cpp # tests/matrix_compare_perf_test.cpp tests/matrix_pseudoinverse_test.cpp tests/matrix_test.cpp tests/perf_test.cpp tests/performance_test.cpp tests/qr_decomposition_test.cpp tests/quaternion_test.cpp # tests/stringtests.cpp tests/svd_lapack_vs_old.cpp tests/svd_test.cpp tests/tensor3_iterator_test.cpp tests/tensor3_test.cpp tests/timer.cpp tests/tucker3_tensor_test.cpp tests/unit_test.cpp tests/vector_test.cpp # tests/vmmlib_lapack_main.cpp # tests/vmmlib_performance_tests_main.cpp tests/vmmlib_unit_tests_main.cpp ) target_link_libraries(vmmlib_test ${LAPACK_LIBRARIES} ) add_test(vmmlib_test vmmlib_test) vmmlib-1.0/vmmlib.xcodeproj/0000755000175000017500000000000011674116154015464 5ustar shevekshevekvmmlib-1.0/vmmlib.xcodeproj/project.pbxproj0000644000175000017500000014772311674116154020556 0ustar shevekshevek// !$*UTF8*$! { archiveVersion = 1; classes = { }; objectVersion = 42; objects = { /* Begin PBXBuildFile section */ 98244A330E3F5A5E0018E13A /* unit_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98FE7DCD0E224EC400B1E17F /* unit_test.cpp */; }; 98244A3F0E3F5AEE0018E13A /* lapack_svd_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98244A3B0E3F5AEE0018E13A /* lapack_svd_test.cpp */; }; 98244A400E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98244A3D0E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp */; }; 98244A410E3F5AEE0018E13A /* lapack_svd_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98244A3B0E3F5AEE0018E13A /* lapack_svd_test.cpp */; }; 98244A420E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98244A3D0E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp */; }; 98244A430E3F5AEE0018E13A /* lapack_svd_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98244A3B0E3F5AEE0018E13A /* lapack_svd_test.cpp */; }; 98244A440E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98244A3D0E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp */; }; 98244C010E3F76930018E13A /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 9839FE0E0E2BB16D00A16721 /* Accelerate.framework */; }; 9839FA240E2B5BBB00A16721 /* svd_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9839FA220E2B5BBB00A16721 /* svd_test.cpp */; }; 9839FA250E2B5BBB00A16721 /* svd_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9839FA220E2B5BBB00A16721 /* svd_test.cpp */; }; 9839FE440E2BB25200A16721 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 9839FE0E0E2BB16D00A16721 /* Accelerate.framework */; }; 9839FE5E0E2BB5B300A16721 /* vmmlib_lapack_main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9839FE5D0E2BB5B300A16721 /* vmmlib_lapack_main.cpp */; }; 9839FEF80E2BC67400A16721 /* svd_lapack_vs_old.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9839FEF60E2BC67400A16721 /* svd_lapack_vs_old.cpp */; }; 9839FF000E2BC75D00A16721 /* performance_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B7A2680E24CB140064264E /* performance_test.cpp */; }; 9839FF020E2BC76600A16721 /* timer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B7A2560E24C9540064264E /* timer.cpp */; }; 98476419110DDB940024A1F8 /* tensor3_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98476417110DDB940024A1F8 /* tensor3_test.cpp */; }; 9863B6F211903EFE00887FFC /* lapack_gaussian_elimination_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9863B6F111903EFE00887FFC /* lapack_gaussian_elimination_test.cpp */; }; 986834C10E24FFD400618F55 /* vector_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 986834BF0E24FFD400618F55 /* vector_test.cpp */; }; 986834C20E24FFD400618F55 /* vector_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 986834BF0E24FFD400618F55 /* vector_test.cpp */; }; 98B22A280FB8353900EEDF5F /* frustum_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B22A260FB8353900EEDF5F /* frustum_test.cpp */; }; 98B230730FB985D700EEDF5F /* jacobi_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B230710FB985D700EEDF5F /* jacobi_test.cpp */; }; 98B7A2520E24C8E70064264E /* vmmlib_unit_tests_main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B7A2500E24C8E70064264E /* vmmlib_unit_tests_main.cpp */; }; 98B7A2540E24C8F40064264E /* vmmlib_performance_tests_main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B7A2510E24C8E70064264E /* vmmlib_performance_tests_main.cpp */; }; 98B7A2570E24C9540064264E /* timer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B7A2560E24C9540064264E /* timer.cpp */; }; 98B7A26A0E24CB140064264E /* performance_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B7A2680E24CB140064264E /* performance_test.cpp */; }; 98B7A2A50E24DF910064264E /* matrix_compare_perf_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98B7A2A30E24DF910064264E /* matrix_compare_perf_test.cpp */; }; 98C561060F1BA62B0026B925 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 9839FE0E0E2BB16D00A16721 /* Accelerate.framework */; }; 98D402D60E38D6A000B24DF1 /* quaternion_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98D402D40E38D6A000B24DF1 /* quaternion_test.cpp */; }; 98D402D70E38D6A000B24DF1 /* quaternion_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98D402D40E38D6A000B24DF1 /* quaternion_test.cpp */; }; 98D402D80E38D6A000B24DF1 /* quaternion_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98D402D40E38D6A000B24DF1 /* quaternion_test.cpp */; }; 98F5563A0E24377F0044BA3E /* matrix_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98F556350E24377F0044BA3E /* matrix_test.cpp */; }; 98F5563B0E24377F0044BA3E /* qr_decomposition_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98F556370E24377F0044BA3E /* qr_decomposition_test.cpp */; }; 98FAB2960E30CDF400C1A8FC /* unit_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98FE7DCD0E224EC400B1E17F /* unit_test.cpp */; }; 98FE7DCF0E224EC400B1E17F /* unit_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 98FE7DCD0E224EC400B1E17F /* unit_test.cpp */; }; CF06479F1446E4B7007DD062 /* tucker3_exporter_importer_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CF06479E1446E4B7007DD062 /* tucker3_exporter_importer_test.cpp */; }; CF0649C814472249007DD062 /* qtucker3_tensor_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CF0649C714472249007DD062 /* qtucker3_tensor_test.cpp */; }; CF2DD25E126C8EAE0036DE05 /* tensor3_iterator_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CF2DD25D126C8EAE0036DE05 /* tensor3_iterator_test.cpp */; }; CF2DD265126C91670036DE05 /* cp3_tensor_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CF2DD264126C91670036DE05 /* cp3_tensor_test.cpp */; }; CF42E5EA125F738600C0A38E /* matrix_pseudoinverse_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CF42E5E9125F738600C0A38E /* matrix_pseudoinverse_test.cpp */; }; CF75FFF51432383D00CFD46E /* blas_dot_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CF75FFF41432383D00CFD46E /* blas_dot_test.cpp */; }; CF7FA8D5114EB617003076E4 /* tucker3_tensor_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CF7FA8D4114EB617003076E4 /* tucker3_tensor_test.cpp */; }; CFA7FE4B14225C03001EE112 /* t3_ihopm_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CFA7FE4A14225C03001EE112 /* t3_ihopm_test.cpp */; }; CFD85C551399060300266D85 /* t3_hosvd_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CFD85C541399060300266D85 /* t3_hosvd_test.cpp */; }; CFD85C81139909EF00266D85 /* t3_hooi_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CFD85C80139909EF00266D85 /* t3_hooi_test.cpp */; }; CFD85C8413990A0E00266D85 /* t3_hopm_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CFD85C8313990A0E00266D85 /* t3_hopm_test.cpp */; }; CFF0C1FA1406E55200C3ADDB /* blas_dgemm_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CFF0C1F81406E55200C3ADDB /* blas_dgemm_test.cpp */; }; CFF95533131CECD100071FB3 /* lapack_sym_eigs_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CFF95532131CECD100071FB3 /* lapack_sym_eigs_test.cpp */; }; /* End PBXBuildFile section */ /* Begin PBXFileReference section */ 982449FB0E3F584A0018E13A /* lapack_svd.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_svd.hpp; path = include/vmmlib/lapack_svd.hpp; sourceTree = ""; }; 982449FC0E3F584A0018E13A /* lapack_linear_least_squares.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_linear_least_squares.hpp; path = include/vmmlib/lapack_linear_least_squares.hpp; sourceTree = ""; }; 982449FD0E3F584A0018E13A /* lapack.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack.hpp; path = include/vmmlib/lapack.hpp; sourceTree = ""; }; 98244A3B0E3F5AEE0018E13A /* lapack_svd_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lapack_svd_test.cpp; path = tests/lapack_svd_test.cpp; sourceTree = ""; }; 98244A3C0E3F5AEE0018E13A /* lapack_svd_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_svd_test.hpp; path = tests/lapack_svd_test.hpp; sourceTree = ""; }; 98244A3D0E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lapack_linear_least_squares_test.cpp; path = tests/lapack_linear_least_squares_test.cpp; sourceTree = ""; }; 98244A3E0E3F5AEE0018E13A /* lapack_linear_least_squares_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_linear_least_squares_test.hpp; path = tests/lapack_linear_least_squares_test.hpp; sourceTree = ""; }; 9839FA1D0E2B5A6C00A16721 /* svd.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = svd.hpp; path = include/vmmlib/svd.hpp; sourceTree = ""; }; 9839FA220E2B5BBB00A16721 /* svd_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = svd_test.cpp; path = tests/svd_test.cpp; sourceTree = ""; }; 9839FA230E2B5BBB00A16721 /* svd_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = svd_test.hpp; path = tests/svd_test.hpp; sourceTree = ""; }; 9839FE0E0E2BB16D00A16721 /* Accelerate.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Accelerate.framework; path = /System/Library/Frameworks/Accelerate.framework; sourceTree = ""; }; 9839FE1F0E2BB24700A16721 /* vmmlib_lapack_test */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = vmmlib_lapack_test; sourceTree = BUILT_PRODUCTS_DIR; }; 9839FE5D0E2BB5B300A16721 /* vmmlib_lapack_main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = vmmlib_lapack_main.cpp; path = tests/vmmlib_lapack_main.cpp; sourceTree = ""; }; 9839FEF60E2BC67400A16721 /* svd_lapack_vs_old.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = svd_lapack_vs_old.cpp; path = tests/svd_lapack_vs_old.cpp; sourceTree = ""; }; 9839FEF70E2BC67400A16721 /* svd_lapack_vs_old.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = svd_lapack_vs_old.hpp; path = tests/svd_lapack_vs_old.hpp; sourceTree = ""; }; 984763FE110DDB3C0024A1F8 /* tensor3.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tensor3.hpp; path = include/vmmlib/tensor3.hpp; sourceTree = ""; }; 98476417110DDB940024A1F8 /* tensor3_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = tensor3_test.cpp; path = tests/tensor3_test.cpp; sourceTree = ""; }; 98476418110DDB940024A1F8 /* tensor3_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tensor3_test.hpp; path = tests/tensor3_test.hpp; sourceTree = ""; }; 984F581211B8CFD90027D673 /* vector_traits.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = vector_traits.hpp; path = include/vmmlib/vector_traits.hpp; sourceTree = ""; }; 984F581311B8CFD90027D673 /* matrix_traits.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = matrix_traits.hpp; path = include/vmmlib/matrix_traits.hpp; sourceTree = ""; }; 98584AF50E643AEC00314C4C /* lapack_types.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_types.hpp; path = include/vmmlib/lapack_types.hpp; sourceTree = ""; }; 98584B140E643BFC00314C4C /* lapack_includes.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_includes.hpp; path = include/vmmlib/lapack_includes.hpp; sourceTree = ""; }; 985964770FB177A6006CA0F8 /* math.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = math.hpp; path = include/vmmlib/math.hpp; sourceTree = ""; }; 98596E620FB4891E006CA0F8 /* enable_if.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = enable_if.hpp; path = include/vmmlib/enable_if.hpp; sourceTree = ""; }; 98596E730FB4897C006CA0F8 /* jacobi_solver.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = jacobi_solver.hpp; path = include/vmmlib/jacobi_solver.hpp; sourceTree = ""; }; 98596E840FB489D4006CA0F8 /* frustum_culler.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = frustum_culler.hpp; path = include/vmmlib/frustum_culler.hpp; sourceTree = ""; }; 985F6FCC0C6B7C67002B05C5 /* LICENSE */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; name = LICENSE; path = include/vmmlib/LICENSE; sourceTree = ""; }; 9863B6E711903E5D00887FFC /* lapack_gaussian_elimination.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_gaussian_elimination.hpp; path = include/vmmlib/lapack_gaussian_elimination.hpp; sourceTree = ""; }; 9863B6F011903EFE00887FFC /* lapack_gaussian_elimination_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_gaussian_elimination_test.hpp; path = tests/lapack_gaussian_elimination_test.hpp; sourceTree = ""; }; 9863B6F111903EFE00887FFC /* lapack_gaussian_elimination_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lapack_gaussian_elimination_test.cpp; path = tests/lapack_gaussian_elimination_test.cpp; sourceTree = ""; }; 9868345B0E24F8F300618F55 /* vector.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = vector.hpp; path = include/vmmlib/vector.hpp; sourceTree = ""; }; 9868345D0E24F97D00618F55 /* vmmlib_config.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = vmmlib_config.hpp; path = include/vmmlib/vmmlib_config.hpp; sourceTree = ""; }; 986834BF0E24FFD400618F55 /* vector_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = vector_test.cpp; path = tests/vector_test.cpp; sourceTree = ""; }; 986834C00E24FFD400618F55 /* vector_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = vector_test.hpp; path = tests/vector_test.hpp; sourceTree = ""; }; 988F5A100C22CAFE0005AC92 /* README */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = README; sourceTree = ""; }; 98B22A260FB8353900EEDF5F /* frustum_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = frustum_test.cpp; path = tests/frustum_test.cpp; sourceTree = ""; }; 98B22A270FB8353900EEDF5F /* frustum_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = frustum_test.hpp; path = tests/frustum_test.hpp; sourceTree = ""; }; 98B230710FB985D700EEDF5F /* jacobi_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jacobi_test.cpp; path = tests/jacobi_test.cpp; sourceTree = ""; }; 98B230720FB985D700EEDF5F /* jacobi_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = jacobi_test.hpp; path = tests/jacobi_test.hpp; sourceTree = ""; }; 98B7A2490E24C85C0064264E /* vmmlib_performance_tests */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = vmmlib_performance_tests; sourceTree = BUILT_PRODUCTS_DIR; }; 98B7A2500E24C8E70064264E /* vmmlib_unit_tests_main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = vmmlib_unit_tests_main.cpp; path = tests/vmmlib_unit_tests_main.cpp; sourceTree = ""; }; 98B7A2510E24C8E70064264E /* vmmlib_performance_tests_main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = vmmlib_performance_tests_main.cpp; path = tests/vmmlib_performance_tests_main.cpp; sourceTree = ""; }; 98B7A2550E24C9540064264E /* timer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = timer.hpp; path = tests/timer.hpp; sourceTree = ""; }; 98B7A2560E24C9540064264E /* timer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = timer.cpp; path = tests/timer.cpp; sourceTree = ""; }; 98B7A2680E24CB140064264E /* performance_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = performance_test.cpp; path = tests/performance_test.cpp; sourceTree = ""; }; 98B7A2690E24CB140064264E /* performance_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = performance_test.hpp; path = tests/performance_test.hpp; sourceTree = ""; }; 98B7A2A30E24DF910064264E /* matrix_compare_perf_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = matrix_compare_perf_test.cpp; path = tests/matrix_compare_perf_test.cpp; sourceTree = ""; }; 98B7A2A40E24DF910064264E /* matrix_compare_perf_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = matrix_compare_perf_test.hpp; path = tests/matrix_compare_perf_test.hpp; sourceTree = ""; }; 98B7A3F00E24EAA30064264E /* matrix_functors.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = matrix_functors.hpp; path = include/vmmlib/matrix_functors.hpp; sourceTree = ""; }; 98D402D30E38D6A000B24DF1 /* quaternion.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = quaternion.hpp; path = include/vmmlib/quaternion.hpp; sourceTree = ""; }; 98D402D40E38D6A000B24DF1 /* quaternion_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = quaternion_test.cpp; path = tests/quaternion_test.cpp; sourceTree = ""; }; 98D402D50E38D6A000B24DF1 /* quaternion_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = quaternion_test.hpp; path = tests/quaternion_test.hpp; sourceTree = ""; }; 98D4102C0E2658FE00BEFA71 /* exception.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = exception.hpp; path = include/vmmlib/exception.hpp; sourceTree = ""; }; 98D9E40F0E3E269700B046DD /* vmmlib.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = vmmlib.hpp; path = include/vmmlib/vmmlib.hpp; sourceTree = ""; }; 98D9E4110E3E26E000B046DD /* frustum.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = frustum.hpp; path = include/vmmlib/frustum.hpp; sourceTree = ""; }; 98D9E4C10E3E314700B046DD /* visibility.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = visibility.hpp; path = include/vmmlib/visibility.hpp; sourceTree = ""; }; 98F556320E2437540044BA3E /* matrix.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = matrix.hpp; path = include/vmmlib/matrix.hpp; sourceTree = ""; }; 98F556330E2437540044BA3E /* qr_decomposition.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = qr_decomposition.hpp; path = include/vmmlib/qr_decomposition.hpp; sourceTree = ""; }; 98F556350E24377F0044BA3E /* matrix_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = matrix_test.cpp; path = tests/matrix_test.cpp; sourceTree = ""; }; 98F556360E24377F0044BA3E /* matrix_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = matrix_test.hpp; path = tests/matrix_test.hpp; sourceTree = ""; }; 98F556370E24377F0044BA3E /* qr_decomposition_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = qr_decomposition_test.cpp; path = tests/qr_decomposition_test.cpp; sourceTree = ""; }; 98F556380E24377F0044BA3E /* qr_decomposition_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = qr_decomposition_test.hpp; path = tests/qr_decomposition_test.hpp; sourceTree = ""; }; 98FE7DC50E224E8700B1E17F /* vmmlib_unit_tests */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = vmmlib_unit_tests; sourceTree = BUILT_PRODUCTS_DIR; }; 98FE7DCD0E224EC400B1E17F /* unit_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = unit_test.cpp; path = tests/unit_test.cpp; sourceTree = ""; }; 98FE7DCE0E224EC400B1E17F /* unit_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = unit_test.hpp; path = tests/unit_test.hpp; sourceTree = ""; }; CF0647971446DE52007DD062 /* qtucker3_tensor.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = qtucker3_tensor.hpp; path = include/vmmlib/qtucker3_tensor.hpp; sourceTree = ""; }; CF0647981446E152007DD062 /* tucker3_exporter.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tucker3_exporter.hpp; path = include/vmmlib/tucker3_exporter.hpp; sourceTree = ""; }; CF06479A1446E17B007DD062 /* tucker3_importer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tucker3_importer.hpp; path = include/vmmlib/tucker3_importer.hpp; sourceTree = ""; }; CF06479D1446E4B7007DD062 /* tucker3_exporter_importer_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tucker3_exporter_importer_test.hpp; path = tests/tucker3_exporter_importer_test.hpp; sourceTree = ""; }; CF06479E1446E4B7007DD062 /* tucker3_exporter_importer_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = tucker3_exporter_importer_test.cpp; path = tests/tucker3_exporter_importer_test.cpp; sourceTree = ""; }; CF0649C614472249007DD062 /* qtucker3_tensor_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = qtucker3_tensor_test.hpp; path = tests/qtucker3_tensor_test.hpp; sourceTree = ""; }; CF0649C714472249007DD062 /* qtucker3_tensor_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = qtucker3_tensor_test.cpp; path = tests/qtucker3_tensor_test.cpp; sourceTree = ""; }; CF2DD1EF126C7A4A0036DE05 /* cp3_tensor.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = cp3_tensor.hpp; path = include/vmmlib/cp3_tensor.hpp; sourceTree = ""; }; CF2DD25B126C8E530036DE05 /* tensor3_iterator.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tensor3_iterator.hpp; path = include/vmmlib/tensor3_iterator.hpp; sourceTree = ""; }; CF2DD25C126C8EAE0036DE05 /* tensor3_iterator_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tensor3_iterator_test.hpp; path = tests/tensor3_iterator_test.hpp; sourceTree = ""; }; CF2DD25D126C8EAE0036DE05 /* tensor3_iterator_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = tensor3_iterator_test.cpp; path = tests/tensor3_iterator_test.cpp; sourceTree = ""; }; CF2DD263126C91670036DE05 /* cp3_tensor_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = cp3_tensor_test.hpp; path = tests/cp3_tensor_test.hpp; sourceTree = ""; }; CF2DD264126C91670036DE05 /* cp3_tensor_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = cp3_tensor_test.cpp; path = tests/cp3_tensor_test.cpp; sourceTree = ""; }; CF42E5E7125F736E00C0A38E /* matrix_pseudoinverse_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = matrix_pseudoinverse_test.hpp; path = tests/matrix_pseudoinverse_test.hpp; sourceTree = ""; }; CF42E5E9125F738600C0A38E /* matrix_pseudoinverse_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = matrix_pseudoinverse_test.cpp; path = tests/matrix_pseudoinverse_test.cpp; sourceTree = ""; }; CF42E65B125F7F2100C0A38E /* matrix_pseudoinverse.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = matrix_pseudoinverse.hpp; path = include/vmmlib/matrix_pseudoinverse.hpp; sourceTree = ""; }; CF75FFD11432315C00CFD46E /* blas_dot.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = blas_dot.hpp; path = include/vmmlib/blas_dot.hpp; sourceTree = ""; }; CF75FFF31432383D00CFD46E /* blas_dot_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = blas_dot_test.hpp; path = tests/blas_dot_test.hpp; sourceTree = ""; }; CF75FFF41432383D00CFD46E /* blas_dot_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = blas_dot_test.cpp; path = tests/blas_dot_test.cpp; sourceTree = ""; }; CF7FA84C114AAC01003076E4 /* tucker3_tensor.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tucker3_tensor.hpp; path = include/vmmlib/tucker3_tensor.hpp; sourceTree = ""; }; CF7FA8D4114EB617003076E4 /* tucker3_tensor_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = tucker3_tensor_test.cpp; path = tests/tucker3_tensor_test.cpp; sourceTree = ""; }; CF7FA8D9114EB696003076E4 /* tucker3_tensor_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = tucker3_tensor_test.hpp; path = tests/tucker3_tensor_test.hpp; sourceTree = ""; }; CFA7FE00142242BD001EE112 /* t3_ihopm.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = t3_ihopm.hpp; path = include/vmmlib/t3_ihopm.hpp; sourceTree = ""; }; CFA7FE4914225C03001EE112 /* t3_ihopm_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = t3_ihopm_test.hpp; path = tests/t3_ihopm_test.hpp; sourceTree = ""; }; CFA7FE4A14225C03001EE112 /* t3_ihopm_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = t3_ihopm_test.cpp; path = tests/t3_ihopm_test.cpp; sourceTree = ""; }; CFD85BC61398E2A100266D85 /* t3_hosvd.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = t3_hosvd.hpp; path = include/vmmlib/t3_hosvd.hpp; sourceTree = ""; }; CFD85BC71398E2BE00266D85 /* t3_hooi.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = t3_hooi.hpp; path = include/vmmlib/t3_hooi.hpp; sourceTree = ""; }; CFD85BC81398E2D400266D85 /* t3_hopm.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = t3_hopm.hpp; path = include/vmmlib/t3_hopm.hpp; sourceTree = ""; }; CFD85C531399060300266D85 /* t3_hosvd_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = t3_hosvd_test.hpp; path = tests/t3_hosvd_test.hpp; sourceTree = ""; }; CFD85C541399060300266D85 /* t3_hosvd_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = t3_hosvd_test.cpp; path = tests/t3_hosvd_test.cpp; sourceTree = ""; }; CFD85C7F139909EF00266D85 /* t3_hooi_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = t3_hooi_test.hpp; path = tests/t3_hooi_test.hpp; sourceTree = ""; }; CFD85C80139909EF00266D85 /* t3_hooi_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = t3_hooi_test.cpp; path = tests/t3_hooi_test.cpp; sourceTree = ""; }; CFD85C8213990A0E00266D85 /* t3_hopm_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = t3_hopm_test.hpp; path = tests/t3_hopm_test.hpp; sourceTree = ""; }; CFD85C8313990A0E00266D85 /* t3_hopm_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = t3_hopm_test.cpp; path = tests/t3_hopm_test.cpp; sourceTree = ""; }; CFF0C1F21406E4DC00C3ADDB /* blas_dgemm.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = blas_dgemm.hpp; path = include/vmmlib/blas_dgemm.hpp; sourceTree = ""; }; CFF0C1F31406E4DC00C3ADDB /* blas_includes.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = blas_includes.hpp; path = include/vmmlib/blas_includes.hpp; sourceTree = ""; }; CFF0C1F41406E4DC00C3ADDB /* blas_types.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = blas_types.hpp; path = include/vmmlib/blas_types.hpp; sourceTree = ""; }; CFF0C1F81406E55200C3ADDB /* blas_dgemm_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = blas_dgemm_test.cpp; path = tests/blas_dgemm_test.cpp; sourceTree = ""; }; CFF0C1F91406E55200C3ADDB /* blas_dgemm_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = blas_dgemm_test.hpp; path = tests/blas_dgemm_test.hpp; sourceTree = ""; }; CFF952C41312B52C00071FB3 /* lapack_sym_eigs.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_sym_eigs.hpp; path = include/vmmlib/lapack_sym_eigs.hpp; sourceTree = ""; }; CFF95531131CECD100071FB3 /* lapack_sym_eigs_test.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = lapack_sym_eigs_test.hpp; path = tests/lapack_sym_eigs_test.hpp; sourceTree = ""; }; CFF95532131CECD100071FB3 /* lapack_sym_eigs_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lapack_sym_eigs_test.cpp; path = tests/lapack_sym_eigs_test.cpp; sourceTree = ""; }; /* End PBXFileReference section */ /* Begin PBXFrameworksBuildPhase section */ 9839FE1D0E2BB24700A16721 /* Frameworks */ = { isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = ( 9839FE440E2BB25200A16721 /* Accelerate.framework in Frameworks */, ); runOnlyForDeploymentPostprocessing = 0; }; 98B7A2470E24C85C0064264E /* Frameworks */ = { isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = ( 98C561060F1BA62B0026B925 /* Accelerate.framework in Frameworks */, ); runOnlyForDeploymentPostprocessing = 0; }; 98FE7DC30E224E8700B1E17F /* Frameworks */ = { isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = ( 98244C010E3F76930018E13A /* Accelerate.framework in Frameworks */, ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXFrameworksBuildPhase section */ /* Begin PBXGroup section */ 034768DFFF38A50411DB9C8B /* Products */ = { isa = PBXGroup; children = ( 98FE7DC50E224E8700B1E17F /* vmmlib_unit_tests */, 98B7A2490E24C85C0064264E /* vmmlib_performance_tests */, 9839FE1F0E2BB24700A16721 /* vmmlib_lapack_test */, ); name = Products; sourceTree = ""; }; 0867D691FE84028FC02AAC07 /* VMMLib */ = { isa = PBXGroup; children = ( 08FB77AEFE84172EC02AAC07 /* Library */, 988F58330C22C0720005AC92 /* Tests */, 089C1665FE841158C02AAC07 /* Resources */, 0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */, 034768DFFF38A50411DB9C8B /* Products */, ); name = VMMLib; sourceTree = ""; }; 0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */ = { isa = PBXGroup; children = ( 9839FE0E0E2BB16D00A16721 /* Accelerate.framework */, ); name = "External Frameworks and Libraries"; sourceTree = ""; }; 089C1665FE841158C02AAC07 /* Resources */ = { isa = PBXGroup; children = ( 985F6FCC0C6B7C67002B05C5 /* LICENSE */, 988F5A100C22CAFE0005AC92 /* README */, ); name = Resources; sourceTree = ""; }; 08FB77AEFE84172EC02AAC07 /* Library */ = { isa = PBXGroup; children = ( 98D9E40F0E3E269700B046DD /* vmmlib.hpp */, 9868345D0E24F97D00618F55 /* vmmlib_config.hpp */, 98F556320E2437540044BA3E /* matrix.hpp */, 98B7A3F00E24EAA30064264E /* matrix_functors.hpp */, 9868345B0E24F8F300618F55 /* vector.hpp */, 98D402D30E38D6A000B24DF1 /* quaternion.hpp */, CF42E65B125F7F2100C0A38E /* matrix_pseudoinverse.hpp */, 98596E640FB48941006CA0F8 /* advanced */, 98596E630FB48923006CA0F8 /* misc */, 98596E740FB489AC006CA0F8 /* frustum */, 984763FD110DDB210024A1F8 /* tensor */, CFF0C1F11406E4BA00C3ADDB /* blas */, 9839FE5C0E2BB59800A16721 /* lapack */, 984F581111B8CFB50027D673 /* boost la */, ); name = Library; sourceTree = ""; }; 9839FE5C0E2BB59800A16721 /* lapack */ = { isa = PBXGroup; children = ( 9839FE5D0E2BB5B300A16721 /* vmmlib_lapack_main.cpp */, 982449FD0E3F584A0018E13A /* lapack.hpp */, 98584AF50E643AEC00314C4C /* lapack_types.hpp */, 98584B140E643BFC00314C4C /* lapack_includes.hpp */, 982449FC0E3F584A0018E13A /* lapack_linear_least_squares.hpp */, 982449FB0E3F584A0018E13A /* lapack_svd.hpp */, 9863B6E711903E5D00887FFC /* lapack_gaussian_elimination.hpp */, CFF952C41312B52C00071FB3 /* lapack_sym_eigs.hpp */, ); name = lapack; sourceTree = ""; }; 984763FD110DDB210024A1F8 /* tensor */ = { isa = PBXGroup; children = ( 984763FE110DDB3C0024A1F8 /* tensor3.hpp */, CF2DD25B126C8E530036DE05 /* tensor3_iterator.hpp */, CF7FA84C114AAC01003076E4 /* tucker3_tensor.hpp */, CF0647971446DE52007DD062 /* qtucker3_tensor.hpp */, CF0647981446E152007DD062 /* tucker3_exporter.hpp */, CF06479A1446E17B007DD062 /* tucker3_importer.hpp */, CF2DD1EF126C7A4A0036DE05 /* cp3_tensor.hpp */, CFD85BC61398E2A100266D85 /* t3_hosvd.hpp */, CFD85BC71398E2BE00266D85 /* t3_hooi.hpp */, CFD85BC81398E2D400266D85 /* t3_hopm.hpp */, CFA7FE00142242BD001EE112 /* t3_ihopm.hpp */, ); name = tensor; sourceTree = ""; }; 984F581111B8CFB50027D673 /* boost la */ = { isa = PBXGroup; children = ( 984F581211B8CFD90027D673 /* vector_traits.hpp */, 984F581311B8CFD90027D673 /* matrix_traits.hpp */, ); name = "boost la"; sourceTree = ""; }; 98596E630FB48923006CA0F8 /* misc */ = { isa = PBXGroup; children = ( 985964770FB177A6006CA0F8 /* math.hpp */, 98596E620FB4891E006CA0F8 /* enable_if.hpp */, 98D4102C0E2658FE00BEFA71 /* exception.hpp */, ); name = misc; sourceTree = ""; }; 98596E640FB48941006CA0F8 /* advanced */ = { isa = PBXGroup; children = ( 98F556330E2437540044BA3E /* qr_decomposition.hpp */, 9839FA1D0E2B5A6C00A16721 /* svd.hpp */, 98596E730FB4897C006CA0F8 /* jacobi_solver.hpp */, ); name = advanced; sourceTree = ""; }; 98596E740FB489AC006CA0F8 /* frustum */ = { isa = PBXGroup; children = ( 98D9E4110E3E26E000B046DD /* frustum.hpp */, 98596E840FB489D4006CA0F8 /* frustum_culler.hpp */, 98D9E4C10E3E314700B046DD /* visibility.hpp */, ); name = frustum; sourceTree = ""; }; 988F58330C22C0720005AC92 /* Tests */ = { isa = PBXGroup; children = ( 98B7A24D0E24C8750064264E /* unit testing */, 98B7A24F0E24C87E0064264E /* performance testing */, ); name = Tests; sourceTree = ""; }; 98B7A24D0E24C8750064264E /* unit testing */ = { isa = PBXGroup; children = ( 98B7A2500E24C8E70064264E /* vmmlib_unit_tests_main.cpp */, 98FE7DCE0E224EC400B1E17F /* unit_test.hpp */, 98FE7DCD0E224EC400B1E17F /* unit_test.cpp */, 98B7A2620E24CA760064264E /* unit tests */, ); name = "unit testing"; sourceTree = ""; }; 98B7A24F0E24C87E0064264E /* performance testing */ = { isa = PBXGroup; children = ( 98B7A2510E24C8E70064264E /* vmmlib_performance_tests_main.cpp */, 98B7A2690E24CB140064264E /* performance_test.hpp */, 98B7A2680E24CB140064264E /* performance_test.cpp */, 98B7A2550E24C9540064264E /* timer.hpp */, 98B7A2560E24C9540064264E /* timer.cpp */, 98B7A2A20E24DF7A0064264E /* performance tests */, ); name = "performance testing"; sourceTree = ""; }; 98B7A2620E24CA760064264E /* unit tests */ = { isa = PBXGroup; children = ( 98F556360E24377F0044BA3E /* matrix_test.hpp */, 98F556350E24377F0044BA3E /* matrix_test.cpp */, 986834C00E24FFD400618F55 /* vector_test.hpp */, 986834BF0E24FFD400618F55 /* vector_test.cpp */, 98D402D50E38D6A000B24DF1 /* quaternion_test.hpp */, 98D402D40E38D6A000B24DF1 /* quaternion_test.cpp */, 98B22A270FB8353900EEDF5F /* frustum_test.hpp */, 98B22A260FB8353900EEDF5F /* frustum_test.cpp */, 98F556380E24377F0044BA3E /* qr_decomposition_test.hpp */, 98F556370E24377F0044BA3E /* qr_decomposition_test.cpp */, 9839FA230E2B5BBB00A16721 /* svd_test.hpp */, 9839FA220E2B5BBB00A16721 /* svd_test.cpp */, 98B230720FB985D700EEDF5F /* jacobi_test.hpp */, 98B230710FB985D700EEDF5F /* jacobi_test.cpp */, 98244A3C0E3F5AEE0018E13A /* lapack_svd_test.hpp */, 98244A3B0E3F5AEE0018E13A /* lapack_svd_test.cpp */, 98244A3E0E3F5AEE0018E13A /* lapack_linear_least_squares_test.hpp */, 98244A3D0E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp */, 9863B6F011903EFE00887FFC /* lapack_gaussian_elimination_test.hpp */, 9863B6F111903EFE00887FFC /* lapack_gaussian_elimination_test.cpp */, CFF95531131CECD100071FB3 /* lapack_sym_eigs_test.hpp */, CFF95532131CECD100071FB3 /* lapack_sym_eigs_test.cpp */, CF42E5E7125F736E00C0A38E /* matrix_pseudoinverse_test.hpp */, CF42E5E9125F738600C0A38E /* matrix_pseudoinverse_test.cpp */, 98476418110DDB940024A1F8 /* tensor3_test.hpp */, 98476417110DDB940024A1F8 /* tensor3_test.cpp */, CF2DD25C126C8EAE0036DE05 /* tensor3_iterator_test.hpp */, CF2DD25D126C8EAE0036DE05 /* tensor3_iterator_test.cpp */, CF7FA8D9114EB696003076E4 /* tucker3_tensor_test.hpp */, CF7FA8D4114EB617003076E4 /* tucker3_tensor_test.cpp */, CF0649C614472249007DD062 /* qtucker3_tensor_test.hpp */, CF0649C714472249007DD062 /* qtucker3_tensor_test.cpp */, CF06479D1446E4B7007DD062 /* tucker3_exporter_importer_test.hpp */, CF06479E1446E4B7007DD062 /* tucker3_exporter_importer_test.cpp */, CF2DD263126C91670036DE05 /* cp3_tensor_test.hpp */, CF2DD264126C91670036DE05 /* cp3_tensor_test.cpp */, CFD85C531399060300266D85 /* t3_hosvd_test.hpp */, CFD85C541399060300266D85 /* t3_hosvd_test.cpp */, CFD85C7F139909EF00266D85 /* t3_hooi_test.hpp */, CFD85C80139909EF00266D85 /* t3_hooi_test.cpp */, CFD85C8213990A0E00266D85 /* t3_hopm_test.hpp */, CFD85C8313990A0E00266D85 /* t3_hopm_test.cpp */, CFA7FE4914225C03001EE112 /* t3_ihopm_test.hpp */, CFA7FE4A14225C03001EE112 /* t3_ihopm_test.cpp */, CFF0C1F91406E55200C3ADDB /* blas_dgemm_test.hpp */, CFF0C1F81406E55200C3ADDB /* blas_dgemm_test.cpp */, CF75FFF31432383D00CFD46E /* blas_dot_test.hpp */, CF75FFF41432383D00CFD46E /* blas_dot_test.cpp */, ); name = "unit tests"; sourceTree = ""; }; 98B7A2A20E24DF7A0064264E /* performance tests */ = { isa = PBXGroup; children = ( 98B7A2A40E24DF910064264E /* matrix_compare_perf_test.hpp */, 98B7A2A30E24DF910064264E /* matrix_compare_perf_test.cpp */, 9839FEF70E2BC67400A16721 /* svd_lapack_vs_old.hpp */, 9839FEF60E2BC67400A16721 /* svd_lapack_vs_old.cpp */, ); name = "performance tests"; sourceTree = ""; }; CFF0C1F11406E4BA00C3ADDB /* blas */ = { isa = PBXGroup; children = ( CFF0C1F21406E4DC00C3ADDB /* blas_dgemm.hpp */, CF75FFD11432315C00CFD46E /* blas_dot.hpp */, CFF0C1F31406E4DC00C3ADDB /* blas_includes.hpp */, CFF0C1F41406E4DC00C3ADDB /* blas_types.hpp */, ); name = blas; sourceTree = ""; }; /* End PBXGroup section */ /* Begin PBXNativeTarget section */ 9839FE1E0E2BB24700A16721 /* vmmlib_lapack_test */ = { isa = PBXNativeTarget; buildConfigurationList = 9839FE470E2BB26400A16721 /* Build configuration list for PBXNativeTarget "vmmlib_lapack_test" */; buildPhases = ( 9839FE1C0E2BB24700A16721 /* Sources */, 9839FE1D0E2BB24700A16721 /* Frameworks */, ); buildRules = ( ); dependencies = ( ); name = vmmlib_lapack_test; productName = vmmlib_lapack_test; productReference = 9839FE1F0E2BB24700A16721 /* vmmlib_lapack_test */; productType = "com.apple.product-type.tool"; }; 98B7A2480E24C85C0064264E /* vmmlib_performance_tests */ = { isa = PBXNativeTarget; buildConfigurationList = 98B7A24E0E24C8750064264E /* Build configuration list for PBXNativeTarget "vmmlib_performance_tests" */; buildPhases = ( 98B7A2460E24C85C0064264E /* Sources */, 98B7A2470E24C85C0064264E /* Frameworks */, ); buildRules = ( ); dependencies = ( ); name = vmmlib_performance_tests; productName = vmmlib_performance_tests; productReference = 98B7A2490E24C85C0064264E /* vmmlib_performance_tests */; productType = "com.apple.product-type.tool"; }; 98FE7DC40E224E8700B1E17F /* vmmlib_unit_tests */ = { isa = PBXNativeTarget; buildConfigurationList = 98FE7DCA0E224E9800B1E17F /* Build configuration list for PBXNativeTarget "vmmlib_unit_tests" */; buildPhases = ( 98FE7DC20E224E8700B1E17F /* Sources */, 98FE7DC30E224E8700B1E17F /* Frameworks */, ); buildRules = ( ); dependencies = ( ); name = vmmlib_unit_tests; productName = vmmlib_unit_tests; productReference = 98FE7DC50E224E8700B1E17F /* vmmlib_unit_tests */; productType = "com.apple.product-type.tool"; }; /* End PBXNativeTarget section */ /* Begin PBXProject section */ 0867D690FE84028FC02AAC07 /* Project object */ = { isa = PBXProject; buildConfigurationList = 1DEB91B108733DA50010E9CD /* Build configuration list for PBXProject "vmmlib" */; compatibilityVersion = "Xcode 2.4"; developmentRegion = English; hasScannedForEncodings = 1; knownRegions = ( English, Japanese, French, German, ); mainGroup = 0867D691FE84028FC02AAC07 /* VMMLib */; productRefGroup = 034768DFFF38A50411DB9C8B /* Products */; projectDirPath = ""; projectRoot = ""; targets = ( 98FE7DC40E224E8700B1E17F /* vmmlib_unit_tests */, 98B7A2480E24C85C0064264E /* vmmlib_performance_tests */, 9839FE1E0E2BB24700A16721 /* vmmlib_lapack_test */, ); }; /* End PBXProject section */ /* Begin PBXSourcesBuildPhase section */ 9839FE1C0E2BB24700A16721 /* Sources */ = { isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( 9839FE5E0E2BB5B300A16721 /* vmmlib_lapack_main.cpp in Sources */, 9839FEF80E2BC67400A16721 /* svd_lapack_vs_old.cpp in Sources */, 9839FF000E2BC75D00A16721 /* performance_test.cpp in Sources */, 9839FF020E2BC76600A16721 /* timer.cpp in Sources */, 98D402D60E38D6A000B24DF1 /* quaternion_test.cpp in Sources */, 98244A330E3F5A5E0018E13A /* unit_test.cpp in Sources */, 98244A3F0E3F5AEE0018E13A /* lapack_svd_test.cpp in Sources */, 98244A400E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; 98B7A2460E24C85C0064264E /* Sources */ = { isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( 98B7A2540E24C8F40064264E /* vmmlib_performance_tests_main.cpp in Sources */, 98B7A2570E24C9540064264E /* timer.cpp in Sources */, 98B7A26A0E24CB140064264E /* performance_test.cpp in Sources */, 98B7A2A50E24DF910064264E /* matrix_compare_perf_test.cpp in Sources */, 986834C20E24FFD400618F55 /* vector_test.cpp in Sources */, 9839FA250E2B5BBB00A16721 /* svd_test.cpp in Sources */, 98FAB2960E30CDF400C1A8FC /* unit_test.cpp in Sources */, 98D402D80E38D6A000B24DF1 /* quaternion_test.cpp in Sources */, 98244A430E3F5AEE0018E13A /* lapack_svd_test.cpp in Sources */, 98244A440E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; 98FE7DC20E224E8700B1E17F /* Sources */ = { isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( 98FE7DCF0E224EC400B1E17F /* unit_test.cpp in Sources */, 98F5563A0E24377F0044BA3E /* matrix_test.cpp in Sources */, 98F5563B0E24377F0044BA3E /* qr_decomposition_test.cpp in Sources */, 98B7A2520E24C8E70064264E /* vmmlib_unit_tests_main.cpp in Sources */, 986834C10E24FFD400618F55 /* vector_test.cpp in Sources */, 9839FA240E2B5BBB00A16721 /* svd_test.cpp in Sources */, 98D402D70E38D6A000B24DF1 /* quaternion_test.cpp in Sources */, 98244A410E3F5AEE0018E13A /* lapack_svd_test.cpp in Sources */, 98244A420E3F5AEE0018E13A /* lapack_linear_least_squares_test.cpp in Sources */, 98B22A280FB8353900EEDF5F /* frustum_test.cpp in Sources */, 98B230730FB985D700EEDF5F /* jacobi_test.cpp in Sources */, 98476419110DDB940024A1F8 /* tensor3_test.cpp in Sources */, CF7FA8D5114EB617003076E4 /* tucker3_tensor_test.cpp in Sources */, 9863B6F211903EFE00887FFC /* lapack_gaussian_elimination_test.cpp in Sources */, CF42E5EA125F738600C0A38E /* matrix_pseudoinverse_test.cpp in Sources */, CF2DD25E126C8EAE0036DE05 /* tensor3_iterator_test.cpp in Sources */, CF2DD265126C91670036DE05 /* cp3_tensor_test.cpp in Sources */, CFF95533131CECD100071FB3 /* lapack_sym_eigs_test.cpp in Sources */, CFD85C551399060300266D85 /* t3_hosvd_test.cpp in Sources */, CFD85C81139909EF00266D85 /* t3_hooi_test.cpp in Sources */, CFD85C8413990A0E00266D85 /* t3_hopm_test.cpp in Sources */, CFF0C1FA1406E55200C3ADDB /* blas_dgemm_test.cpp in Sources */, CFA7FE4B14225C03001EE112 /* t3_ihopm_test.cpp in Sources */, CF75FFF51432383D00CFD46E /* blas_dot_test.cpp in Sources */, CF06479F1446E4B7007DD062 /* tucker3_exporter_importer_test.cpp in Sources */, CF0649C814472249007DD062 /* qtucker3_tensor_test.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXSourcesBuildPhase section */ /* Begin XCBuildConfiguration section */ 1DEB91B208733DA50010E9CD /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { ARCHS = ( ppc, ppc64, i386, x86_64, ); GCC_WARN_ABOUT_RETURN_TYPE = YES; GCC_WARN_UNUSED_VARIABLE = YES; PREBINDING = NO; SDKROOT = ""; USER_HEADER_SEARCH_PATHS = "$(SRCROOT)/include"; }; name = Debug; }; 1DEB91B308733DA50010E9CD /* Release */ = { isa = XCBuildConfiguration; buildSettings = { ARCHS = ( ppc, ppc64, i386, x86_64, ); GCC_OPTIMIZATION_LEVEL = 3; GCC_WARN_ABOUT_RETURN_TYPE = YES; GCC_WARN_UNUSED_VARIABLE = YES; PREBINDING = NO; SDKROOT = ""; USER_HEADER_SEARCH_PATHS = "$(SRCROOT)/include"; }; name = Release; }; 9839FE210E2BB24800A16721 /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { COPY_PHASE_STRIP = NO; GCC_DYNAMIC_NO_PIC = NO; GCC_ENABLE_FIX_AND_CONTINUE = YES; GCC_MODEL_TUNING = G5; GCC_OPTIMIZATION_LEVEL = 0; GCC_PREPROCESSOR_DEFINITIONS = VMMLIB_NO_TYPEDEFS; INSTALL_PATH = /usr/local/bin; PREBINDING = NO; PRODUCT_NAME = vmmlib_lapack_test; ZERO_LINK = YES; }; name = Debug; }; 9839FE220E2BB24800A16721 /* Release */ = { isa = XCBuildConfiguration; buildSettings = { COPY_PHASE_STRIP = YES; DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; GCC_ENABLE_FIX_AND_CONTINUE = NO; GCC_MODEL_TUNING = G5; GCC_OPTIMIZATION_LEVEL = 3; GCC_PREPROCESSOR_DEFINITIONS = VMMLIB_NO_TYPEDEFS; INSTALL_PATH = /usr/local/bin; OTHER_CFLAGS = ""; PREBINDING = NO; PRODUCT_NAME = vmmlib_lapack_test; ZERO_LINK = NO; }; name = Release; }; 98B7A24B0E24C85C0064264E /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { COPY_PHASE_STRIP = NO; GCC_DYNAMIC_NO_PIC = NO; GCC_ENABLE_FIX_AND_CONTINUE = YES; GCC_MODEL_TUNING = G5; GCC_OPTIMIZATION_LEVEL = 0; GCC_PREPROCESSOR_DEFINITIONS = VMMLIB_NO_TYPEDEFS; INSTALL_PATH = /usr/local/bin; PREBINDING = NO; PRODUCT_NAME = vmmlib_performance_tests; ZERO_LINK = YES; }; name = Debug; }; 98B7A24C0E24C85C0064264E /* Release */ = { isa = XCBuildConfiguration; buildSettings = { COPY_PHASE_STRIP = YES; DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; GCC_ENABLE_FIX_AND_CONTINUE = NO; GCC_MODEL_TUNING = G5; GCC_PREPROCESSOR_DEFINITIONS = VMMLIB_NO_TYPEDEFS; INSTALL_PATH = /usr/local/bin; OTHER_CFLAGS = "-DNDEBUG"; PREBINDING = NO; PRODUCT_NAME = vmmlib_performance_tests; ZERO_LINK = NO; }; name = Release; }; 98FE7DC70E224E8800B1E17F /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { COPY_PHASE_STRIP = NO; GCC_DYNAMIC_NO_PIC = NO; GCC_ENABLE_FIX_AND_CONTINUE = YES; GCC_MODEL_TUNING = G5; GCC_OPTIMIZATION_LEVEL = 0; GCC_PREPROCESSOR_DEFINITIONS = ( VMMLIB_USE_BLAS, VMMLIB_USE_LAPACK, ); INSTALL_PATH = /usr/local/bin; ONLY_ACTIVE_ARCH = YES; PREBINDING = NO; PRODUCT_NAME = vmmlib_unit_tests; ZERO_LINK = YES; }; name = Debug; }; 98FE7DC80E224E8800B1E17F /* Release */ = { isa = XCBuildConfiguration; buildSettings = { COPY_PHASE_STRIP = YES; DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; GCC_ENABLE_FIX_AND_CONTINUE = NO; GCC_MODEL_TUNING = G5; GCC_PREPROCESSOR_DEFINITIONS = ""; INSTALL_PATH = /usr/local/bin; ONLY_ACTIVE_ARCH = YES; PREBINDING = NO; PRODUCT_NAME = vmmlib_unit_tests; ZERO_LINK = NO; }; name = Release; }; /* End XCBuildConfiguration section */ /* Begin XCConfigurationList section */ 1DEB91B108733DA50010E9CD /* Build configuration list for PBXProject "vmmlib" */ = { isa = XCConfigurationList; buildConfigurations = ( 1DEB91B208733DA50010E9CD /* Debug */, 1DEB91B308733DA50010E9CD /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; 9839FE470E2BB26400A16721 /* Build configuration list for PBXNativeTarget "vmmlib_lapack_test" */ = { isa = XCConfigurationList; buildConfigurations = ( 9839FE210E2BB24800A16721 /* Debug */, 9839FE220E2BB24800A16721 /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; 98B7A24E0E24C8750064264E /* Build configuration list for PBXNativeTarget "vmmlib_performance_tests" */ = { isa = XCConfigurationList; buildConfigurations = ( 98B7A24B0E24C85C0064264E /* Debug */, 98B7A24C0E24C85C0064264E /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; 98FE7DCA0E224E9800B1E17F /* Build configuration list for PBXNativeTarget "vmmlib_unit_tests" */ = { isa = XCConfigurationList; buildConfigurations = ( 98FE7DC70E224E8800B1E17F /* Debug */, 98FE7DC80E224E8800B1E17F /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; /* End XCConfigurationList section */ }; rootObject = 0867D690FE84028FC02AAC07 /* Project object */; } vmmlib-1.0/README0000644000175000017500000000033611674116156013066 0ustar shevekshevekVMMLib is a small templatized vector and matrix math library. License: (revised) BSD VMMLib depends on LAPACK and BLAS, if you just want to use VMMLib basic without depending on LAPACK/BLAS, enable VMMLIB_BASIC_ONLY.