PyLinear-0.91/0000755000175000001440000000000010135231541012733 5ustar akusers00000000000000PyLinear-0.91/3rdparty/0000755000175000001440000000000010135231541014503 5ustar akusers00000000000000PyLinear-0.91/3rdparty/arpack/0000755000175000001440000000000010135231541015744 5ustar akusers00000000000000PyLinear-0.91/3rdparty/arpack/arpack_proto.h0000644000175000001440000002262310135202257020610 0ustar akusers00000000000000/* ARPACK++ v1.0 8/1/1997 c++ interface to ARPACK code. MODULE arpackf.h ARPACK FORTRAN routines. ARPACK Authors Richard Lehoucq Danny Sorensen Chao Yang Dept. of Computational & Applied Mathematics Rice University Houston, Texas Slightly modified for PyLinear by Andreas Kloeckner 2003. */ #ifndef ARPACKF_H #define ARPACKF_H #include typedef int integer; typedef int logical; #define ARPACK_F77NAME(x) x##_ extern "C" { // debug "common" statement. struct { integer logfil, ndigit, mgetv0; integer msaupd, msaup2, msaitr, mseigt, msapps, msgets, mseupd; integer mnaupd, mnaup2, mnaitr, mneigt, mnapps, mngets, mneupd; integer mcaupd, mcaup2, mcaitr, mceigt, mcapps, mcgets, mceupd; } ARPACK_F77NAME(debug); // double precision symmetric routines. void ARPACK_F77NAME(dsaupd)(integer *ido, char *bmat, integer *n, char *which, integer *nev, double *tol, double *resid, integer *ncv, double *V, integer *ldv, integer *iparam, integer *ipntr, double *workd, double *workl, integer *lworkl, integer *info); void ARPACK_F77NAME(dseupd)(logical *rvec, char *HowMny, logical *select, double *d, double *Z, integer *ldz, double *sigma, char *bmat, integer *n, char *which, integer *nev, double *tol, double *resid, integer *ncv, double *V, integer *ldv, integer *iparam, integer *ipntr, double *workd, double *workl, integer *lworkl, integer *info); // double precision nonsymmetric routines. void ARPACK_F77NAME(dnaupd)(integer *ido, char *bmat, integer *n, char *which, integer *nev, double *tol, double *resid, integer *ncv, double *V, integer *ldv, integer *iparam, integer *ipntr, double *workd, double *workl, integer *lworkl, integer *info); void ARPACK_F77NAME(dneupd)(logical *rvec, char *HowMny, logical *select, double *dr, double *di, double *Z, integer *ldz, double *sigmar, double *sigmai, double *workev, char *bmat, integer *n, char *which, integer *nev, double *tol, double *resid, integer *ncv, double *V, integer *ldv, integer *iparam, integer *ipntr, double *workd, double *workl, integer *lworkl, integer *info); // single precision symmetric routines. void ARPACK_F77NAME(ssaupd)(integer *ido, char *bmat, integer *n, char *which, integer *nev, float *tol, float *resid, integer *ncv, float *V, integer *ldv, integer *iparam, integer *ipntr, float *workd, float *workl, integer *lworkl, integer *info); void ARPACK_F77NAME(sseupd)(logical *rvec, char *HowMny, logical *select, float *d, float *Z, integer *ldz, float *sigma, char *bmat, integer *n, char *which, integer *nev, float *tol, float *resid, integer *ncv, float *V, integer *ldv, integer *iparam, integer *ipntr, float *workd, float *workl, integer *lworkl, integer *info); // single precision nonsymmetric routines. void ARPACK_F77NAME(snaupd)(integer *ido, char *bmat, integer *n, char *which, integer *nev, float *tol, float *resid, integer *ncv, float *V, integer *ldv, integer *iparam, integer *ipntr, float *workd, float *workl, integer *lworkl, integer *info); void ARPACK_F77NAME(sneupd)(logical *rvec, char *HowMny, logical *select, float *dr, float *di, float *Z, integer *ldz, float *sigmar, float *sigmai, float *workev, char *bmat, integer *n, char *which, integer *nev, float *tol, float *resid, integer *ncv, float *V, integer *ldv, integer *iparam, integer *ipntr, float *workd, float *workl, integer *lworkl, integer *info); // single precision complex routines. void ARPACK_F77NAME(cnaupd)(integer *ido, char *bmat, integer *n, char *which, integer *nev, float *tol, std::complex *resid, integer *ncv, std::complex *V, integer *ldv, integer *iparam, integer *ipntr, std::complex *workd, std::complex *workl, integer *lworkl, float *rwork, integer *info); void ARPACK_F77NAME(cneupd)(logical *rvec, char *HowMny, logical *select, std::complex *d, std::complex *Z, integer *ldz, std::complex *sigma, std::complex *workev, char *bmat, integer *n, char *which, integer *nev, float *tol, std::complex *resid, integer *ncv, std::complex *V, integer *ldv, integer *iparam, integer *ipntr, std::complex *workd, std::complex *workl, integer *lworkl, float *rwork, integer *info); // double precision complex routines. void ARPACK_F77NAME(znaupd)(integer *ido, char *bmat, integer *n, char *which, integer *nev, double *tol, std::complex *resid, integer *ncv, std::complex *V, integer *ldv, integer *iparam, integer *ipntr, std::complex *workd, std::complex *workl, integer *lworkl, double *rwork, integer *info); void ARPACK_F77NAME(zneupd)(logical *rvec, char *HowMny, logical *select, std::complex *d, std::complex *Z, integer *ldz, std::complex *sigma, std::complex *workev, char *bmat, integer *n, char *which, integer *nev, double *tol, std::complex *resid, integer *ncv, std::complex *V, integer *ldv, integer *iparam, integer *ipntr, std::complex *workd, std::complex *workl, integer *lworkl, double *rwork, integer *info); } namespace arpack { #define DECLARE_NAUPD(TYPE, BASETYPE) \ inline void naupd(integer *ido, char *bmat, integer *n, char *which, \ /*5*/integer *nev, BASETYPE *tol, TYPE *resid, \ /*9*/integer *ncv, TYPE *V, integer *ldv, \ /*12*/integer *iparam, integer *ipntr, TYPE *workd, \ /*15*/TYPE *workl, integer *lworkl, \ BASETYPE *rwork, integer *info) #define DEFINE_REAL_NAUPD(BASETYPE, LETTER) \ DECLARE_NAUPD(BASETYPE, BASETYPE) \ { \ ARPACK_F77NAME(LETTER##naupd)(ido, bmat, n, which, nev, tol, resid, ncv, V, ldv, iparam, ipntr, workd, workl, \ lworkl, info); \ } #define DEFINE_COMPLEX_NAUPD(BASETYPE, LETTER) \ DECLARE_NAUPD(std::complex, BASETYPE) \ { \ ARPACK_F77NAME(LETTER##naupd)(ido, bmat, n, which, nev, tol, resid, ncv, V, ldv, iparam, ipntr, workd, workl, \ lworkl, rwork, info); \ } #define DECLARE_NEUPD(TYPE, BASETYPE) \ inline void neupd(logical *rvec, char *HowMny, logical *select, \ /*4*/std::complex *d, TYPE *Z, integer *ldz, \ /*7*/std::complex *sigma, TYPE *workev, \ /*9*/char *bmat, integer *n, char *which, integer *nev, \ /*13*/BASETYPE *tol, TYPE *resid, integer *ncv, \ TYPE *V, integer *ldv, integer *iparam, \ integer *ipntr, TYPE *workd, \ TYPE *workl, integer *lworkl, \ BASETYPE *rwork, integer *info) \ #define DEFINE_REAL_NEUPD(BASETYPE, LETTER) \ DECLARE_NEUPD(BASETYPE, BASETYPE) \ { \ BASETYPE d_real[*nev+1]; \ BASETYPE d_imag[*nev+1]; \ BASETYPE sigma_real = std::real(*sigma); \ BASETYPE sigma_imag = std::imag(*sigma); \ ARPACK_F77NAME(LETTER##neupd)(rvec, HowMny, select, d_real, d_imag, Z, ldz, \ &sigma_real, &sigma_imag, workev, bmat, n, which, nev, \ tol, resid, ncv, V, ldv, iparam, ipntr, workd, workl, lworkl, \ info); \ for (int i = 0; i < *nev+1; i++) \ d[i] = std::complex(d_real[i], d_imag[i]); \ } #define DEFINE_COMPLEX_NEUPD(BASETYPE, LETTER) \ DECLARE_NEUPD(std::complex, BASETYPE) \ { \ ARPACK_F77NAME(LETTER##neupd)(rvec, HowMny, select, d, Z, ldz, sigma, workev, bmat, n, which, nev, \ tol, resid, ncv, V, ldv, iparam, ipntr, workd, workl, lworkl, rwork, \ info); \ } DEFINE_REAL_NAUPD(float, s); DEFINE_REAL_NAUPD(double, d); DEFINE_COMPLEX_NAUPD(float, c); DEFINE_COMPLEX_NAUPD(double, z); DEFINE_REAL_NEUPD(float, s); DEFINE_REAL_NEUPD(double, d); DEFINE_COMPLEX_NEUPD(float, c); DEFINE_COMPLEX_NEUPD(double, z); } #endif // ARPACKF_H PyLinear-0.91/algorithms/0000755000175000001440000000000010135231541015104 5ustar akusers00000000000000PyLinear-0.91/algorithms/arpack.hpp0000644000175000001440000002551210135202257017065 0ustar akusers00000000000000#ifndef HEADER_SEEN_ARPACK_HPP #define HEADER_SEEN_ARPACK_HPP #include #include #include #include namespace arpack { namespace ublas = boost::numeric::ublas; enum which_eigenvalues { LARGEST_MAGNITUDE, SMALLEST_MAGNITUDE, LARGEST_REAL_PART, SMALLEST_REAL_PART, LARGEST_IMAGINARY_PART, SMALLEST_IMAGINARY_PART }; namespace detail { const char *mapWhichToString(which_eigenvalues we) { switch (we) { case LARGEST_MAGNITUDE: return "LM"; case SMALLEST_MAGNITUDE: return "SM"; case LARGEST_REAL_PART: return "LR"; case SMALLEST_REAL_PART: return "SR"; case LARGEST_IMAGINARY_PART: return "LI"; case SMALLEST_IMAGINARY_PART: return "SI"; default: throw std::runtime_error("arpack: invalid eigenvalue selector"); } } } enum arpack_mode { REGULAR_NON_GENERALIZED = 1, REGULAR_GENERALIZED = 2, SHIFT_AND_INVERT_GENERALIZED = 3 }; template struct results { typedef std::vector > value_container; typedef std::vector > > vector_container; value_container m_ritz_values; vector_container m_ritz_vectors; }; namespace detail { template results *makeResults(unsigned nconv, unsigned n, BaseType *z, std::complex *d) { // result generation for real types // slightly more complicated: take care of complex conjugate pairs std::auto_ptr > my_results(new results); unsigned i = 0; while (i < nconv) { if (imag(d[i]) != 0) { // complex-conjugate pair if (i + 1 >= nconv) throw std::runtime_error("arpack: complex pair split up"); my_results->m_ritz_values.push_back(d[i]); my_results->m_ritz_values.push_back(d[i+1]); ublas::vector > ritz_vector(n); for (unsigned j = 0; j < n; j++) ritz_vector[j] = std::complex(z[i*n + j], z[(i+1)*n +j]); my_results->m_ritz_vectors.push_back(ritz_vector); my_results->m_ritz_vectors.push_back(conj(ritz_vector)); i += 2; } else { // real eigenvalue, single eigenvector my_results->m_ritz_values.push_back(d[i]); ublas::vector > ritz_vector(n); for (unsigned j = 0; j < n; j++) ritz_vector[j] = z[i*n + j]; my_results->m_ritz_vectors.push_back(ritz_vector); i++; } } return my_results.release(); } template results *makeResults(unsigned nconv, unsigned n, std::complex *z, std::complex *d) { // result generation for complex types std::auto_ptr > my_results(new results); // simple: just copy everything over. for (unsigned i = 0; i < nconv; i++) { my_results->m_ritz_values.push_back(d[i]); ublas::vector > ritz_vector(n); for (unsigned j = 0; j < n; j++) ritz_vector[j] = z[i*n + j]; my_results->m_ritz_vectors.push_back(ritz_vector); } return my_results.release(); } } template results::type> *doReverseCommunication( const matrix_operator &op, const matrix_operator &m, arpack_mode mode, std::complex::type> spectral_shift, int number_of_eigenvalues, int number_of_arnoldi_vectors, which_eigenvalues which_e = LARGEST_MAGNITUDE, typename helpers::decomplexify::type tolerance = 1e-8, bool m_is_identity = false, int max_iterations = 0 ) { typedef typename helpers::decomplexify::type base_type; typedef std::complex complex_type; int ido = 0; char bmat = m_is_identity ? 'I' : 'G'; int n = op.size1(); if ((unsigned) n != op.size2() || (unsigned) n != m.size1() || (unsigned) n != m.size2()) throw std::runtime_error("arpack: matrix sizes don't match."); char *which = const_cast(detail::mapWhichToString(which_e)); ValueType residual[n]; ValueType v[number_of_arnoldi_vectors * n]; int ldv = n; int iparam[11]; iparam[1-1] = 1; // exact shifts iparam[2-1] = 0; // unused iparam[3-1] = max_iterations != 0 ? max_iterations : 10000 * n; iparam[4-1] = 1; // block size iparam[5-1] = 0; // NCONV iparam[6-1] = 0; // IUPD, unused iparam[7-1] = mode; iparam[8-1] = 0; // NP, something to do with user-provided shifts iparam[9-1] = 0; // NUMOP iparam[10-1] = 0; // NUMOPB iparam[11-1] = 0; // NUMREO int info = 0; // we're not specifying a previous residual int ipntr[14]; ValueType workd[3*n]; int lworkl; if (helpers::isComplex(ValueType())) lworkl = 3 * number_of_arnoldi_vectors * number_of_arnoldi_vectors + 5 * number_of_arnoldi_vectors; else lworkl = 3 * number_of_arnoldi_vectors * number_of_arnoldi_vectors + 6 * number_of_arnoldi_vectors; ValueType workl[lworkl]; double rwork[number_of_arnoldi_vectors]; do { naupd( &ido, &bmat, &n, which, &number_of_eigenvalues, &tolerance, residual, &number_of_arnoldi_vectors, v, &ldv, iparam, ipntr, workd, workl, &lworkl, rwork, &info ); switch (info) { case 0: break; case 1: throw std::runtime_error("arpack, naupd: performed max. number of iterations (1)"); case 3: throw std::runtime_error("arpack, naupd: could not apply shifts (3)"); case -1: throw std::runtime_error("arpack, naupd: n not positive (-1)"); case -2: throw std::runtime_error("arpack, naupd: nev not positive (-2)"); case -3: throw std::runtime_error("arpack, naupd: ncv <= nev or ncv > n (-3)"); case -4: throw std::runtime_error("arpack, naupd: max_iterations must be bigger than zero (-4)"); case -5: throw std::runtime_error("arpack, naupd: invalid WHICH (-5)"); case -6: throw std::runtime_error("arpack, naupd: invalid BMAT (-6)"); case -7: throw std::runtime_error("arpack, naupd: work array too short (-7)"); case -8: throw std::runtime_error("arpack, naupd: LAPACK error (-8)"); case -9: throw std::runtime_error("arpack, naupd: starting vector is zero (-9)"); case -10: throw std::runtime_error("arpack, naupd: invalid MODE (-10)"); case -11: throw std::runtime_error("arpack, naupd: MODE and BMAT don't agree (-11)"); case -12: throw std::runtime_error("arpack, naupd: ISHIFT invalid (-12)"); default: throw std::runtime_error("arpack, naupd: invalid naupd error code"); } if (ido == -1 || ido == 1 || ido == 2) { // FIXME copying is not good ublas::vector operand, result; operand.resize(n); result.resize(n); ValueType *x = workd + ipntr[1-1] - 1; ValueType *y = workd + ipntr[2-1] - 1; for (int i = 0; i < n; i++) operand[i] = x[i]; if (ido == 2) m.apply(operand, result); else op.apply(operand, result); for (int i = 0; i < n; i++) y[i] = result[i]; } else if (ido == 99) /*nothing*/; else throw std::runtime_error("arpack: reverse communication failure"); } while (ido != 99); if (max_iterations != 0) { if (max_iterations <= iparam[2]) throw std::runtime_error("arpack: hit iteration count limit"); max_iterations -= iparam[2]; } { // prepare for call to neupd int rvec = 1; char howmny = 'A'; int select[number_of_arnoldi_vectors]; // no-op complex_type d[number_of_eigenvalues+1]; unsigned z_size; unsigned workev_size; if (helpers::isComplex(ValueType())) { z_size = number_of_eigenvalues; workev_size = 2*number_of_arnoldi_vectors; } else { z_size = number_of_eigenvalues+1; workev_size = 3*number_of_arnoldi_vectors; } ValueType z[z_size*n]; int ldz = n; ValueType workev[workev_size]; neupd( &rvec, &howmny, select, d, z, &ldz, &spectral_shift, workev, // naupd parameters follow &bmat, &n, which, &number_of_eigenvalues, &tolerance, residual, &number_of_arnoldi_vectors, v, &ldv, iparam, ipntr, workd, workl, &lworkl, rwork, &info ); switch (info) { case 0: break; case 1: throw std::runtime_error("arpack, neupd: schur form could not be reordered (1)"); case -1: throw std::runtime_error("arpack, neupd: n not positive (-1)"); case -2: throw std::runtime_error("arpack, neupd: nev not positive (-2)"); case -3: throw std::runtime_error("arpack, neupd: ncv <= nev or ncv > n (-3)"); case -5: throw std::runtime_error("arpack, neupd: invalid WHICH (-5)"); case -6: throw std::runtime_error("arpack, neupd: invalid BMAT (-6)"); case -7: throw std::runtime_error("arpack, neupd: work array too short (-7)"); case -8: throw std::runtime_error("arpack, neupd: LAPACK error (-8)"); case -9: throw std::runtime_error("arpack, neupd: LAPACK _trevc failed (-9)"); case -10: throw std::runtime_error("arpack, neupd: invalid MODE (-10)"); case -11: throw std::runtime_error("arpack, neupd: MODE and BMAT don't agree (-11)"); case -12: throw std::runtime_error("arpack, neupd: HOWNY = S invalid (-12)"); case -13: throw std::runtime_error("arpack, neupd: HOWNY and RVEC don't agree (-13)"); case -14: throw std::runtime_error("arpack, neupd: no eigenvalues found (-14)"); default: throw std::runtime_error("arpack, neupd: invalid neupd error code"); } unsigned nconv = iparam[5-1]; return detail::makeResults(nconv, n, z, d); } } } #endif PyLinear-0.91/algorithms/bicgstab.hpp0000644000175000001440000001042510135202257017377 0ustar akusers00000000000000#ifndef HEADER_SEEN_BICGSTAB_HPP #define HEADER_SEEN_BICGSTAB_HPP #include #include #include #include #include "helpers.hpp" #include "matrix_operator.hpp" namespace bicgstab { using namespace boost::numeric::ublas; template void solveBiCGSTAB(const MatrixExpression &A, const PreconditionerExpression &preconditioner, VectorTypeX &result, const VectorExpressionB &b, double tol, unsigned max_iterations, unsigned *iteration_count = NULL, unsigned debug_level = 0) { typedef typename MatrixExpression::value_type v_t; typedef typename helpers::decomplexify::type real_t; if (A().size1() != A().size2()) throw std::runtime_error("bicgstab: A is not quadratic"); if (debug_level >= 2) std::cout << "rhs:" << b << std::endl; // typed up from Figure 2.10 of // Templates for the Solution of Linear Systems: // Building Blocks for Iterative Methods // (Barrett, R., M. Berry, T. F. Chan, et al.) unsigned iterations = 0; // "next" refers to i // "" refers to i-1 // "last" refers to i-2 v_t rho, last_rho, alpha, omega; vector p, v, x(result); vector r(b-prod(A,x)); vector r_tilde(r); real_t initial_residual = norm_2(r); // silence "used uninitialized" warnings last_rho = 0; alpha = 0; while (iterations < max_iterations) { rho = inner_prod(conj(r_tilde), r); if (helpers::absolute_value(rho) == 0) throw std::runtime_error("bicgstab failed, rho == 0"); if (iterations == 0) { p = r; } else { v_t beta = (rho/last_rho)*(alpha/omega); p = r + beta*(p-omega*v); } vector p_hat = prod(preconditioner, p); v = prod(A, p_hat); alpha = rho/inner_prod(conj(r_tilde), v); vector s = r - alpha*v; { real_t norm_s = norm_2(s); if (norm_s < tol * initial_residual) { x += alpha*p_hat; break; } } vector s_hat = prod(preconditioner, s); vector t = prod(A, s_hat); omega = inner_prod(conj(t), s)/inner_prod(conj(t), t); x += alpha * p_hat + omega * s_hat; r = s - omega * t; { real_t norm_r = norm_2(r); if (norm_r < tol * initial_residual) break; } if (helpers::absolute_value(omega) == 0) throw std::runtime_error("bicgstab failed, omega == 0"); last_rho = rho; if (debug_level) { if (debug_level >= 2 || iterations % 10 == 0) std::cout << double(norm_2(r)) << std::endl; } iterations++; } result = x; if ( iterations == max_iterations) throw std::runtime_error("bicgstab failed to converge"); if (iteration_count) *iteration_count = iterations; } template class bicgstab_matrix_operator : public iterative_solver_matrix_operator { typedef matrix_operator mop_type; const mop_type &m_matrix; const mop_type &m_preconditioner; typedef iterative_solver_matrix_operator super; public: typedef typename super::vector_type vector_type; bicgstab_matrix_operator(const mop_type &mat, const mop_type &precon, unsigned maxit, double tol) : super(maxit, tol), m_matrix(mat), m_preconditioner(precon) { if (mat.size1() != mat.size2()) throw std::runtime_error("bicgstab: matrix has to be quadratic (and sym. pos. def.) to work with cg"); } unsigned size1() const { return m_matrix.size2(); } unsigned size2() const { return m_matrix.size1(); } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); solveBiCGSTAB(m_matrix, m_preconditioner, after, before, this->m_tolerance, this->m_maxIterations, const_cast(&this->m_lastIterationCount), this->m_debugLevel); } }; } #endif PyLinear-0.91/algorithms/cg.hpp0000644000175000001440000000665610135202257016225 0ustar akusers00000000000000#ifndef HEADER_SEEN_CG_HPP #define HEADER_SEEN_CG_HPP #include #include #include #include "helpers.hpp" #include "matrix_operator.hpp" namespace cg { using namespace boost::numeric::ublas; using namespace helpers; template void solveCG(const MatrixExpression &A, const PreconditionerExpression &preconditioner, VectorTypeX &x, const VectorExpressionB &b, double tol, unsigned max_iterations, unsigned *iteration_count = NULL, unsigned debug_level = 0) { typedef typename MatrixExpression::value_type v_t; if (A().size1() != A().size2()) throw std::runtime_error("cg: A is not quadratic"); // typed up from J.R. Shewchuck, // An Introduction to the Conjugate Gradient Method // Without the Agonizing Pain, Edition 1 1/4 [8/1994] // Appendix B4 unsigned iterations = 0; vector residual(b-prod(A,x)); vector d = prod(preconditioner, residual); v_t delta_new = inner_prod(residual, conj(d)); v_t delta_0 = delta_new; while (iterations < max_iterations) { vector q = prod(A, d); v_t alpha = delta_new / inner_prod(d, conj(q)); x += alpha * d; bool calculate_real_residual = iterations % 50 == 0 || \ absolute_value(delta_new) < tol*tol * absolute_value(delta_0); if (calculate_real_residual) residual = b - prod(A,x); else residual -= alpha*q; vector s = prod(preconditioner, residual); v_t delta_old = delta_new; delta_new = inner_prod(residual, conj(s)); if (calculate_real_residual && absolute_value(delta_new) < tol*tol * absolute_value(delta_0)) { // Only terminate the loop on the basis of a "real" residual. break; } v_t beta = delta_new / delta_old; d = s + beta * d; if (debug_level && iterations % 20 == 0) std::cout << delta_new << std::endl; iterations++; } if ( iterations == max_iterations) throw std::runtime_error("cg failed to converge"); if (iteration_count) *iteration_count = iterations; } template class cg_matrix_operator : public iterative_solver_matrix_operator { typedef matrix_operator mop_type; const mop_type &m_matrix; const mop_type &m_preconditioner; typedef iterative_solver_matrix_operator super; public: typedef typename super::vector_type vector_type; cg_matrix_operator(const mop_type &mat, const mop_type &precon, unsigned maxit, double tol) : super(maxit, tol), m_matrix(mat), m_preconditioner(precon) { if (mat.size1() != mat.size2()) throw std::runtime_error("cg: matrix has to be quadratic (and sym. pos. def.) to work with cg"); } unsigned size1() const { return m_matrix.size2(); } unsigned size2() const { return m_matrix.size1(); } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); cg::solveCG(m_matrix, m_preconditioner, after, before, this->m_tolerance, this->m_maxIterations, const_cast(&this->m_lastIterationCount), this->m_debugLevel); } }; } #endif PyLinear-0.91/algorithms/cholesky.hpp0000644000175000001440000000354510135202257017447 0ustar akusers00000000000000#ifndef HEADER_SEEN_CHOLESKY_HPP #define HEADER_SEEN_CHOLESKY_HPP #include #include #include #include "helpers.hpp" namespace cholesky { using namespace boost::numeric::ublas; using namespace helpers; inline double conj(double x) { return x; } inline double real(double x) { return x; } /** This routine only uses the lower-left half of A. */ template DesiredResult *cholesky(const MatrixExpression &A) { if (A().size1() != A().size2()) throw std::runtime_error("cholesky: A is not quadratic"); std::auto_ptr result(new DesiredResult(A().size1(), A().size2())); DesiredResult &L = *result; typedef typename MatrixExpression::size_type size_type; typedef typename MatrixExpression::value_type value_type; // FIXME: this is a quick prototype for (size_type col = 0; col < A().size2(); col++) { // determine diagonal element value_type sum = A()(col,col); for (size_type row = 0; row < col; row++) { value_type value = L(col,row); sum -= value*conj(value); } if (real(sum) < 0 && !helpers::isComplex(value_type())) throw std::runtime_error("cholesky: matrix not positive definite"); L(col,col) = sqrt(sum); // determine off-diagonal elements for (size_type row = col+1; row < A().size2(); row++) { sum = A()(row,col); for (size_type i = 0; i < col; i++) { // FIXME : casts needed due to bug in sparse uBLAS sum -= value_type(L(row,i))*value_type(conj(value_type(L(col,i)))); } L(row,col) = sum/value_type(L(col,col)); } } return result.release(); } } #endif PyLinear-0.91/algorithms/generic_ublas.hpp0000644000175000001440000002022710135202257020424 0ustar akusers00000000000000#ifndef HEADER_SEEN_GENERIC_UBLAS_HPP #define HEADER_SEEN_GENERIC_UBLAS_HPP #include #include #include #include #include namespace generic_ublas { namespace ublas = boost::numeric::ublas; namespace mpl = boost::mpl; namespace detail { class begin_tag { }; class end_tag { }; } template class minilist { public: typedef ValueType value_type; typedef unsigned size_type; private: ValueType m_list[MaxElements]; unsigned m_size; public: minilist() : m_size(0) { } minilist(const value_type &v0) : m_size(1) { m_list[0] = v0; } minilist(const value_type &v0, const value_type &v1) : m_size(2) { m_list[0] = v0; m_list[1] = v1; } size_type size() const { return m_size; } void push_back(const value_type &v) { #ifndef NDEBUG if (m_size == MaxElements) throw std::runtime_error("minilist has reached max size"); #endif m_list[m_size++] = v; } ValueType &operator[](size_type index) { return m_list[index]; } const ValueType &operator[](size_type index) const { return m_list[index]; } }; // is_vector ---------------------------------------------------------------- template struct is_vector { typedef mpl::false_ type; }; template struct is_vector > { typedef mpl::true_ type; }; template struct is_vector > { typedef mpl::true_ type; }; template struct is_vector > { typedef mpl::true_ type; }; template struct is_vector > { typedef mpl::true_ type; }; // matrix_iterator ---------------------------------------------------------- template ::type> class matrix_iterator : public boost::iterator_facade< matrix_iterator, // Base typename MatrixType::value_type, // Value boost::forward_traversal_tag, // CategoryOrTraversal typename MatrixType::iterator2::reference> // Reference { typedef typename MatrixType::iterator1 it1_t; typedef typename MatrixType::iterator2 it2_t; it1_t m_it1; it2_t m_it2; public: matrix_iterator() { } matrix_iterator(MatrixType &mat, detail::begin_tag) : m_it1(mat.begin1()), m_it2(m_it1.begin()) { validate(); } matrix_iterator(MatrixType &mat, detail::end_tag) : m_it1(mat.end1()), m_it2(m_it1.begin()) { } minilist index() const { return minilist(m_it2.index1(), m_it2.index2()); } private: friend class boost::iterator_core_access; void validate() { // this makes sure that the iterator points to an existing element while (m_it1 != m_it1().end1() && m_it2 == m_it1.end()) { m_it1++; m_it2 = m_it1.begin(); } } void increment() { m_it2++; validate(); } bool equal(matrix_iterator const& other) const { return m_it1 == other.m_it1 && m_it2 == other.m_it2; } typename MatrixType::iterator2::reference dereference() const { return *m_it2; } }; template class matrix_iterator : public boost::iterator_adaptor< matrix_iterator, typename MatrixType::iterator, typename MatrixType::value_type, boost::forward_traversal_tag, typename MatrixType::iterator::reference> { typedef boost::iterator_adaptor< matrix_iterator, typename MatrixType::iterator, typename MatrixType::value_type, boost::forward_traversal_tag, typename MatrixType::iterator::reference> super; public: matrix_iterator() { } matrix_iterator(MatrixType &mat, detail::begin_tag) : super(mat.begin()) { } matrix_iterator(MatrixType &mat, detail::end_tag) : super(mat.end()) { } matrix_iterator(const typename MatrixType::iterator &it) : super(it) { } minilist index() const { return minilist(this->base_reference().index()); } private: friend class boost::iterator_core_access; }; template matrix_iterator begin(MatrixType &mat) { return matrix_iterator(mat, detail::begin_tag()); } template matrix_iterator end(MatrixType &mat) { return matrix_iterator(mat, detail::end_tag()); } // shapes and subscripting -------------------------------------------------- namespace detail { template inline minilist getShape(const MatrixType &mat, mpl::false_) { return minilist(mat.size1(), mat.size2()); } template inline minilist getShape(const MatrixType &mat, mpl::true_) { return minilist(mat.size()); } } template inline minilist getShape(const MatrixType &mat) { return detail::getShape(mat, typename is_vector::type()); } namespace detail { template inline void setShape(MatrixType &mat, const minilist &shape, mpl::false_) { mat.resize(shape[0], shape[1]); } template inline void setShape(MatrixType &mat, const minilist &shape, mpl::true_) { mat.resize(shape[0]); } } template inline void setShape(MatrixType &mat, const minilist &shape) { detail::setShape(mat, shape, typename is_vector::type()); } namespace detail { template inline MatrixType *newWithShape(const minilist &shape, mpl::false_) { return new MatrixType(shape[0], shape[1]); } template inline MatrixType *newWithShape(const minilist &shape, mpl::true_) { return new MatrixType(shape[0]); } } template MatrixType *newWithShape(const minilist &shape) { return detail::newWithShape(shape, typename is_vector::type()); } namespace detail { template inline void insert( MatrixType &mat, const minilist &index, const typename MatrixType::value_type &value, mpl::false_) { mat.insert(index[0], index[1], value); } template inline void insert( MatrixType &mat, const minilist &index, const typename MatrixType::value_type &value, mpl::true_) { mat.insert(index[0], value); } } template inline void insert( MatrixType &mat, const minilist &index, const typename MatrixType::value_type &value) { detail::insert(mat,index, value, typename is_vector::type()); } namespace detail { template inline void set( MatrixType &mat, const minilist &index, const typename MatrixType::value_type &value, mpl::false_) { mat(index[0], index[1]) = value; } template inline void set( MatrixType &mat, const minilist &index, const typename MatrixType::value_type &value, mpl::true_) { mat[index[0]] = value; } } template inline void set( MatrixType &mat, const minilist &index, const typename MatrixType::value_type &value) { detail::set(mat,index, value, typename is_vector::type()); } } #endif PyLinear-0.91/algorithms/helpers.hpp0000644000175000001440000000642710135202257017272 0ustar akusers00000000000000#ifndef HEADER_SEEN_HELPERS_HPP #define HEADER_SEEN_HELPERS_HPP #include #include "managed_adaptors.hpp" #include "generic_ublas.hpp" #include namespace helpers { namespace ublas = boost::numeric::ublas; // decomplexify --------------------------------------------------------------- template struct decomplexify { typedef T type; }; template struct decomplexify > { typedef ELT type; }; // complexify ----------------------------------------------------------------- template struct complexify { typedef std::complex type; }; template struct complexify > { typedef std::complex type; }; // isComplex ------------------------------------------------------------------ template inline bool isComplex(const T &) { return false; } template inline bool isComplex(const std::complex &) { return true; } // isSparse ------------------------------------------------------------------- template inline bool isSparse(const T &) { return true; } template inline bool isSparse(const ublas::matrix &) { return false; } template inline bool isSparse(const ublas::vector &) { return false; } // isHermitian ---------------------------------------------------------------- template inline bool isHermitian(const MatrixType &) { return false; } template inline bool isHermitian(const managed_symmetric_adaptor &) { return true; } template inline bool isHermitian(const managed_hermitian_adaptor &) { return true; } // isCoordinateMatrix --------------------------------------------------------- template inline bool isCoordinateMatrix(const MatrixType &) { return false; } template inline bool isCoordinateMatrix(const ublas::coordinate_matrix &) { return true; } // conjugate ------------------------------------------------------------------ template inline T conjugate(const T &x) { return x; } template inline std::complex conjugate(const std::complex &x) { return conj(x); } // conjugate_if --------------------------------------------------------------- template inline T conjugate_if(bool do_it, const T &x) { return x; } template inline std::complex conjugate_if(bool do_it, const std::complex &x) { return do_it ? conj(x) : x; } // absolute_value ------------------------------------------------------------- template inline T absolute_value(const T &x) { return fabs(x); } template inline T2 absolute_value(const std::complex &x) { return sqrt(norm(x)); } // fill_matrix ---------------------------------------------------------------- template void fill_matrix(MatrixType &me, const typename MatrixType::value_type &value) { generic_ublas::matrix_iterator first = generic_ublas::begin(me), last = generic_ublas::end(me); while (first != last) *first++ = value; } // end namespaces ------------------------------------------------------------- } #endif PyLinear-0.91/algorithms/lu.hpp0000644000175000001440000001077310135202257016247 0ustar akusers00000000000000#ifndef HEADER_SEEN_LU_HPP #define HEADER_SEEN_LU_HPP #include #include #include #include #include #include "helpers.hpp" #include namespace lu { namespace ublas = boost::numeric::ublas; using namespace boost::numeric::ublas; using namespace helpers; using namespace boost::tuples; inline double magnitude(double x) { return fabs(x); } inline double magnitude(std::complex x) { return std::max(fabs(real(x)), fabs(imag(x))); } /** Postcondition P*A = L*U. */ template boost::tuple *, int> lu(const MatrixExpression &a) { if (a().size1() != a().size2()) throw std::runtime_error("cholesky: A is not quadratic"); unsigned n = a().size1(); int parity = 1; std::auto_ptr result_l(new DesiredResultL(n, n)); std::auto_ptr result_u(new DesiredResultU(n, n)); std::auto_ptr > permut_ptr(new std::vector); permut_ptr->resize(n); DesiredResultL &l = *result_l; DesiredResultU &u = *result_u; std::vector &permut = *permut_ptr; for (unsigned i = 0; i big) big = temp; if (big == 0) throw std::runtime_error("lu: all-zero column in lu decomposition"); scale_factor[row] = 1./big; } // Crout ------------------------------------------------------------------ double temp; double biggest; size_type biggest_row; value_type sum; value_type pivot; for (size_type col = 0; col < n; col++) { // elements above diagonal --> r for (size_type row = 0; row < col; row++) { sum = a()(permut[row], col); for (size_type i = 0;i < row;i++) sum -= value_type(l(row, i))*value_type(u(i, col)); u(row, col) = sum; /* * vectorizing does not make this faster: u(row, col) = a()(permut[row], col) - inner_prod( project(ublas::row(l, row), range(0, row)), project(column(u, col), range(0, row)) ); */ } biggest = 0; biggest_row = 0; // element on diagonal --> first into l, then into u sum = a()(permut[col], col); for (size_type i = 0; i < col; i++) sum -= value_type(l(col, i))*value_type(u(i, col)); l(col, col) = sum; if ((temp = scale_factor[permut[col]] * magnitude(sum)) >= biggest) { biggest = temp; biggest_row = col; } // elements below diagonal --> l for (size_type row = col + 1; row < n; row++) { sum = a()(permut[row], col); for (size_type i = 0; i < col; i++) sum -= value_type(l(row, i))*value_type(u(i, col)); l(row, col) = sum; if ((temp = scale_factor[permut[row]] * magnitude(sum)) >= biggest) { biggest = temp; biggest_row = row; } } if (biggest == 0) throw std::runtime_error("lu: matrix is singular"); if (biggest_row != col) { // swap access array for a std::swap(permut[biggest_row], permut[col]); // swap rows of l accordingly swap( project(ublas::row(l, col), range(0, col+1)), project(ublas::row(l, biggest_row), range(0, col+1)) ); parity *= -1; } pivot = u(col, col) = l(col, col); l(col, col) = 1; project(column(l, col), range(col+1, n)) *= 1. / pivot; } return make_tuple(result_l.release(), result_u.release(), permut_ptr.release(), parity); } } #endif PyLinear-0.91/algorithms/managed_adaptors.hpp0000644000175000001440000001074710135202257021121 0ustar akusers00000000000000#ifndef HEADER_SEEN_MANAGED_ADAPTORS_HPP #define HEADER_SEEN_MANAGED_ADAPTORS_HPP #include #include #include #include template class managed_symmetric_adaptor : private boost::base_from_member >, public boost::numeric::ublas::symmetric_adaptor { typedef boost::numeric::ublas::symmetric_adaptor super; typedef boost::base_from_member > m_data; public: typedef AdaptedMatrix adapted_matrix; typedef typename super::size_type size_type; typedef typename super::value_type value_type; managed_symmetric_adaptor() : m_data(new AdaptedMatrix()), super(*m_data::member) { } managed_symmetric_adaptor(size_type s1, size_type s2) : m_data(new AdaptedMatrix(s1, s1)), super(*m_data::member) { if (s1 != s2) throw std::runtime_error( "symmetric matrices are quadratic" ); } managed_symmetric_adaptor(const managed_symmetric_adaptor &m) : m_data(new AdaptedMatrix(*m.member)), super(*m_data::member) { } template managed_symmetric_adaptor(const boost::numeric::ublas::matrix_expression &ae) : m_data(new AdaptedMatrix(ae().size1(), ae().size1())), super(*m_data::member) { if (ae().size1() != ae().size2()) throw std::runtime_error( "symmetric matrices are quadratic" ); super::operator=(ae); } void resize(size_type s1, size_type s2) { if (s1 != s2) throw std::runtime_error( "symmetric matrices are quadratic" ); m_data::member->resize(s1, s2); } void insert(size_type i1, size_type i2, const value_type &val) { super::operator()(i1, i2) = val; } void push_back(size_type i1, size_type i2, const value_type &val) { super::operator()(i1, i2) = val; } managed_symmetric_adaptor &operator=(const managed_symmetric_adaptor &m) { *m_data::member.operator=(*m.member); } template managed_symmetric_adaptor &operator=(const boost::numeric::ublas::matrix_expression &ae) { if (ae().size1() != ae().size2()) throw std::runtime_error( "symmetric matrices are quadratic" ); m_data::member->resize(ae.size1(), ae.size2()); super::operator=(ae); } }; template class managed_hermitian_adaptor : private boost::base_from_member >, public boost::numeric::ublas::hermitian_adaptor { typedef boost::numeric::ublas::hermitian_adaptor super; typedef boost::base_from_member > m_data; public: typedef AdaptedMatrix adapted_matrix; typedef typename super::size_type size_type; typedef typename super::value_type value_type; managed_hermitian_adaptor() : m_data(new AdaptedMatrix()), super(*m_data::member) { } managed_hermitian_adaptor(size_type s1, size_type s2) : m_data(new AdaptedMatrix(s1, s1)), super(*m_data::member) { if (s1 != s2) throw std::runtime_error( "hermitian matrices are quadratic" ); } managed_hermitian_adaptor(const managed_hermitian_adaptor &m) : m_data(new AdaptedMatrix(*m.member)), super(*m_data::member) { } template managed_hermitian_adaptor(const boost::numeric::ublas::matrix_expression &ae) : m_data(new AdaptedMatrix(ae().size1(), ae().size1())), super(*m_data::member) { if (ae().size1() != ae().size2()) throw std::runtime_error( "hermitian matrices are quadratic" ); super::operator=(ae); } void resize(size_type s1, size_type s2) { if (s1 != s2) throw std::runtime_error( "hermitian matrices are quadratic" ); m_data::member->resize(s1, s2); } void insert(size_type i1, size_type i2, const value_type &val) { super::operator()(i1, i2) = val; } void push_back(size_type i1, size_type i2, const value_type &val) { super::operator()(i1, i2) = val; } managed_hermitian_adaptor &operator=(const managed_hermitian_adaptor &m) { *m_data::member.operator=(*m.member); } template managed_hermitian_adaptor &operator=(const boost::numeric::ublas::matrix_expression &ae) { if (ae().size1() != ae().size2()) throw std::runtime_error( "hermitian matrices are quadratic" ); m_data::member->resize(ae.size1(), ae.size2()); super::operator=(ae); } }; #endif PyLinear-0.91/algorithms/matrix_operator.hpp0000644000175000001440000002011010135202257021030 0ustar akusers00000000000000#ifndef HEADER_SEEN_MATRIX_OPERATOR_HPP #define HEADER_SEEN_MATRIX_OPERATOR_HPP #include #include template class matrix_operator { public: // types typedef unsigned size_type; typedef ValueType value_type; typedef boost::numeric::ublas::vector vector_type; // interface virtual ~matrix_operator() { } virtual unsigned size1() const = 0; virtual unsigned size2() const = 0; /** Before using apply, after must have the correct size. */ virtual void apply(const vector_type &before, vector_type &after) const { if (size2() != before.size() || size1() != after.size()) throw std::runtime_error("invalid vector sizes in matrix_operator::apply"); } // matrix_expression compatibility const matrix_operator &operator()() const { return *this; } }; template class algorithm_matrix_operator : public matrix_operator { protected: unsigned m_lastIterationCount; unsigned m_debugLevel; public: algorithm_matrix_operator() : m_lastIterationCount(0), m_debugLevel(0) { } unsigned getDebugLevel() const { return m_debugLevel; } void setDebugLevel(unsigned dl) { m_debugLevel = dl; } unsigned getLastIterationCount() const { return m_lastIterationCount; } }; template class iterative_solver_matrix_operator : public algorithm_matrix_operator { protected: unsigned m_maxIterations; double m_tolerance; public: iterative_solver_matrix_operator(unsigned maxit = 0, double tol = 0) : m_maxIterations(maxit), m_tolerance(tol) { } unsigned getMaxIterations() const { return m_maxIterations; } void setMaxIterations(unsigned maxit) { m_maxIterations = maxit; } double getTolerance() const { return m_tolerance; } void setTolerance(double tol) { m_tolerance = tol; } }; template class ublas_matrix_operator : public matrix_operator { const MatrixType &m_matrix; typedef matrix_operator super; public: typedef typename matrix_operator::vector_type vector_type; ublas_matrix_operator(const MatrixType &m) : m_matrix(m) { } unsigned size1() const { return m_matrix.size1(); } unsigned size2() const { return m_matrix.size2(); } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); using namespace boost::numeric::ublas; //after = prod(m_matrix, before); axpy_prod(m_matrix, before, after, /*init*/ true); } }; template class identity_matrix_operator : public matrix_operator { typedef matrix_operator super; unsigned m_size; public: typedef typename super::vector_type vector_type; identity_matrix_operator(unsigned size) : m_size(size) { } unsigned size2() const { return m_size; } unsigned size1() const { return m_size; } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); after = before; } }; template class composite_matrix_operator : public matrix_operator { typedef matrix_operator super; const super &m_outer, &m_inner; public: typedef typename super::vector_type vector_type; composite_matrix_operator(const super &outer, const super &inner) : m_outer(outer), m_inner(inner) { if (m_inner.size1() != m_outer.size2()) throw std::runtime_error("composite_matrix_operator: sizes do not match"); } unsigned size1() const { return m_outer.size1(); } unsigned size2() const { return m_inner.size2(); } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); vector_type temp(m_inner.size1()); m_inner.apply(before, temp); m_outer.apply(temp, after); } }; template class sum_of_matrix_operators : public matrix_operator { typedef matrix_operator super; const super &m_op1, &m_op2; public: typedef typename super::vector_type vector_type; sum_of_matrix_operators (const super &op1, const super &op2) : m_op1(op1), m_op2(op2) { if (m_op1.size1() != m_op2.size1()) throw std::runtime_error("sum_of_matrix_operators: sizes do not match"); if (m_op1.size2() != m_op2.size2()) throw std::runtime_error("sum_of_matrix_operators: sizes do not match"); } unsigned size1() const { return m_op1.size1(); } unsigned size2() const { return m_op1.size2(); } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); vector_type temp(size1()); m_op1.apply(before, temp); m_op2.apply(before, after); after += temp; } }; template class complex_matrix_operator_adaptor : public matrix_operator > { typedef matrix_operator > super; typedef matrix_operator real_op; typedef typename real_op::vector_type real_vector_type; const real_op &m_real, &m_imaginary; public: typedef typename super::vector_type vector_type; complex_matrix_operator_adaptor(const real_op &real_part, const real_op &imaginary_part) : m_real(real_part), m_imaginary(imaginary_part) { if (m_real.size1() != m_imaginary.size1()) throw std::runtime_error("complex_matrix_operator_adaptor: sizes do not match"); if (m_real.size2() != m_imaginary.size2()) throw std::runtime_error("complex_matrix_operator_adaptor: sizes do not match"); } unsigned size1() const { return m_real.size1(); } unsigned size2() const { return m_real.size2(); } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); real_vector_type before_real(real(before)), before_imag(imag(before)); real_vector_type after_real(real(after)), after_imag(imag(after)); real_vector_type after_real_2(real(after)), after_imag_2(imag(after)); m_real.apply(before_real, after_real); m_imaginary.apply(before_imag, after_real_2); after_real_2 *= -1; m_imaginary.apply(before_real, after_imag); m_real.apply(before_imag, after_imag_2); after = after_real + after_real_2 + std::complex(0,1) * (after_imag + after_imag_2); } }; template class scalar_multiplication_matrix_operator : public matrix_operator { typedef matrix_operator super; ValueType m_factor; unsigned m_size; public: typedef typename super::vector_type vector_type; scalar_multiplication_matrix_operator(const ValueType &factor, unsigned size) : m_factor(factor), m_size(size) { } unsigned size1() const { return m_size; } unsigned size2() const { return m_size; } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); after = m_factor * before; } }; // generic prod() interface --------------------------------------------------- template boost::numeric::ublas::vector prod( const matrix_operator &mo, const boost::numeric::ublas::vector &vec) { boost::numeric::ublas::vector result(mo.size1()); mo.apply(vec, result); return result; } #endif PyLinear-0.91/algorithms/umfpack.hpp0000644000175000001440000000255110135202257017250 0ustar akusers00000000000000#ifndef HEADER_SEEN_UMFPACK_HPP #define HEADER_SEEN_UMFPACK_HPP #include #include #include #include "matrix_operator.hpp" namespace umfpack { namespace ublas = boost::numeric::ublas; namespace umf = boost::numeric::bindings::umfpack; template class umfpack_matrix_operator : public algorithm_matrix_operator, boost::noncopyable { typedef algorithm_matrix_operator super; public: typedef ublas::compressed_matrix matrix_type; typedef typename super::vector_type vector_type; private: const matrix_type &m_matrix; umf::numeric_type m_numeric; public: umfpack_matrix_operator(const matrix_type &src) : m_matrix(src) { umf::factor(m_matrix, m_numeric); } unsigned size1() const { return m_matrix.size2(); } unsigned size2() const { return m_matrix.size1(); } void apply(const vector_type &before, vector_type &after) const { super::apply(before, after); umf::solve(m_matrix, after, before, m_numeric); // FIXME: honor debug levels? } }; } #endif PyLinear-0.91/extensions/0000755000175000001440000000000010135231541015132 5ustar akusers00000000000000PyLinear-0.91/extensions/algorithms.cpp0000644000175000001440000004750110135202257020020 0ustar akusers00000000000000#include #include #include #include #include #include #include #include "meta.hpp" #include "python_helpers.hpp" #include #include #include #include #include #include #include /* #include #include */ // shape accessors ------------------------------------------------------------ template inline python::object getShape(const MatrixType &m) { return python::make_tuple(m.size1(), m.size2()); } // wrappers ------------------------------------------------------------------- template class matrix_operator_wrapper : public matrix_operator { PyObject *m_self; public: typedef typename matrix_operator::vector_type vector_type; matrix_operator_wrapper(PyObject *self, const matrix_operator &) : m_self(self) { } unsigned size1() const { return python::extract(python::call_method(m_self, "shape")[0]); } unsigned size2() const { return python::extract(python::call_method(m_self, "shape")[1]); } void apply(const vector_type &before, vector_type &after) const { return python::call_method(m_self, "apply", before, after); } }; template class algorithm_matrix_operator_wrapper : public algorithm_matrix_operator { PyObject *m_self; public: typedef typename matrix_operator::vector_type vector_type; algorithm_matrix_operator_wrapper(PyObject *self, const algorithm_matrix_operator &) : m_self(self) { } unsigned size1() const { return python::extract(python::call_method(m_self, "shape")[0]); } unsigned size2() const { return python::extract(python::call_method(m_self, "shape")[1]); } void apply(const vector_type &before, vector_type &after) const { return python::call_method(m_self, "apply", before, after); } }; template class iterative_solver_matrix_operator_wrapper : public iterative_solver_matrix_operator { PyObject *m_self; public: typedef typename matrix_operator::vector_type vector_type; iterative_solver_matrix_operator_wrapper(PyObject *self, const iterative_solver_matrix_operator &) : m_self(self) { } unsigned size1() const { return python::extract(python::call_method(m_self, "shape")[0]); } unsigned size2() const { return python::extract(python::call_method(m_self, "shape")[1]); } void apply(const vector_type &before, vector_type &after) const { return python::call_method(m_self, "apply", before, after); } }; // ublas_matrix_operator ------------------------------------------------------ template static ublas_matrix_operator *makeMatrixOperator(const MatrixType &mat) { return new ublas_matrix_operator(mat); } struct ublas_matrix_operator_exposer { template void expose(const std::string &python_mattype, MatrixType) const { typedef typename MatrixType::value_type value_type; typedef typename matrix_operator::vector_type vector_type; python::class_, python::bases > > (("MatrixOperator" + python_mattype).c_str(), python::init()[python::with_custodian_and_ward<1,2>()]); python::def("makeMatrixOperator", makeMatrixOperator, python::return_value_policy< python::manage_new_object, python::with_custodian_and_ward_postcall<0, 1> >()); } }; // cholesky_exposer ----------------------------------------------------------- struct cholesky_exposer { public: template void expose(const std::string &python_mattype, MatrixType) const { python::def("cholesky", cholesky::cholesky::type>, python::return_value_policy()); } }; // lu ------------------------------------------------------------------------- /* UBLAS builtin lu is dog-slow. template python::object luWrapper(const MatrixType &a) { using namespace ublas; typedef typename strip_symmetric_wrappers::type result_type; typedef permutation_matrix permut_type; std::auto_ptr a_copy(new MatrixType(a)); std::auto_ptr permut_ptr(new permut_type(a.size1())); axpy_lu_factorize(*a_copy, *permut_ptr); std::auto_ptr l(new result_type( triangular_adaptor(*a_copy))); std::auto_ptr u(new result_type( triangular_adaptor(*a_copy))); int sign = 1; python::list py_permut; for (unsigned i = 0; i < permut_ptr->size(); i++) { // FIXME: BUG... py_permut.append((*permut_ptr)[i]); // FIXME: prove that this is right. if ((*permut_ptr)[i] != i) sign *= -1; } python::object py_result = python::make_tuple(handle_from_new_ptr(l.get()), handle_from_new_ptr(u.get()), py_permut, sign); l.release(); u.release(); return py_result; } */ /* My LU is still slow, but faster than the UBLAS builtin. */ template python::object luWrapper(const MatrixType &a) { typedef typename strip_symmetric_wrappers::type result_type; boost::tuple *, int> result = lu::lu(a); std::auto_ptr l(result.get<0>()), u(result.get<1>()); std::auto_ptr > permut_ptr(result.get<2>()); std::vector &permut = *permut_ptr; python::list py_permut; for (unsigned i = 0; i < permut.size(); i++) py_permut.append(permut[i]); python::object py_result = python::make_tuple(handle_from_new_ptr(l.get()), handle_from_new_ptr(u.get()), py_permut, result.get<3>()); l.release(); u.release(); return py_result; } /* couldn't find atlas CLAPACK template python::object luWrapper(const MatrixType &a) { using namespace boost::numeric::bindings::atlas; typedef typename strip_symmetric_wrappers::type result_type; typedef ublas::vector permut_type; std::auto_ptr a_copy(new MatrixType(a)); std::auto_ptr permut_ptr(new permut_type(a.size1())); lu_factor(*a_copy, *permut_ptr); std::auto_ptr l(new result_type( ublas::triangular_adaptor(*a_copy))); std::auto_ptr u(new result_type( ublas::triangular_adaptor(*a_copy))); int sign = 1; python::list py_permut; for (unsigned i = 0; i < permut_ptr->size(); i++) { // FIXME: BUG... py_permut.append((*permut_ptr)[i]); // FIXME: prove that this is right. if ((*permut_ptr)[i] != i) sign *= -1; } python::object py_result = python::make_tuple(handle_from_new_ptr(l.get()), handle_from_new_ptr(u.get()), py_permut, sign); l.release(); u.release(); return py_result; } */ // svd ------------------------------------------------------------------------ template static python::object svdWrapper(const ublas::matrix &a) { typedef ublas::matrix mat; typedef ublas::matrix fortran_mat; fortran_mat a_copy(a), u(a.size1(), a.size1()), vt(a.size2(), a.size2()); ublas::vector s(std::min(a.size1(), a.size2())); int ierr = boost::numeric::bindings::lapack::gesdd(a_copy, s, u, vt); if (ierr < 0) throw std::runtime_error("invalid argument to gesdd"); else if (ierr > 0) throw std::runtime_error("no convergence for given matrix"); typedef ublas::matrix mat; typedef ublas::vector vec; return python::make_tuple(handle_from_new_ptr(new mat(u)), handle_from_new_ptr(new vec(s)), handle_from_new_ptr(new mat(vt))); } // eigenvectors --------------------------------------------------------------- void _Heigenvectors_backend(char jobz, char uplo, ublas::matrix &a, ublas::vector &w) { int ierr = boost::numeric::bindings::lapack::syev(jobz, uplo, a, w, boost::numeric::bindings::lapack::optimal_workspace()); if (ierr < 0) throw std::runtime_error("invalid argument to syev"); else if (ierr > 0) throw std::runtime_error("no convergence for given matrix"); } void _Heigenvectors_backend(char jobz, char uplo, ublas::matrix, ublas::column_major> &a, ublas::vector &w) { int ierr = boost::numeric::bindings::lapack::heev(jobz, uplo, a, w, boost::numeric::bindings::lapack::optimal_workspace()); if (ierr < 0) throw std::runtime_error("invalid argument to heev"); else if (ierr > 0) throw std::runtime_error("no convergence for given matrix"); } template static python::object HeigenvectorsWrapper(bool get_vectors, bool upper, const ublas::matrix &a) { typedef ublas::matrix mat; typedef ublas::matrix fortran_mat; typedef ublas::vector vec; fortran_mat a_copy(a); std::auto_ptr w(new vec(a.size1())); _Heigenvectors_backend(get_vectors ? 'V' : 'N', upper ? 'U' : 'L', a_copy, *w); typedef ublas::matrix mat; return python::make_tuple(handle_from_new_ptr(new mat(a_copy)), handle_from_new_ptr(w.release())); } template static python::object eigenvectorsWrapper(unsigned get_left_vectors, unsigned get_right_vectors, const ublas::matrix &a) { typedef ublas::matrix mat; typedef ublas::matrix fortran_mat; typedef ublas::vector::type > eval_vec; typedef ublas::matrix::type, ublas::column_major> evec_mat; int const n = a.size1(); fortran_mat a_copy(a); std::auto_ptr w(new eval_vec(a.size1())); std::auto_ptr vl, vr; if (get_left_vectors) vl = std::auto_ptr(new evec_mat(n, n)); if (get_right_vectors) vr = std::auto_ptr(new evec_mat(n, n)); int ierr = boost::numeric::bindings::lapack::geev(a_copy, *w, vl.get(), vr.get(), boost::numeric::bindings::lapack::optimal_workspace()); if (ierr < 0) throw std::runtime_error("invalid argument to geev"); else if (ierr > 0) throw std::runtime_error("no convergence for given matrix"); typedef ublas::matrix::type> cmat; typedef ublas::vector vec; if (get_left_vectors) { if (get_right_vectors) return python::make_tuple(handle_from_new_ptr(w.release()), handle_from_new_ptr(new cmat(*vl)), handle_from_new_ptr(new cmat(*vr))); else return python::make_tuple(handle_from_new_ptr(w.release()), handle_from_new_ptr(new cmat(*vl)), python::object()); } else { if (get_right_vectors) return python::make_tuple(handle_from_new_ptr(w.release()), python::object(), handle_from_new_ptr(new cmat(*vr))); else return python::make_tuple(handle_from_new_ptr(w.release()), python::object(), python::object()); } } // ---------------------------------------------------------------------------- template void exposeSpecialAlgorithms(ValueType) { python::def("lu", luWrapper >); python::def("singular_value_decomposition", svdWrapper); python::def("Heigenvectors", HeigenvectorsWrapper); python::def("eigenvectors", eigenvectorsWrapper); } // matrix operators ----------------------------------------------------------- template static void exposeMatrixOperators(const std::string &python_eltname, ValueType) { { typedef matrix_operator wrapped_type; python::class_, noncopyable > (("MatrixOperator"+python_eltname).c_str(), python::no_init) .add_property("shape", &getShape) .def("typecode", &typecode) .def("apply", &wrapped_type::apply) ; } { typedef algorithm_matrix_operator wrapped_type; python::class_ >, algorithm_matrix_operator_wrapper, noncopyable > (("AlgorithmMatrixOperator"+python_eltname).c_str(), python::no_init) .add_property("debug_level", &wrapped_type::getDebugLevel, &wrapped_type::setDebugLevel) .add_property("last_iteration_count", &wrapped_type::getLastIterationCount) ; } { typedef iterative_solver_matrix_operator wrapped_type; python::class_ >, iterative_solver_matrix_operator_wrapper, noncopyable > (("IterativeSolverMatrixOperator"+python_eltname).c_str(), python::no_init) .add_property("max_iterations", &wrapped_type::getMaxIterations, &wrapped_type::setMaxIterations) .add_property("tolerance", &wrapped_type::getTolerance, &wrapped_type::setTolerance) ; } { python::class_, python::bases > > (("IdentityMatrixOperator"+python_eltname).c_str(), python::init()); } { python::class_, python::bases > > (("CompositeMatrixOperator"+python_eltname).c_str(), python::init< const matrix_operator &, const matrix_operator &>() [python::with_custodian_and_ward<1, 2, python::with_custodian_and_ward<1, 3> >()]); } { python::class_, python::bases > > (("SumOfMatrixOperators"+python_eltname).c_str(), python::init< const matrix_operator &, const matrix_operator &>() [python::with_custodian_and_ward<1, 2, python::with_custodian_and_ward<1, 3> >()]); } { python::class_, python::bases > > (("ScalarMultiplicationMatrixOperator"+python_eltname).c_str(), python::init()); } { typedef cg::cg_matrix_operator wrapped_type; python::class_ > > (("CGMatrixOperator"+python_eltname).c_str(), python::init< const matrix_operator &, const matrix_operator&, unsigned, double>() [python::with_custodian_and_ward<1, 2, python::with_custodian_and_ward<1, 3> >()]); } { typedef bicgstab::bicgstab_matrix_operator wrapped_type; python::class_ > > (("BiCGSTABMatrixOperator"+python_eltname).c_str(), python::init< const matrix_operator &, const matrix_operator&, unsigned, double>() [python::with_custodian_and_ward<1, 2, python::with_custodian_and_ward<1, 3> >()]); } { typedef umfpack::umfpack_matrix_operator wrapped_type; typedef python::class_ >, boost::noncopyable> wrapper_type; wrapper_type pyclass(("UMFPACKMatrixOperator"+python_eltname).c_str(), python::init() [python::with_custodian_and_ward<1,2>()]); } } // arpack --------------------------------------------------------------------- template static typename ResultsType::value_container::iterator beginRitzValues(ResultsType &res) { return res.m_ritz_values.begin(); } template static typename ResultsType::value_container::iterator endRitzValues(ResultsType &res) { return res.m_ritz_values.end(); } template static typename ResultsType::vector_container::iterator beginRitzVectors(ResultsType &res) { return res.m_ritz_vectors.begin(); } template static typename ResultsType::vector_container::iterator endRitzVectors(ResultsType &res) { return res.m_ritz_vectors.end(); } template static void exposeArpack(const std::string &python_valuetypename, ValueType) { using namespace boost::python; typedef typename arpack::results results_type; class_ (("ArpackResults"+python_valuetypename).c_str()) .add_property("RitzValues", range(beginRitzValues, endRitzValues)) .add_property("RitzVectors", range(beginRitzVectors, endRitzVectors)) ; def("runArpack", arpack::doReverseCommunication, return_value_policy()); } // main ----------------------------------------------------------------------- BOOST_PYTHON_MODULE(_algorithms) { exposeMatrixOperators("Float64", double()); exposeMatrixOperators("Complex64", std::complex()); // expose bicgstab only for real-valued matrices // expose complex adaptor only for real-valued matrices { typedef double ValueType; typedef complex_matrix_operator_adaptor wrapped_type; python::class_ > > > ("ComplexMatrixOperatorAdaptorFloat64", python::init< const matrix_operator &, const matrix_operator &>() [python::with_custodian_and_ward<1, 2, python::with_custodian_and_ward<1, 3> >()]); } exposeForAllMatrices(ublas_matrix_operator_exposer()); python::enum_("arpack_which_eigenvalues") .value("SMALLEST_MAGNITUDE", arpack::SMALLEST_MAGNITUDE) .value("LARGEST_MAGNITUDE", arpack::LARGEST_MAGNITUDE) .value("SMALLEST_REAL_PART", arpack::SMALLEST_REAL_PART) .value("LARGEST_REAL_PART", arpack::LARGEST_REAL_PART) .value("SMALLEST_IMAGINARY_PART", arpack::SMALLEST_IMAGINARY_PART) .value("LARGEST_IMAGINARY_PART", arpack::LARGEST_IMAGINARY_PART) .export_values(); python::enum_("arpack_mode") .value("REGULAR_NON_GENERALIZED", arpack::REGULAR_NON_GENERALIZED) .value("REGULAR_GENERALIZED", arpack::REGULAR_GENERALIZED) .value("SHIFT_AND_INVERT_GENERALIZED", arpack::SHIFT_AND_INVERT_GENERALIZED) .export_values(); exposeArpack("Float64", double()); exposeArpack("Complex64", std::complex()); exposeSpecialAlgorithms(double()); exposeSpecialAlgorithms(std::complex()); exposeForAllMatrices(cholesky_exposer()); } // EMACS-FORMAT-TAG // // Local Variables: // mode: C++ // eval: (c-set-style "stroustrup") // eval: (c-set-offset 'access-label -2) // eval: (c-set-offset 'inclass '++) // c-basic-offset: 2 // tab-width: 8 // End: PyLinear-0.91/extensions/matrices.cpp0000644000175000001440000000135110135202257017447 0ustar akusers00000000000000#include "matrices.hpp" template static void exposeAll(ValueType, const std::string &python_eltypename) { exposeMatrixType(ublas::matrix(), "Matrix", python_eltypename); } void pylinear_expose_sym_build(); void pylinear_expose_sym_ex(); void pylinear_expose_sparse_build(); void pylinear_expose_sparse_ex(); void pylinear_expose_vectors(); BOOST_PYTHON_MODULE(_matrices) { enum_("SupportedElementTypes") .value("Float64", Float64) .value("Complex64", Complex64) .export_values(); EXPOSE_ALL_TYPES; //pylinear_expose_sym_build(); //pylinear_expose_sym_ex(); pylinear_expose_sparse_build(); pylinear_expose_sparse_ex(); pylinear_expose_vectors(); } PyLinear-0.91/extensions/matrices.hpp0000644000175000001440000012641610135202257017466 0ustar akusers00000000000000#include #include #include #include #include #include "meta.hpp" #include "python_helpers.hpp" #include #include #include #include #include #include using boost::python::class_; using boost::python::enum_; using boost::python::self; using boost::python::def; using helpers::decomplexify; namespace { // helpers -------------------------------------------------------------------- generic_ublas::minilist getMinilist(const python::tuple &tup) { unsigned len = python::extract(tup.attr("__len__")()); generic_ublas::minilist result; for (unsigned i = 0; i < len; ++i) result.push_back(python::extract(tup[i])); return result; } python::tuple getPythonShapeTuple(const generic_ublas::minilist &ml) { if (ml.size() == 1) return python::make_tuple(ml[0]); else return python::make_tuple(ml[0], ml[1]); } python::object getPythonIndexTuple(const generic_ublas::minilist &ml) { if (ml.size() == 1) return python::object(ml[0]); else return python::make_tuple(ml[0], ml[1]); } // shape accessors ------------------------------------------------------------ template inline unsigned getLength(const MatrixType &m) { return m.size1() * m.size2(); } template inline unsigned getLength(const ublas::vector &m) { return m.size(); } template inline python::object getShape(const MatrixType &m) { return getPythonShapeTuple(generic_ublas::getShape(m)); } template inline void setShape(MatrixType &m, const python::tuple &new_shape) { generic_ublas::setShape(m,getMinilist(new_shape)); } // iterator interface --------------------------------------------------------- template struct python_matrix_key_iterator { typename generic_ublas::matrix_iterator m_iterator, m_end; python_matrix_key_iterator *iter() { return this; } python::object next() { if (m_iterator == m_end) { PyErr_SetNone(PyExc_StopIteration); throw python::error_already_set(); } python::object result = getPythonIndexTuple(m_iterator.index()); ++m_iterator; return result; } static python_matrix_key_iterator *obtain(MatrixType &m) { std::auto_ptr it(new python_matrix_key_iterator); it->m_iterator = generic_ublas::begin(m); it->m_end = generic_ublas::end(m); return it.release(); } }; template ::type > struct python_matrix_value_iterator { const MatrixType &m_matrix; typename MatrixType::size_type m_row_index; python_matrix_value_iterator(const MatrixType &matrix) : m_matrix(matrix), m_row_index(0) { } python_matrix_value_iterator *iter() { return this; } python::handle next() { if (m_row_index >= m_matrix.size1()) { PyErr_SetNone(PyExc_StopIteration); throw python::error_already_set(); } return handle_from_new_ptr( new typename get_corresponding_vector_type::type( ublas::row(m_matrix, m_row_index++))); } static python_matrix_value_iterator *obtain(MatrixType &m) { return new python_matrix_value_iterator(m); } }; template struct python_matrix_value_iterator { const MatrixType &m_matrix; typename MatrixType::size_type m_row_index; python_matrix_value_iterator(const MatrixType &matrix) : m_matrix(matrix), m_row_index(0) { } python_matrix_value_iterator *iter() { return this; } typename MatrixType::value_type next() { if (m_row_index >= m_matrix.size()) { PyErr_SetNone(PyExc_StopIteration); throw python::error_already_set(); } return m_matrix(m_row_index++); } static python_matrix_value_iterator *obtain(MatrixType &m) { return new python_matrix_value_iterator(m); } }; // element accessors ---------------------------------------------------------- struct slice_info { bool m_was_slice; int m_start; int m_end; int m_step; int m_sliceLength; }; static void translateIndex(PyObject *slice_or_constant, slice_info &si, int my_length) { si.m_was_slice = PySlice_Check(slice_or_constant); if (si.m_was_slice) { PySliceObject *slice = reinterpret_cast(slice_or_constant); if (PySlice_GetIndicesEx(slice, my_length, &si.m_start, &si.m_end, &si.m_step, &si.m_sliceLength) != 0) throw python::error_already_set(); } else if (PyInt_Check(slice_or_constant)) { int index = PyInt_AS_LONG(slice_or_constant); if (index < 0) index += my_length; if (index < 0) throw std::out_of_range("negative index out of bounds"); if (index >= my_length) throw std::out_of_range("index out of bounds"); si.m_start = index; si.m_end = index + 1; si.m_step = 1; si.m_sliceLength = 1; } else throw std::out_of_range("invalid index object"); } template static python::handle getElement(const MatrixType &m, PyObject *index) { typedef typename get_corresponding_vector_type::type vector_t; if (PyTuple_Check(index)) { // we have a tuple if (PyTuple_GET_SIZE(index) != 2) throw std::out_of_range("expected tuple of size 2"); slice_info si1, si2; translateIndex(PyTuple_GET_ITEM(index, 0), si1, m.size1()); translateIndex(PyTuple_GET_ITEM(index, 1), si2, m.size2()); if (!si1.m_was_slice && !si2.m_was_slice) return handle_from_object(m(si1.m_start, si2.m_start)); else if (!si1.m_was_slice) return handle_from_new_ptr(new vector_t(row(m,si1.m_start))); else if (!si2.m_was_slice) return handle_from_new_ptr(new vector_t(column(m,si2.m_start))); else { return handle_from_new_ptr( new MatrixType(project(m, ublas::slice(si1.m_start, si1.m_step, si1.m_sliceLength), ublas::slice(si2.m_start, si2.m_step, si2.m_sliceLength)))); } } else { slice_info si; translateIndex(index, si, m.size1()); if (!si.m_was_slice) return handle_from_new_ptr(new vector_t(row(m, si.m_start))); else return handle_from_new_ptr( new MatrixType(project(m, ublas::slice(si.m_start, si.m_step, si.m_sliceLength), ublas::slice(0, 1, m.size2()) ))); } } template static python::handle getElement(const ublas::vector &m, PyObject *index) { slice_info si; translateIndex(index, si, m.size()); if (!si.m_was_slice) return handle_from_object(m(si.m_start)); else return handle_from_new_ptr( new ublas::vector(project(m, ublas::slice(si.m_start, si.m_step, si.m_sliceLength)))); } template static void setElement(MatrixType &m, PyObject *index, python::object &new_value) { typedef typename get_corresponding_vector_type::type vector_type; python::extract new_scalar(new_value); python::extract new_vector(new_value); python::extract new_matrix(new_value); if (PyTuple_Check(index)) { // we have a tuple if (PyTuple_GET_SIZE(index) != 2) throw std::out_of_range("expected tuple of size 2"); slice_info si1, si2; translateIndex(PyTuple_GET_ITEM(index, 0), si1, m.size1()); translateIndex(PyTuple_GET_ITEM(index, 1), si2, m.size2()); if (new_scalar.check()) { // scalar broadcast // vector special cases are good because rows and columns are // tremendously faster than slices - they use strides. if (si1.m_sliceLength == 1 && si2.m_sliceLength == 1) m(si1.m_start, si2.m_start) = new_scalar(); else if (si1.m_sliceLength == 1 && (unsigned) si2.m_sliceLength == m.size2()) { ublas::matrix_row my_row(m, si1.m_start); helpers::fill_matrix(my_row, new_scalar()); } else if (si2.m_sliceLength == 1 && (unsigned) si1.m_sliceLength == m.size1()) { ublas::matrix_column my_column(m, si2.m_start); helpers::fill_matrix(my_column, new_scalar()); } else { ublas::matrix_slice my_slice(m, ublas::slice(si1.m_start, si1.m_step, si1.m_sliceLength), ublas::slice(si2.m_start, si2.m_step, si2.m_sliceLength)); helpers::fill_matrix(my_slice, new_scalar()); } } else if (new_vector.check()) { vector_type new_vec = new_vector(); if (si1.m_sliceLength == 1) { // replace row if (new_vec.size() != m.size2()) throw std::out_of_range("submatrix is wrong size for assignment"); row(m,si1.m_start) = new_vec; } else if (si2.m_sliceLength == 1) { // replace column if (new_vec.size() != m.size1()) throw std::out_of_range("submatrix is wrong size for assignment"); column(m,si2.m_start) = new_vec; } else { // broadcast vector across matrix ublas::matrix_slice my_slice(m, ublas::slice(si1.m_start, si1.m_step, si1.m_sliceLength), ublas::slice(si2.m_start, si2.m_step, si2.m_sliceLength)); if (new_vec.size() != my_slice.size2()) throw std::out_of_range("submatrix is wrong size for assignment"); for (unsigned i = 0; i < my_slice.size1(); ++i) row(my_slice, i) = new_vec; } } else if (new_matrix.check()) { // no broadcast const MatrixType &new_mat = new_matrix(); if (int(new_mat.size1()) != si1.m_sliceLength || int(new_mat.size2()) != si2.m_sliceLength) throw std::out_of_range("submatrix is wrong size for assignment"); project(m, ublas::slice(si1.m_start, si1.m_step, si1.m_sliceLength), ublas::slice(si2.m_start, si2.m_step, si2.m_sliceLength)) = new_mat; } else { PyErr_SetString(PyExc_ValueError, "Unknown type in element or slice assignment"); throw python::error_already_set(); } } else { slice_info si; translateIndex(index, si, m.size1()); if (new_scalar.check()) { // broadcast a scalar if (si.m_sliceLength == 1) { // rows are much faster than generic slices ublas::matrix_row my_row(row(m, si.m_start)); helpers::fill_matrix(my_row, new_scalar()); } else { ublas::matrix_slice my_slice(m, ublas::slice(si.m_start, si.m_step, si.m_sliceLength), ublas::slice(0, 1, m.size2())); helpers::fill_matrix(my_slice, new_scalar()); } } else if (new_vector.check()) { vector_type new_vec = new_vector(); if (si.m_sliceLength == 1) { if (new_vec.size() != m.size2()) throw std::out_of_range("submatrix is wrong size for assignment"); row(m,si.m_start) = new_vec; } else { // broadcast vector across matrix if (new_vec.size() != m.size2()) throw std::out_of_range("submatrix is wrong size for assignment"); for (int i = si.m_start; i < si.m_end; i += si.m_step) row(m, i) = new_vec; } } else if (new_matrix.check()) { const MatrixType &new_mat = new_matrix(); if (int(new_mat.size1()) != si.m_sliceLength || new_mat.size2() != m.size2()) throw std::out_of_range("submatrix is wrong size for assignment"); project(m, ublas::slice(si.m_start, si.m_step, si.m_sliceLength), ublas::slice(0, 1, m.size2())) = new_mat(); } else { PyErr_SetString(PyExc_ValueError, "Unknown type in element or slice assignment"); throw python::error_already_set(); } } } template static void setElement(ublas::vector &m, PyObject *index, python::object &new_value) { python::extract::value_type> new_scalar(new_value); python::extract &> new_vector(new_value); slice_info si; translateIndex(index, si, m.size()); if (new_scalar.check()) { if (si.m_sliceLength == 1) m(si.m_start) = new_scalar(); else { // broadcast a scalar ublas::vector_slice > my_slice(m, ublas::slice(si.m_start, si.m_step, si.m_sliceLength)); helpers::fill_matrix(my_slice, new_scalar()); } } else if (new_vector.check()) project(m, ublas::slice(si.m_start, si.m_step, si.m_sliceLength)) = new_vector(); else { PyErr_SetString(PyExc_ValueError, "Unknown type in element or slice assignment"); throw python::error_already_set(); } } // pickling ------------------------------------------------------------------- template struct sparse_pickle_suite : python::pickle_suite { static python::tuple getinitargs(const MatrixType &m) { return getPythonShapeTuple(generic_ublas::getShape(m)); } static python::object getstate(MatrixType &m) { generic_ublas::matrix_iterator first = generic_ublas::begin(m), last = generic_ublas::end(m); python::list result; while (first != last) { result.append(python::make_tuple(getPythonIndexTuple(first.index()), typename MatrixType::value_type(*first))); first++; } return result; } static void setstate(MatrixType &m, python::object entries) { unsigned len = python::extract(entries.attr("__len__")()); for (unsigned i = 0; i < len; i++) { generic_ublas::insert(m, getMinilist(python::extract(entries[i][0])), python::extract(entries[i][1])); } } }; template struct dense_pickle_suite : python::pickle_suite { static python::tuple getinitargs(const MatrixType &m) { return getPythonShapeTuple(generic_ublas::getShape(m)); } static python::object getstate(MatrixType &m) { generic_ublas::matrix_iterator first = generic_ublas::begin(m), last = generic_ublas::end(m); python::list result; while (first != last) result.append(*first++); return result; } static void setstate(MatrixType &m, python::object entries) { generic_ublas::matrix_iterator first = generic_ublas::begin(m); unsigned len = python::extract(entries.attr("__len__")()); for (unsigned i = 0; i < len; i++) *first++ = (typename MatrixType::value_type) python::extract(entries[i]); } }; // specialty constructors ----------------------------------------------------- template static MatrixType *getFilledMatrix( typename MatrixType::size_type size1, typename MatrixType::size_type size2, const typename MatrixType::value_type &value) { std::auto_ptr mat(new MatrixType(size1, size2)); helpers::fill_matrix(*mat, value); return mat.release(); } template static MatrixType *getFilledVector( typename MatrixType::size_type size1, const typename MatrixType::value_type &value) { std::auto_ptr mat(new MatrixType(size1)); helpers::fill_matrix(*mat, value); return mat.release(); } // operators ------------------------------------------------------------------ template MatrixType negateOp(const MatrixType &m) { return -m; } template MatrixType plusOp(const MatrixType &m1, const MatrixType &m2) { return m1+m2; } template MatrixType minusOp(const MatrixType &m1, const MatrixType &m2) { return m1-m2; } template MatrixType *plusAssignOp(MatrixType &m1, const MatrixType &m2) { m1 += m2; return &m1; } template MatrixType *minusAssignOp(MatrixType &m1, const MatrixType &m2) { m1 -= m2; return &m1; } template MatrixType scalarTimesOp(const MatrixType &m1, const Scalar &s) { return m1 * s; } template MatrixType scalarDivideOp(const MatrixType &m1, const Scalar &s) { return m1 / s; } template MatrixType *scalarTimesAssignOp(MatrixType &m1, const Scalar &s) { m1 *= s; return &m1; } template MatrixType *scalarDivideAssignOp(MatrixType &m1, const Scalar &s) { m1 /= s; return &m1; } // universal functions -------------------------------------------------------- template inline MatrixType *copyNew(const MatrixType &m) { return new MatrixType(m); } template ublas::vector * multiplyVector(const MatrixType &mat, const ublas::vector &vec) { if (mat.size2() != vec.size()) throw std::runtime_error("matrix size doesn't match vector"); ublas::vector *result = new ublas::vector(mat.size1()); ublas::axpy_prod(mat, vec, *result); return result; } template ublas::vector * premultiplyVector(const MatrixType &mat, const ublas::vector &vec) { if (mat.size1() != vec.size()) throw std::runtime_error("matrix size doesn't match vector"); return new ublas::vector(prod(vec,mat)); } template MatrixType *multiplyMatrix(const MatrixType &mat1, const MatrixType &mat2) { if (mat1.size2() != mat2.size1()) throw std::runtime_error("matrix sizes don't match"); return new MatrixType(prod(mat1,mat2)); } template struct inner_prodWrapper { typedef typename value_type_promotion::bigger_type::type result_type; static result_type apply(const Op1 &op1, const Op2 &op2) { if (op1.size() != op2.size()) throw std::runtime_error("vector sizes for inner product don't match"); return inner_prod(op1, op2); } }; template struct outer_prodWrapper { typedef typename value_type_promotion::bigger_type::type result_value_type; typedef typename ublas::matrix result_type; inline static result_type *apply(const Op1 &op1, const Op2 &op2) { return new result_type(outer_prod(op1, op2)); } }; template static MatrixType *transposeMatrix(const MatrixType &m) { return new MatrixType(trans(m)); } template static MatrixType *hermiteMatrix(const MatrixType &m) { return new MatrixType(herm(m)); } template struct realWrapper { typedef typename change_value_type::type>::type result_type; inline static python::handle apply(const MatrixType &m) { return handle_from_new_ptr(new result_type(real(m))); } }; template struct imagWrapper { typedef typename change_value_type::type>::type result_type; inline static python::handle apply(const MatrixType &m) { return handle_from_new_ptr(new result_type(imag(m))); } }; template struct conjugateWrapper { typedef MatrixType result_type; inline static result_type *apply(const MatrixType &m) { return new result_type(conj(m)); } }; template inline std::string stringify(const T &obj) { std::stringstream stream; stream << obj; return stream.rdbuf()->str(); } template void addScattered(MatrixType &mat, python::object row_indices, python::object column_indices, const ublas::matrix &little_mat) { using namespace boost::python; unsigned row_count = extract(row_indices.attr("__len__")()); unsigned column_count = extract(column_indices.attr("__len__")()); if (row_count != little_mat.size1() || column_count != little_mat.size2()) throw std::runtime_error("addScattered: sizes don't match"); // FIXME: HACK if (helpers::isCoordinateMatrix(mat)) { for (unsigned int row = 0; row < row_count; ++row) { int dest_row = extract(row_indices[row]); if (dest_row < 0) continue; for (unsigned col = 0; col < column_count; ++col) { int dest_col = extract(column_indices[col]); if (dest_col < 0) continue; mat.insert(dest_row, dest_col, little_mat(row, col)); } } } else { for (unsigned int row = 0; row < row_count; ++row) { int dest_row = extract(row_indices[row]); if (dest_row < 0) continue; for (unsigned col = 0; col < column_count; ++col) { int dest_col = extract(column_indices[col]); if (dest_col < 0) continue; mat(dest_row, dest_col) += little_mat(row, col); } } } } template inline void addScatteredSymmetric(MatrixType &mat, python::object indices, const ublas::matrix &little_mat) { using namespace boost::python; unsigned index_count = extract(indices.attr("__len__")()); if (index_count != little_mat.size1() || index_count != little_mat.size2()) throw std::runtime_error("addScatteredSymmetric: sizes don't match"); if (helpers::isHermitian(mat)) { // FIXME: Until now, hermitian matrices can't count as coordinate matrices. for (unsigned int row = 0; row < index_count; ++row) { int dest_row = extract(indices[row]); if (dest_row < 0) continue; for (unsigned col = 0; col <= row; ++col) { int dest_col = extract(indices[col]); if (dest_col < 0) continue; mat(dest_row, dest_col) += little_mat(row, col); } } } else { // FIXME: hack if (helpers::isCoordinateMatrix(mat)) { for (unsigned int row = 0; row < index_count; ++row) { int dest_row = extract(indices[row]); if (dest_row < 0) continue; for (unsigned col = 0; col < index_count; ++col) { int dest_col = extract(indices[col]); if (dest_col < 0) continue; mat.insert(dest_row, dest_col, little_mat(row, col)); } } } else { for (unsigned int row = 0; row < index_count; ++row) { int dest_row = extract(indices[row]); if (dest_row < 0) continue; for (unsigned col = 0; col < index_count; ++col) { int dest_col = extract(indices[col]); if (dest_col < 0) continue; mat(dest_row, dest_col) += little_mat(row, col); } } } } } template typename get_corresponding_vector_type::type * solveLower(const MatrixType &mat, const typename get_corresponding_vector_type::type &vec) { return new typename get_corresponding_vector_type::type (ublas::solve(mat, vec, ublas::lower_tag())); } template typename get_corresponding_vector_type::type * solveUpper(const MatrixType &mat, const typename get_corresponding_vector_type::type &vec) { return new typename get_corresponding_vector_type::type (ublas::solve(mat, vec, ublas::upper_tag())); } namespace ufuncs { // my_XX function prototypes ------------------------------------------------ template static inline T my_arg(T x) { if (x >= 0) return 0; else return M_PI; } template static inline T my_arg(const std::complex &x) { return std::arg(x); } template static inline T my_abs(T x) { return fabs(x); } template static inline T my_abs(const std::complex &x) { return abs(x); } template static inline T my_floor(T x) { return floor(x); } template static inline std::complex my_floor(const std::complex &x) { return std::complex(floor(x.real()), floor(x.imag())); } template static inline T my_ceil(T x) { return ceil(x); } template static inline std::complex my_ceil(const std::complex &x) { return std::complex(ceil(x.real()), ceil(x.imag())); } template static inline bool my_less(T x, T y) { return x < y; } template static inline bool my_less(const std::complex &x, const std::complex &y) { return x.real() < y.real(); } // binary ufuncs ------------------------------------------------------------ template struct power : public std::binary_function { T operator()(T a, T b) { return pow(a, b); } }; template struct minimum : public std::binary_function { T operator()(T a, T b) { if (my_less(a,b)) return a; else return b; } }; template struct maximum : public std::binary_function { T operator()(T a, T b) { if (my_less(a,b)) return b; else return a; } }; // identical types ---------------------------------------------------------- #define MAKE_UNARY_FUNCTION_ADAPTER(NAME, f) \ template \ struct simple_function_adapter_##NAME \ { \ typedef T result_type; \ \ inline result_type operator()(const T &x) \ { \ return f(x); \ } \ } // every type MAKE_UNARY_FUNCTION_ADAPTER(cos, cos); MAKE_UNARY_FUNCTION_ADAPTER(cosh, cosh); MAKE_UNARY_FUNCTION_ADAPTER(exp, exp); MAKE_UNARY_FUNCTION_ADAPTER(log, log); MAKE_UNARY_FUNCTION_ADAPTER(log10, log10); MAKE_UNARY_FUNCTION_ADAPTER(sin, sin); MAKE_UNARY_FUNCTION_ADAPTER(sinh, sinh); MAKE_UNARY_FUNCTION_ADAPTER(sqrt, sqrt); MAKE_UNARY_FUNCTION_ADAPTER(tan, tan); MAKE_UNARY_FUNCTION_ADAPTER(tanh, tanh); MAKE_UNARY_FUNCTION_ADAPTER(floor, my_floor); MAKE_UNARY_FUNCTION_ADAPTER(ceil, my_ceil); #undef MAKE_UNARY_FUNCTION_ADAPTER // to real ------------------------------------------------------------------ #define MAKE_UNARY_TO_REAL_FUNCTION_ADAPTER(NAME, f) \ template \ struct simple_function_adapter_##NAME \ { \ typedef typename decomplexify::type result_type; \ \ inline result_type operator()(const T &x) \ { \ return f(x); \ } \ } MAKE_UNARY_TO_REAL_FUNCTION_ADAPTER(absolute, my_abs); MAKE_UNARY_TO_REAL_FUNCTION_ADAPTER(arg, my_arg); #undef MAKE_UNARY_TO_REAL_FUNCTION_ADAPTER template struct unary_ufunc_applicator { typedef typename change_value_type::type result_type; static result_type *apply(MatrixType &m) { Function f; std::auto_ptr new_mat( generic_ublas::newWithShape(generic_ublas::getShape(m))); // FIXME: should be const generic_ublas::matrix_iterator first = generic_ublas::begin(m), last = generic_ublas::end(m); while (first != last) { generic_ublas::set(*new_mat, first.index(), f(*first)); ++first; } return new_mat.release(); } }; // binary ufuncs ------------------------------------------------------------ template struct reverse_binary_function : public std::binary_function { typename Function::result_type operator()( const typename Function::second_argument_type &a2, const typename Function::first_argument_type &a1) { Function f; return f(a1, a2); } }; template ::type> struct binary_ufunc_applicator { template static MatrixType *applyBackend(RealFunction f, const MatrixType &m1, python::object obj) { typedef typename MatrixType::value_type value_type; typedef ublas::vector vector_type; typedef typename decomplexify::type nc_value_type; typedef typename MatrixType::const_iterator1 it1_t; typedef typename MatrixType::const_iterator2 it2_t; python::extract m2_extractor(obj); python::extract v2_extractor(obj); python::extract s2_extractor(obj); python::extract n2_extractor(obj); std::auto_ptr new_mat(new MatrixType(m1.size1(), m1.size2())); if (m2_extractor.check()) { const MatrixType &m2 = m2_extractor(); if (m1.size1() != m2.size1() || m1.size2() != m2.size2()) throw std::runtime_error("cannot apply binary ufunc to arrays of different sizes"); for (it1_t it1 = m1.begin1(); it1 != m1.end1(); ++it1) for (it2_t it2 = it1.begin(); it2 != it1.end(); ++it2) new_mat->insert(it2.index1(), it2.index2(), f(*it2, m2(it2.index1(), it2.index2()))); } else if (v2_extractor.check()) { const vector_type &v2 = v2_extractor(); if (m1.size2() != v2.size()) throw std::runtime_error("cannot apply binary ufunc to arrays of different sizes"); for (it1_t it1 = m1.begin1(); it1 != m1.end1(); ++it1) for (it2_t it2 = it1.begin(); it2 != it1.end(); ++it2) new_mat->insert(it2.index1(), it2.index2(), f(*it2, v2(it2.index2()))); } else if (s2_extractor.check()) { value_type s2 = s2_extractor(); for (it1_t it1 = m1.begin1(); it1 != m1.end1(); ++it1) for (it2_t it2 = it1.begin(); it2 != it1.end(); ++it2) new_mat->insert(it2.index1(), it2.index2(), f(*it2, s2)); } else if (n2_extractor.check()) { value_type n2 = n2_extractor(); for (it1_t it1 = m1.begin1(); it1 != m1.end1(); ++it1) for (it2_t it2 = it1.begin(); it2 != it1.end(); ++it2) new_mat->insert(it2.index1(), it2.index2(), f(*it2, n2)); } else { PyErr_SetString(PyExc_TypeError, "unidentified second operand to matrix ufunc"); throw python::error_already_set(); } return new_mat.release(); } static MatrixType *apply(const MatrixType &m1, python::object obj) { return applyBackend(Function(), m1, obj); } static MatrixType *applyReversed(const MatrixType &m2, python::object obj) { return applyBackend(reverse_binary_function(), m2, obj); } }; template struct binary_ufunc_applicator { template static MatrixType *applyBackend(RealFunction f, const MatrixType &m1, python::object obj) { typedef typename MatrixType::value_type value_type; typedef typename decomplexify::type nc_value_type; typedef typename MatrixType::const_iterator it_t; python::extract m2_extractor(obj); python::extract s2_extractor(obj); python::extract n2_extractor(obj); std::auto_ptr new_mat(new MatrixType(m1.size())); if (m2_extractor.check()) { const MatrixType &m2 = m2_extractor(); if (m1.size() != m2.size()) throw std::runtime_error("cannot apply binary ufunc to vectors of different sizes"); for (it_t it = m1.begin(); it != m1.end(); ++it) new_mat->insert(it.index(), f(*it, m2(it.index()))); } else if (s2_extractor.check()) { value_type s2 = s2_extractor(); for (it_t it = m1.begin(); it != m1.end(); ++it) new_mat->insert(it.index(), f(*it, s2)); } else if (n2_extractor.check()) { value_type n2 = n2_extractor(); for (it_t it = m1.begin(); it != m1.end(); ++it) new_mat->insert(it.index(), f(*it, n2)); } else { PyErr_SetString(PyExc_TypeError, "unidentified second operand to matrix ufunc"); throw python::error_already_set(); } return new_mat.release(); } static MatrixType *apply(const MatrixType &m1, python::object obj) { return applyBackend(Function(), m1, obj); } static MatrixType *applyReversed(const MatrixType &m2, python::object obj) { return applyBackend(reverse_binary_function(), m2, obj); } }; } // wrapper for stuff that is common to vectors and matrices ------------------- template static void exposeUfuncs(PythonClass &pyc, WrappedClass) { typedef typename WrappedClass::value_type value_type; pyc .def("_ufunc_conjugate", conjugateWrapper::apply, python::return_value_policy()) .add_property("real", realWrapper::apply) .add_property("imaginary", imagWrapper::apply); #define MAKE_UNARY_UFUNC(f) \ pyc.def("_ufunc_" #f, ufuncs::unary_ufunc_applicator >::apply, \ python::return_value_policy()); MAKE_UNARY_UFUNC(cos); MAKE_UNARY_UFUNC(cosh); MAKE_UNARY_UFUNC(exp); MAKE_UNARY_UFUNC(log); MAKE_UNARY_UFUNC(log10); MAKE_UNARY_UFUNC(sin); MAKE_UNARY_UFUNC(sinh); MAKE_UNARY_UFUNC(sqrt); MAKE_UNARY_UFUNC(tan); MAKE_UNARY_UFUNC(tanh); MAKE_UNARY_UFUNC(floor); MAKE_UNARY_UFUNC(ceil); MAKE_UNARY_UFUNC(arg); MAKE_UNARY_UFUNC(absolute); #undef MAKE_UNARY_UFUNC #define MAKE_BINARY_UFUNC(NAME, f) \ pyc.def("_ufunc_" NAME, ufuncs::binary_ufunc_applicator >::apply, \ python::return_value_policy()); #define MAKE_REVERSE_BINARY_UFUNC(NAME, f) \ pyc.def("_reverse_ufunc_" NAME, ufuncs::binary_ufunc_applicator >::applyReversed, \ python::return_value_policy()); MAKE_BINARY_UFUNC("add", std::plus); MAKE_BINARY_UFUNC("subtract", std::minus); MAKE_REVERSE_BINARY_UFUNC("subtract", std::minus); MAKE_BINARY_UFUNC("multiply", std::multiplies); MAKE_BINARY_UFUNC("divide", std::divides); MAKE_REVERSE_BINARY_UFUNC("divide", std::divides); MAKE_BINARY_UFUNC("divide_safe", std::divides); // FIXME: bogus MAKE_REVERSE_BINARY_UFUNC("divide_safe", std::divides); // FIXME: bogus MAKE_BINARY_UFUNC("power", ufuncs::power); MAKE_REVERSE_BINARY_UFUNC("power", ufuncs::power); MAKE_BINARY_UFUNC("maximum", ufuncs::maximum); MAKE_BINARY_UFUNC("minimum", ufuncs::minimum); #undef MAKE_BINARY_UFUNC } template static void exposeElementWiseBehavior(PythonClass &pyc, WrappedClass) { typedef typename WrappedClass::value_type value_type; pyc .def("typecode", &typecode) .def("copy", copyNew, python::return_value_policy()) .add_property("shape", (python::object (*)(const WrappedClass &)) getShape, (void (*)(WrappedClass &, const python::tuple &)) setShape) .def("__len__", (unsigned (*)(const WrappedClass &)) getLength) .def("swap", &WrappedClass::swap) .def("__getitem__", (python::handle (*)(const WrappedClass &, PyObject *)) getElement) .def("__setitem__", (void (*)(WrappedClass &, PyObject *, python::object &)) setElement) // stringification .def("__repr__", &stringify) // FIXME: doesn't quite conform to requirements // unary negation .def("__neg__", negateOp) // matrix - matrix .def("__add__", plusOp) .def("__sub__", minusOp) .def("__iadd__", plusAssignOp, python::return_self<>()) .def("__isub__", minusAssignOp, python::return_self<>()) // scalar - matrix .def("__mul__", scalarTimesOp) .def("__rmul__", scalarTimesOp) .def("__div__", scalarDivideOp) .def("__imul__", scalarTimesAssignOp, python::return_self<>()) .def("__idiv__", scalarDivideAssignOp, python::return_self<>()) ; if (helpers::isComplex(value_type())) { // scalar-matrix for complex types pyc .def("__mul__", scalarTimesOp) .def("__rmul__", scalarTimesOp) .def("__div__", scalarDivideOp) .def("__imul__", scalarTimesAssignOp, python::return_self<>()) .def("__idiv__", scalarDivideAssignOp, python::return_self<>()) ; } exposeUfuncs(pyc, WrappedClass()); // pickling if (helpers::isSparse(WrappedClass())) pyc.def_pickle(sparse_pickle_suite()); else pyc.def_pickle(dense_pickle_suite()); } template static void exposeIterator(PythonClass &pyc, const std::string &python_typename, WrappedClass) { typedef python_matrix_value_iterator value_iterator; typedef python_matrix_key_iterator key_iterator; pyc .def("__iter__", &value_iterator::obtain, python::return_value_policy >()) .def("indices", &key_iterator::obtain, python::return_value_policy >()) ; class_ ((python_typename + "KeyIterator").c_str(), python::no_init) .def("next", &key_iterator::next) .def("__iter__", &key_iterator::iter, python::return_self<>()) ; class_ ((python_typename + "ValueIterator").c_str(), python::no_init) .def("next", &value_iterator::next) .def("__iter__", &value_iterator::iter, python::return_self<>()) ; } // vector wrapper ------------------------------------------------------------- template static void exposeVectorConcept(PythonClass &pyc, WrappedClass) { typedef typename WrappedClass::value_type value_type; exposeElementWiseBehavior(pyc, WrappedClass()); // inner and outer products pyc .def("_internal_innerproduct", inner_prodWrapper::apply) .def("_internal_outerproduct", outer_prodWrapper::apply, python::return_value_policy()); } template static void exposeVectorConvertersForValueType(PythonClass &pyclass, ValueType) { pyclass .def(python::init &>()) ; } template static void exposeVectorConverters(PythonClass &pyclass, T) { exposeVectorConvertersForValueType(pyclass, T()); } template static void exposeVectorConverters(PythonClass &pyclass, std::complex) { exposeVectorConvertersForValueType(pyclass, T()); exposeVectorConvertersForValueType(pyclass, std::complex()); } template static void exposeVectorType(WrappedClass, const std::string &python_typename, const std::string &python_eltypename) { std::string total_typename = python_typename + python_eltypename; class_ pyclass(total_typename.c_str()); pyclass .def(python::init()) .def("getFilledMatrix", &getFilledVector, python::return_value_policy()) .staticmethod("getFilledMatrix") ; exposeVectorConcept(pyclass, WrappedClass()); exposeIterator(pyclass, total_typename, WrappedClass()); exposeVectorConverters(pyclass, typename WrappedClass::value_type()); } // matrix wrapper ------------------------------------------------------------- template static void exposeMatrixConcept(PythonClass &pyclass, WrappedClass) { typedef typename WrappedClass::value_type value_type; exposeElementWiseBehavior(pyclass, WrappedClass()); // products pyclass .def("_internal_transpose", transposeMatrix, python::return_value_policy()) .def("_internal_hermite", hermiteMatrix, python::return_value_policy()) .def("_internal_multiplyVector", multiplyVector, python::return_value_policy()) .def("_internal_premultiplyVector", premultiplyVector, python::return_value_policy()) .def("_internal_multiplyMatrix", multiplyMatrix, python::return_value_policy()) .def("addScattered", addScattered) .def("addScatteredSymmetric", addScatteredSymmetric) .def("solveLower", solveLower, python::return_value_policy()) .def("solveUpper", solveUpper, python::return_value_policy()) ; } template struct matrix_converter_exposer { PythonClass &m_pyclass; public: matrix_converter_exposer(PythonClass &pyclass) : m_pyclass(pyclass) { } template void expose(const std::string &python_mattype, MatrixType) const { m_pyclass .def(python::init()); } }; template static void exposeMatrixType(WrappedClass, const std::string &python_typename, const std::string &python_eltypename) { std::string total_typename = python_typename + python_eltypename; class_ pyclass(total_typename.c_str()); pyclass .def(python::init()) // special constructors .def("getFilledMatrix", &getFilledMatrix, python::return_value_policy()) .staticmethod("getFilledMatrix") ; exposeMatrixConcept(pyclass, WrappedClass()); exposeIterator(pyclass, total_typename, WrappedClass()); exposeForMatricesConvertibleTo(matrix_converter_exposer >(pyclass), typename WrappedClass::value_type()); } #define EXPOSE_ALL_TYPES \ exposeAll(double(), "Float64"); \ exposeAll(std::complex(), "Complex64"); \ } // private namespace // EMACS-FORMAT-TAG // // Local Variables: // mode: C++ // eval: (c-set-style "stroustrup") // eval: (c-set-offset 'access-label -2) // eval: (c-set-offset 'inclass '++) // c-basic-offset: 2 // tab-width: 8 // End: PyLinear-0.91/extensions/matrices_sparse_build.cpp0000644000175000001440000000045210135202257022204 0ustar akusers00000000000000#include "matrices.hpp" template static void exposeAll(ValueType, const std::string &python_eltypename) { exposeMatrixType(ublas::coordinate_matrix(), "SparseBuildMatrix", python_eltypename); } void pylinear_expose_sparse_build() { EXPOSE_ALL_TYPES; } PyLinear-0.91/extensions/matrices_sparse_ex.cpp0000644000175000001440000000047710135202257021530 0ustar akusers00000000000000#include "matrices.hpp" template static void exposeAll(ValueType, const std::string &python_eltypename) { exposeMatrixType(ublas::compressed_matrix(), "SparseExecuteMatrix", python_eltypename); } void pylinear_expose_sparse_ex() { EXPOSE_ALL_TYPES; } PyLinear-0.91/extensions/meta.hpp0000644000175000001440000001440210135202257016574 0ustar akusers00000000000000#ifndef HEADER_SEEN_META_HPP #define HEADER_SEEN_META_HPP #include #include #include #include #include #include using namespace boost; namespace ublas = boost::numeric::ublas; using generic_ublas::is_vector; // typecode support ----------------------------------------------------------- enum SupportedElementTypes { Float64, Complex64, }; inline SupportedElementTypes getTypeCode(double) { return Float64; } inline SupportedElementTypes getTypeCode(std::complex) { return Complex64; } template inline SupportedElementTypes typecode(const MatrixType &) { return getTypeCode(typename MatrixType::value_type()); } // metaprogramming helpers ---------------------------------------------------- namespace value_type_promotion { using std::complex; template struct bigger_type { }; template struct bigger_type { typedef A type; }; template <> struct bigger_type { typedef double type; }; template <> struct bigger_type > { typedef complex type; }; template <> struct bigger_type > { typedef complex type; }; template <> struct bigger_type > { typedef complex type; }; template <> struct bigger_type > { typedef complex type; }; template <> struct bigger_type, complex > { typedef complex type; }; // and the other way around template <> struct bigger_type { typedef double type; }; template <> struct bigger_type, float> { typedef complex type; }; template <> struct bigger_type, float> { typedef complex type; }; template <> struct bigger_type, double> { typedef complex type; }; template <> struct bigger_type, double> { typedef complex type; }; template <> struct bigger_type, complex > { typedef complex type; }; } // change_value_type template struct change_value_type { }; template struct change_value_type, NewValueType> { typedef ublas::matrix type; }; template struct change_value_type, NewValueType> { typedef ublas::sparse_matrix type; }; template struct change_value_type, NewValueType> { typedef ublas::coordinate_matrix type; }; template struct change_value_type, NewValueType> { typedef ublas::compressed_matrix type; }; template struct change_value_type, NewValueType> { typedef ublas::vector type; }; template struct change_value_type, NewValueType> { typedef managed_symmetric_adaptor< typename change_value_type::type> type; }; template struct change_value_type, NewValueType> { typedef managed_hermitian_adaptor< typename change_value_type::type> type; }; // get_corresponding_vector_type template struct get_corresponding_vector_type { typedef ublas::vector type; }; // strip_symmetric_wrappers template struct strip_symmetric_wrappers { typedef MatrixType type; }; template struct strip_symmetric_wrappers > { typedef MatrixType type; }; template struct strip_symmetric_wrappers > { typedef MatrixType type; }; // generic instantiation infrastructure --------------------------------------- template static void exposeForAllSimpleTypes(const std::string &python_eltname, const Exposer &exposer, ValueType) { exposer.expose("Matrix" + python_eltname, ublas::matrix()); exposer.expose("SparseExecuteMatrix" + python_eltname, ublas::compressed_matrix()); exposer.expose("SparseBuildMatrix" + python_eltname, ublas::coordinate_matrix()); } template static void exposeForAllMatrices(const Exposer &exposer, T) { exposeForAllSimpleTypes("Float64", exposer, T()); exposer.expose("SparseSymmetricExecuteMatrixFloat64", managed_symmetric_adaptor< ublas::compressed_matrix >()); exposer.expose("SparseSymmetricBuildMatrixFloat64", managed_symmetric_adaptor< ublas::coordinate_matrix >()); } template static void exposeForAllMatrices(const Exposer &exposer, std::complex) { exposeForAllSimpleTypes("Complex64", exposer, std::complex()); exposer.expose("SparseHermitianExecuteMatrixComplex64", managed_hermitian_adaptor< ublas::compressed_matrix, ublas::column_major> >()); exposer.expose("SparseHermitianBuildMatrixComplex64", managed_hermitian_adaptor< ublas::coordinate_matrix > >()); } template static void exposeForAllMatrices(const Exposer &exposer) { exposeForAllMatrices(exposer, double()); exposeForAllMatrices(exposer, std::complex()); } template static void exposeForMatricesConvertibleTo(const Exposer &exposer, T) { exposeForAllMatrices(exposer, T()); } template static void exposeForMatricesConvertibleTo(const Exposer &exposer, std::complex) { exposeForAllMatrices(exposer); } #endif PyLinear-0.91/extensions/python_helpers.hpp0000644000175000001440000000105410135202257020710 0ustar akusers00000000000000#ifndef HEADER_SEEN_PYTHON_HELPERS_H #define HEADER_SEEN_PYTHON_HELPERS_H #include template inline boost::python::handle handle_from_new_ptr(T *ptr) { typename boost::python::manage_new_object::apply::type out_converter; return boost::python::handle(out_converter(ptr)); } template inline boost::python::handle handle_from_object(const T &val) { return boost::python::handle(boost::python::borrowed(boost::python::object(val).ptr())); } #endif PyLinear-0.91/extensions/vectors.cpp0000644000175000001440000000041610135202257017326 0ustar akusers00000000000000#include "matrices.hpp" template static void exposeAll(ValueType, const std::string &python_eltypename) { exposeVectorType(ublas::vector(), "Vector", python_eltypename); } void pylinear_expose_vectors() { EXPOSE_ALL_TYPES; } PyLinear-0.91/pylinear/0000755000175000001440000000000010135231541014556 5ustar akusers00000000000000PyLinear-0.91/pylinear/__init__.py0000644000175000001440000000001010135202257016660 0ustar akusers00000000000000# blank PyLinear-0.91/pylinear/algorithms.py0000644000175000001440000000534110135202257017306 0ustar akusers00000000000000import pylinear.matrices as num from pylinear._algorithms import * def _lookupClass(name_trunk, typecode, dict = None): name = name_trunk if typecode == num.Float64: name += "Float64" elif typecode == num.Complex64: name += "Complex64" else: raise RuntimeError, "Invalid element type requested" if dict is None: return eval(name) else: return dict[name] def makeIdentityMatrixOperator(n, typecode): my_class = _lookupClass("IdentityMatrixOperator", typecode) return my_class(n) def makeScalarMultiplicationMatrixOperator(factor, n, typecode): my_class = _lookupClass("ScalarMultiplicationMatrixOperator", typecode) return my_class(factor, n) def makeCGMatrixOperator(matrix_op, max_it, tol = 1e-12, precon_op = None): if precon_op is None: h,w = matrix_op.shape precon_op = makeIdentityMatrixOperator(w, matrix_op.typecode()) my_class = _lookupClass("CGMatrixOperator", matrix_op.typecode()) return my_class(matrix_op, precon_op, max_it, tol) def makeUMFPACKMatrixOperator(matrix): my_class = _lookupClass("UMFPACKMatrixOperator", matrix.typecode()) return my_class(matrix) def makeBiCGSTABMatrixOperator(matrix_op, max_it, tol = 1e-12, precon_op = None): if precon_op is None: h,w = matrix_op.shape precon_op = makeIdentityMatrixOperator(w, matrix_op.typecode()) my_class = _lookupClass("BiCGSTABMatrixOperator", matrix_op.typecode()) return my_class(matrix_op, precon_op, max_it, tol) def composeMatrixOperators(outer, inner): if outer.typecode() != inner.typecode(): raise TypeError, "outer and inner have to have identical typecode" my_class = _lookupClass("CompositeMatrixOperator", inner.typecode()) return my_class(outer, inner) def adaptRealToComplexOperator(real_part, imaginary_part): if real_part.typecode() != imaginary_part.typecode(): raise TypeError, "outer and inner have to have identical typecode" my_class = _lookupClass("ComplexMatrixOperatorAdaptor", real_part.typecode()) return my_class(real_part, imaginary_part) def addMatrixOperators(op1, op2): if op1.typecode() != op2.typecode(): raise TypeError, "op1 and op2 have to have identical typecode" my_class = _lookupClass("SumOfMatrixOperators", op1.typecode()) return my_class(op1, op2) def applyMatrixOperator(mat_op, vec): if mat_op.typecode() is num.Float and vec.typecode() is num.Complex: return num.asarray(applyMatrixOperator(mat_op, vec.real), num.Complex) \ + 1j * num.asarray(applyMatrixOperator(mat_op, vec.imaginary), num.Complex) h, w = mat_op.shape temp = num.zeros((h,), vec.typecode()) mat_op.apply(vec, temp) return temp PyLinear-0.91/pylinear/iteration.py0000644000175000001440000001146610135202257017140 0ustar akusers00000000000000import os class tIterationSuccessful(Exception): def __init__(self, value): Exception.__init__(self, value) class tIterationStalled(Exception): def __init__(self, value): Exception.__init__(self, value) class tIterationStopped(Exception): def __init__(self, value): Exception.__init__(self, value) class tIterationCountExceeded(Exception): def __init__(self, value): Exception.__init__(self, value) class tIterationObserver: def __init__(self): pass def reset(self): pass def addDataPoint(self, residual): pass class tRelativeGoalDetector(tIterationObserver): def __init__(self, tolerance): tIterationObserver.__init__(self) self.Tolerance = tolerance def reset(self): self.FirstResidual = None def addDataPoint(self, residual): if self.FirstResidual is None: self.FirstResidual = residual else: if residual < self.Tolerance * self.FirstResidual: raise tIterationSuccessful, "Iteration successful." class tIterationStallDetector(tIterationObserver): def __init__(self, tolerance, max_stalls = 1): tIterationObserver.__init__(self) self.Tolerance = tolerance self.MaxStalls = max_stalls def reset(self): self.BiggestProgress = 1. self.LastResidual = None self.Stalls = 0 def addDataPoint(self, residual): if self.LastResidual is not None: progress = max(1, self.LastResidual / residual) self.BiggestProgress = max(progress, self.BiggestProgress) stalled = False if self.BiggestProgress - 1 < 1e-10: stalled = True else: if (progress - 1)/(self.BiggestProgress - 1) < self.Tolerance: stalled = True if stalled: self.Stalls += 1 if self.Stalls >= self.MaxStalls: raise tIterationStalled, "No progress is being made." else: self.Stalls = 0 self.LastResidual = residual class tLastChangeLessThan(tIterationObserver): def __init__(self, tolerance, max_stalls = 1): tIterationObserver.__init__(self) self.Tolerance = tolerance self.MaxStalls = max_stalls def reset(self): self.LastResidual = None self.Stalls = 0 def addDataPoint(self, residual): if self.LastResidual is not None: stalled = False if (self.LastResidual - residual)/self.LastResidual < self.Tolerance: # (condition includes the case of LastResidual < residual) stalled = True if stalled: self.Stalls += 1 if self.Stalls >= self.MaxStalls: raise tIterationStalled, "No progress is being made." else: self.Stalls = 0 self.LastResidual = residual class tInteractiveStopper(tIterationObserver): def addDataPoint(self, residual): filename = "STOP-ITERATION-%d" % os.getpid() try: file(filename, "r") os.unlink(filename) raise tIterationStopped, "Stop requested by user." except IOError: pass class tMaxIterationCountChecker(tIterationObserver): def __init__(self, max_iterations): tIterationObserver.__init__(self) self.MaxIterations = max_iterations self.IterationNumber = 0 def addDataPoint(self, residual): self.IterationNumber += 1 if self.IterationNumber >= self.MaxIterations: raise tIterationCountExceeded("Maximum number of iterations reached.") class tCombinedObserver(tIterationObserver): def __init__(self, observers = []): tIterationObserver.__init__(self) self.Observers = observers[:] def reset(self): for obs in self.Observers: obs.reset() def addDataPoint(self, residual): for obs in self.Observers: obs.addDataPoint(residual) def makeObserver(max_it = None, stall_thresh = None, max_stalls = 1, min_change = None, max_unchanged = 1, rel_goal = None): """Only ever refer to the arguments of this routine by keyword, since argument order is not guaranteed to be stable. """ observers = [tInteractiveStopper()] if max_it is not None: observers.append(tMaxIterationCountChecker(max_it)) if stall_thresh is not None: observers.append(tIterationStallDetector(stall_thresh, max_stalls)) if rel_goal is not None: observers.append(tRelativeGoalDetector(rel_goal)) if min_change is not None: observers.append(tLastChangeLessThan(min_change, max_unchanged)) return tCombinedObserver(observers) PyLinear-0.91/pylinear/linear_algebra.py0000644000175000001440000000450310135202257020063 0ustar akusers00000000000000import pylinear.matrices as num import pylinear.algorithms as algo def solve_linear_equations_umf(mat, rhs): typecode = mat.typecode() h,w = mat.shape umf_operator = algo.makeUMFPACKMatrixOperator( num.asarray(mat, mat.typecode(), num.SparseExecuteMatrix)) temp = num.zeros((h,), typecode) if len(rhs.shape) == 1: umf_operator.apply(rhs, temp) return temp else: rhh, rhw = rhs.shape solution = num.zeros(rhs.shape, typecode) assert rhh == h for col in range(rhw): umf_operator.apply(rhs[:,col], temp) solution[:,col] = temp return solution def solve_linear_equations(mat, rhs): typecode = mat.typecode() h,w = mat.shape l, u, permut, sign = algo.lu(mat) temp = num.zeros((h,), typecode) if len(rhs.shape) == 1: for i in range(h): temp[i] = rhs[permut[i]] return u.solveUpper(l.solveLower(temp)) else: rhh, rhw = rhs.shape solution = num.zeros(rhs.shape, typecode) assert rhh == h for col in range(rhw): for i in range(h): temp[i] = rhs[permut[i],col] solution[:,col] = u.solveUpper(l.solveLower(temp)) return solution def inverse(mat): w,h = mat.shape assert h == w return solve_linear_equations(mat, num.identity(h, mat.typecode())) def determinant(mat): h,w = mat.shape assert h == w if h == 2: return mat[0,0]*mat[1,1] - mat[1,0]*mat[0,1] else: try: l,u, permut, sign = algo.lu(mat) product = 1 for i in range(h): product *= u[i,i] return product * sign except RuntimeError: # responds to the "is singular" exception return 0 singular_value_decomposition = algo.singular_value_decomposition def Heigenvalues(mat, upper = True): q, w = algo.Heigenvectors(False, upper, mat) return w def Heigenvectors(mat, upper = True): return algo.Heigenvectors(True, upper, mat) def eigenvalues(mat): w, vl, vr = algo.eigenvectors(False, False, mat) return w def eigenvectors(mat): w, vl, vr = algo.eigenvectors(False, True, mat) return vr, w def cholesky_decomposition(a): return algo.cholesky(a) PyLinear-0.91/pylinear/matrices.py0000644000175000001440000002231110135202257016740 0ustar akusers00000000000000import types from pylinear._matrices import * # element type aliases -------------------------------------------------------- Float = Float64 Complex = Complex64 # matrix types ---------------------------------------------------------------- _TYPECODES = [ Float64, Complex64 ] def _getTypeCodeName(typecode): if typecode == Float64: return "Float64" elif typecode == Complex64: return "Complex64" else: raise RuntimeError, "Invalid typecode specified" class MatrixType: def isA(cls, object): for tc in _TYPECODES: try: t = eval(cls.name()+_getTypeCodeName(tc)) if type(object) is t: return True except: pass return False isA = classmethod(isA) class Vector(MatrixType): def name(): return "Vector" name = staticmethod(name) class DenseMatrix(MatrixType): def name(): return "Matrix" name = staticmethod(name) class SparseBuildMatrix(MatrixType): def name(): return "SparseBuildMatrix" name = staticmethod(name) class SparseExecuteMatrix(MatrixType): def name(): return "SparseExecuteMatrix" name = staticmethod(name) class SparseSymmetricExecuteMatrix(MatrixType): def name(): return "SparseSymmetricExecuteMatrix" name = staticmethod(name) class SparseHermitianExecuteMatrix(MatrixType): def name(): return "SparseHermitianExecuteMatrix" name = staticmethod(name) class SparseSymmetricBuildMatrix(MatrixType): def name(): return "SparseSymmetricBuildMatrix" name = staticmethod(name) class SparseHermitianBuildMatrix(MatrixType): def name(): return "SparseHermitianBuildMatrix" name = staticmethod(name) _TYPES = [ Vector, DenseMatrix, SparseBuildMatrix, SparseExecuteMatrix, SparseSymmetricExecuteMatrix, SparseHermitianExecuteMatrix, SparseSymmetricBuildMatrix, SparseHermitianBuildMatrix ] # Tools ----------------------------------------------------------------------- def _maxTypeCode(list): if Complex in list: return Complex else: return Float # class getter ---------------------------------------------------------------- def _makeRightType(name_trunk, typecode): return globals()[name_trunk + _getTypeCodeName(typecode)] def _getMatrixClass(rank, typecode, matrix_type): if rank == 1: typename = "Vector" else: if rank != 2: raise RuntimeError, "rank must be one or two" typename = matrix_type.name() return _makeRightType(typename, typecode) def _getMatrixType(data): for t in _TYPES: if t.isA(data): return t raise RuntimeError, "Apparently not a matrix type" # construction functions ------------------------------------------------------ def array(data, typecode = None): # slow, but that doesn't matter so much def getRank(data): try: return 1+getRank(data[0]) except: return 0 def getBiggestType(data, prev_biggest_type = Float64): try: data[0][0] for i in data: prev_biggest_type = getBiggestType(i, prev_biggest_type) return prev_biggest_type except TypeError, e: for i in data: if type(i) is types.ComplexType: prev_biggest_type = Complex return prev_biggest_type rank = getRank(data) if typecode is None: typecode = getBiggestType(data) mat_class = _getMatrixClass(rank, typecode, DenseMatrix) if rank == 2: h = len(data) if h == 0: return mat_class(0, 0) w = len(data[0]) result = mat_class(h, w) for i in range(h): for j in range(w): result[i,j] = data[i][j] return result elif rank == 1: h = len(data) result = mat_class(h) for i in range(h): result[i] = data[i] return result def asarray(data, typecode, matrix_type = None): given_matrix_type = _getMatrixType(data) if matrix_type is None: matrix_type = given_matrix_type if data.typecode() == typecode and given_matrix_type == matrix_type: return data mat_class = _getMatrixClass(len(data.shape), typecode, matrix_type) return mat_class(data) def _getFilledMatrix(shape, typecode, matrix_type, fill_value): matrix_class = _getMatrixClass(len(shape), typecode, matrix_type) if len(shape) == 1: return matrix_class.getFilledMatrix(shape[0], fill_value) else: return matrix_class.getFilledMatrix(shape[0], shape[1], fill_value) def zeros(shape, typecode, matrix_type = DenseMatrix): matrix_class = _getMatrixClass(len(shape), typecode, matrix_type) if len(shape) == 1: return matrix_class(shape[0]) else: return matrix_class(shape[0], shape[1]) def ones(shape, typecode, matrix_type = DenseMatrix): return _getFilledMatrix(shape, typecode, matrix_type, 1) def identity(n, typecode, matrix_type = DenseMatrix): result = zeros((n,n), typecode, matrix_type) for i in range(n): result[i,i] = 1 return result # other functions ------------------------------------------------------------- def diagonal(mat, offset = 0): h,w = mat.shape result = [] if offset >= 0: # upwards offset, i.e. to the right post_end_row = min(offset+h, w) length = post_end_row - offset result = zeros((length,), mat.typecode()) if length < 0: raise ValueError, "diagonal: invalid offset" for i in range(length): result[i] = mat[i, i+offset] return result else: # downwards offset offset = - offset post_end_col = min(offset+w, h) length = post_end_col - offset result = zeros((length,), mat.typecode()) if length < 0: raise ValueError, "diagonal: invalid offset" for i in range(length): result[i] = mat[i+offset, i] return result def take(mat, indices, axis = 0): return array([mat[i] for i in indices], mat.typecode()) def matrixmultiply(mat1, mat2): try: if len(mat2.shape) == 1: return mat1._internal_multiplyVector(mat2) elif len(mat1.shape) == 1: return mat2._internal_premultiplyVector(mat1) else: return mat1._internal_multiplyMatrix(mat2) except: if mat1.typecode() == mat2.typecode(): raise mtc = _maxTypeCode([mat1.typecode(), mat2.typecode()]) return matrixmultiply(asarray(mat1, mtc), asarray(mat2, mtc)) def innerproduct(vec1, vec2): try: return vec1._internal_innerproduct(vec2) except: if vec1.typecode() == vec2.typecode(): raise mtc = _maxTypeCode([vec1.typecode(), vec2.typecode()]) return innerproduct(asarray(vec1, mtc), asarray(vec2, mtc)) def outerproduct(vec1, vec2): try: return vec1._internal_outerproduct(vec2) except: if vec1.typecode() == vec2.typecode(): raise mtc = _maxTypeCode([vec1.typecode(), vec2.typecode()]) return outerproduct(asarray(vec1, mtc), asarray(vec2, mtc)) def transpose(mat): return mat._internal_transpose() def hermite(mat): return mat._internal_hermite() def trace(mat, k = 0): diag = diagonal(mat, k) return sum(diag) # ufuncs ---------------------------------------------------------------------- def conjugate(m): return m._ufunc_conjugate() def cos(m): return m._ufunc_cos() def cosh(m): return m._ufunc_cosh() def exp(m): return m._ufunc_exp() def log(m): return m._ufunc_log() def log10(m): return m._ufunc_log10() def sin(m): return m._ufunc_sin() def sinh(m): return m._ufunc_sinh() def sqrt(m): return m._ufunc_sqrt() def tan(m): return m._ufunc_tan() def tanh(m): return m._ufunc_tanh() def floor(m): return m._ufunc_floor() def ceil(m): return m._ufunc_ceil() def arg(m): return m._ufunc_arg() def absolute(m): return m._ufunc_absolute() def add(ma, mb): try: return ma._ufunc_add(mb) except (AttributeError, TypeError): return mb._ufunc_add(ma) def subtract(ma, mb): try: return ma._ufunc_subtract(mb) except (AttributeError, TypeError): return mb._reverse_ufunc_subtract(ma) def multiply(ma, mb): try: return ma._ufunc_multiply(mb) except (AttributeError, TypeError): return mb._ufunc_multiply(ma) def divide(ma, mb): try: return ma._ufunc_divide(mb) except (AttributeError, TypeError): return mb._reverse_ufunc_divide(ma) def divide_safe(ma, mb): try: return ma._ufunc_divide_safe(mb) except (AttributeError, TypeError): return mb._reverse_ufunc_divide_safe(ma) def power(ma, mb): try: return ma._ufunc_power(mb) except (AttributeError, TypeError): return mb._reverse_ufunc_power(ma) def maximum(ma, mb): try: return ma._ufunc_maximum(mb) except (AttributeError, TypeError): return mb._ufunc_maximum(ma) def minimum(ma, mb): try: return ma._ufunc_minimum(mb) except (AttributeError, TypeError): return mb._ufunc_maximum(ma) PyLinear-0.91/pylinear/matrix_tools.py0000644000175000001440000004062210135202257017662 0ustar akusers00000000000000import math, cmath, random, types import pylinear.matrices as num import pylinear.linear_algebra as la import pylinear.algorithms as algo import pylinear.iteration as iteration # polynomial fits ------------------------------------------------------------- def vandermonde(vector, degree = None): if degree is None: degree = len(vector) mat = num.zeros((len(vector), degree+1), vector.typecode()) for i, v in enumerate(vector): for power in range(degree+1): mat[i,power] = v**power return mat def fit_polynomial(x_vector, data_vector, degree): vdm = vandermonde(x_vector, degree) vdm2 = num.matrixmultiply(num.hermite(vdm), vdm) rhs = num.matrixmultiply(num.hermite(vdm), data_vector) return la.solve_linear_equations(vdm2, rhs) def evaluate_polynomial(coefficients, x): # Horner evaluation size = len(coefficients) value_so_far = 0 for i in range(size): value_so_far = x * value_so_far + coefficients[size-1-i] return value_so_far def build_polynomial_function(coefficients): return lambda x: evaluate_polynomial(coefficients, x) def approximate_polynomially(x_vector, f, degree): return fit_polynomial(x_vector, num.array(map(f, x_vector)), degree) def get_approximant(x_vector, f, degree): return build_polynomial_function(approximate_polynomially(x_vector, f, degree)) # interpolation --------------------------------------------------------------- def findInterpolationCoefficients(x_vector, to_x): vm = vandermonde(x_vector, degree = len(x_vector) - 1) vm_x = vandermonde(num.array([to_x], x_vector.typecode()), len(x_vector)-1)[0] return num.matrixmultiply(vm_x, la.inverse(vm)) # matlab-workalikes ----------------------------------------------------------- def linspace(x, y, n = 100): if type(x) is types.IntType: x = float(x) if type(y) is types.IntType: y = float(y) h = (y-x) / n return [ x+h*i for i in range(n+1) ] # Jacobi rotation ------------------------------------------------------------- def _conjugate(value): try: return value.conjugate() except AttributeError: return value def _realPart(value): try: return value.real except AttributeError: return value def _imaginaryPart(value): try: return value.imag except AttributeError: return 0. class tRotationShapeMatrix: def __init__(self, i, j, ii, ij, ji, jj): self.I = i self.J = j self.II = ii self.IJ = ij self.JI = ji self.JJ = jj def hermite(self): return tRotationShapeMatrix(self.I, self.J, _conjugate(self.II), _conjugate(self.JI), _conjugate(self.IJ), _conjugate(self.JJ)) def applyFromLeft(self, mat): row_i = mat[self.I] row_j = mat[self.J] mat[self.I] = row_i * self.II + row_j * self.IJ mat[self.J] = row_j * self.JJ + row_i * self.JI def applyFromRight(self, mat): col_i = mat[:,self.I] col_j = mat[:,self.J] mat[:,self.I] = col_i * self.II + col_j * self.JI mat[:,self.J] = col_j * self.JJ + col_i * self.IJ def makeJacobiRotation(i, j, cos, sin): return tRotationShapeMatrix(i,j, cos, _conjugate(sin), -sin, _conjugate(cos)) def printMatrixInGrid(a): h,w = a.shape for i in range(h): for j in range(w): if a[i,j] == 0: print "---------- ", else: print "%.6f " % a[i,j], print def printComplexMatrixInGrid(a): h,w = a.shape for i in range(h): for j in range(w): if a[i,j] == 0: print "---------- ", else: print "%.3f %.3fj " % (a[i,j].real, a[i,j].imag), print def _sign(x): return x / abs(x) def diagonalize(matrix, compute_vectors = True, observer = iteration.makeObserver(rel_goal = 1e-10)): """This executes a simple sequence of Jacobi transform on the given symmetric positive definite matrix. It returns a tuple of matrices Q, D. Q is a unitary matrix that contains the eigenvectors of the given matrix in its columns. The following invariant holds: matrix = Q * D * Q^H. """ # Simple Jacobi rows, columns = matrix.shape tc = matrix.typecode() def off_diag_norm_squared(a): result = 0 for i,j in a.indices(): if i != j: result += abs(a[i,j])**2 return result if compute_vectors: q = num.identity(rows, tc) else: q = None mymatrix = matrix.copy() if rows == 1 and columns == 1: return q, mymatrix observer.reset() try: while True: observer.addDataPoint(math.sqrt(off_diag_norm_squared(mymatrix))) for i in range(rows): for j in range(0,min(columns,i)): if abs(mymatrix[i,j]) < 1e-10: continue theta = (mymatrix[j,j] - mymatrix[i,i])/mymatrix[i,j] t = _sign(theta)/(abs(theta)+math.sqrt(abs(theta)**2+1)) other_cos = 1 / math.sqrt(abs(t)**2 + 1) other_sin = t * other_cos rot = makeJacobiRotation(i, j, other_cos, other_sin) rot.hermite().applyFromLeft(mymatrix) rot.applyFromRight(mymatrix) if compute_vectors: rot.applyFromRight(q) except iteration.tIterationSuccessful: return q, mymatrix def codiagonalize(matrices, observer = iteration.makeObserver(stall_thresh = 1e-5, rel_goal = 1e-10)): """This executes the generalized Jacobi process from the research papers quoted below. It returns a tuple Q, diagonal_matrices, achieved_tolerance. Q is a unitary matrix that contains the eigenvectors of the given matrices in its columns, provided that complete diagonalization could be achieved. diagonal_matrices contains the elements of `matrices', diagonalized as far as possible. achieved_tolerance, lastly, represents the amount of progress made. If this value is less than the `tolerance' parameter, convergence was achieved. Otherwise, it was decided that progress was no longer being made and the iteration was aborted or the max_iterations number was hit. The following invariant holds for each element `matrix' in matrices and `D' in diagonal_matrices. and : matrix = Q * D * Q^H. For one matrix, this reduces to the diagonalize() function in this module. The matrices list is not modified, nor are any of its constituent matrices. Algorithm from: A. Bunse-Gerstner, R. Byers, V. Mehrmann: Numerical methods for simultaneous diagonalization SIAM J. of Matrix Analysis and Applications, Vol. 14, No. 4, 927-949 (1993) J.-F. Cardoso, A. Souloumiac, Jacobi Angles for Simultaneous Diagonalization, also published by SIAM. """ mm = num.matrixmultiply rows, columns = matrices[0].shape tc = matrices[0].typecode() for mat in matrices[1:]: assert mat.shape == (rows, columns) assert mat.typecode() == tc def off_diag_norm_squared(a): result = 0 for i,j in a.indices(): if i != j: result += abs(a[i,j])**2 return result q = num.identity(rows, tc) norm_before = sum([off_diag_norm_squared(mat) for mat in matrices]) mymats = [mat.copy() for mat in matrices] residual = math.sqrt(sum([off_diag_norm_squared(mat) for mat in mymats])) observer.reset() try: while True: observer.addDataPoint(residual) for i in range(rows): for j in range(0,min(columns,i)): g = num.zeros((3,3), num.Float) for a in mymats: h = num.array([_realPart(a[i,i] - a[j,j]), _realPart(a[i,j] + a[j,i]), -_imaginaryPart(a[j,i] - a[i,j])]) g += num.outerproduct(h, h) u, diag_vec = la.Heigenvectors(g) max_index = None for index in range(3): curval = abs(diag_vec[index]) if max_index is None or curval > current_max: max_index = index current_max = curval if max_index is None: continue # eigenvector belonging to largest eigenvalue bev = u[:,max_index] if bev[0] < 0: bev = - bev r = norm2(bev) if (bev[0] + r)/r < 1e-7: continue cos = math.sqrt((bev[0]+r)/(2*r)) sin = bev[1] if tc is not num.Float: sin -= 1j*bev[2] sin /= math.sqrt(2*r*(bev[0]+r)) rot = makeJacobiRotation(i, j, cos, sin) rot_h = rot.hermite() for mat in mymats: rot.applyFromLeft(mat) rot.hermite().applyFromRight(mat) rot_h.applyFromRight(q) residual = math.sqrt(sum([off_diag_norm_squared(mat) for mat in mymats])) except iteration.tIterationStalled: return q, mymats, math.sqrt(residual/norm_before) except iteration.tIterationSuccessful: return q, mymats, math.sqrt(residual/norm_before) # some tools ------------------------------------------------------------------ def solve_linear_system_cg(matrix, vector): m_inv = algo.makeCGMatrixOperator(algo.makeMatrixOperator(matrix), matrix.shape[0]*2) return algo.applyMatrixOperator(m_inv, vector) def entrySum(a): result = 0 for i,j in a.indices(): result += a[i,j] return result def frobeniusNormSquared(a): result = 0 for i,j in a.indices(): result += abs(a[i,j])**2 return result def frobeniusNorm(a): return math.sqrt(frobeniusNormSquared(a)) def matrixExp(a, eps = 1e-15): h,w = a.shape assert h == w a_frob = frobeniusNorm(a) last_result = num.identity(h, a.typecode()) result = last_result.copy() current_power_of_a = a factorial = 1 n = 1 while True: result += current_power_of_a * (1./factorial) if frobeniusNorm(result - last_result)/a_frob < eps: return result n += 1 last_result = result.copy() factorial *= n current_power_of_a = num.matrixmultiply(current_power_of_a, a) def matrixExpBySymmetricDiagonalization(a): # a has to be symmetric h,w = a.shape assert h == w q, w = la.Heigenvectors(a) d = num.zeros(a.shape, a.typecode()) for i in range(h): d[i,i] = cmath.exp(w[i]) mm = num.matrixmultiply return mm(q, mm(d, hermite(q))) def matrixExpByDiagonalization(a): h,w = a.shape assert h == w v, w = la.eigenvectors(a) e_d = num.zeros(a.shape, a.typecode()) v_t = num.transpose(v) for i in range(h): e_d[i,i] = cmath.exp(w[i]) mm = num.matrixmultiply return num.transpose(la.solve_linear_equations(v_t, mm(e_d, v_t))) def delta(x,y): if x == y: return 1 else: return 0 def sp(x,y): return num.innerproduct(x, num.conjugate(y)) def norm2squared(x): val = num.innerproduct(x,num.conjugate(x)) try: return val.real except AttributeError: # whoops. not complex return val def norm2(x): scalar_product = num.innerproduct(x,num.conjugate(x)) try: return math.sqrt(scalar_product.real) except AttributeError: # whoops. not complex return math.sqrt(scalar_product) def hermite(x): return num.transpose(num.conjugate(x)) def orthogonalize(vectors): # Gram-Schmidt FIXME: unstable done_vectors = [] for v in vectors: my_v = v.copy() for done_v in done_vectors: my_v -= sp(v,done_v) * done_v v_norm = norm2(my_v) if v_norm == 0: raise RuntimeError, "Orthogonalization failed" my_v /= v_norm done_vectors.append(my_v) return done_vectors def estimateConditionNumber(matrix, min_index = 0, threshold = None): u, s_vec, vt = la.singular_value_decomposition(matrix) s_list = list(s_vec) s_list.sort(lambda a, b: cmp(abs(a), abs(b))) i = min_index if threshold is not None: while abs(s_list[i]) < threshold and i < len(s_list): i += 1 if i == len(s_list): raise ValueError, "there is no eigenvalue above the threshold" return abs(s_list[-1])/abs(s_list[i]) # random matrices ------------------------------------------------------------- def writeRandomVector(vec): size, = vec.shape for i in range(size): value = random.normalvariate(0,10) if vec.typecode() == num.Complex64: value += 1j*random.normalvariate(0,10) vec[i] = value def makeRandomVector(size, typecode): vec = num.zeros((size,), typecode) writeRandomVector(vec) return vec def makeRandomONB(size, typecode): vectors = [ makeRandomVector(size, typecode) for i in range(size) ] vectors = orthogonalize(vectors) for i in range(size): for j in range(size): assert abs(delta(i,j) - sp(vectors[i], vectors[j])) < 1e-12 return vectors def makeRandomOrthogonalMatrix(size, typecode): vectors = [] for i in range(size): v = num.zeros((size,), typecode) writeRandomVector(v) vectors.append(v) orth_vectors = orthogonalize(vectors) mat = num.zeros((size,size), typecode) for i in range(size): mat[:,i] = orth_vectors[i] return mat def makeRandomSkewHermitianMatrix(size, typecode): a = num.zeros((size, size), typecode) # fill diagonal if typecode is num.Complex: for i in range(size): a[i,i] = 1j*random.normalvariate(0,10) # fill rest for i in range(size): for j in range(i): value = random.normalvariate(0,10) if typecode is num.Complex: value += 1j*random.normalvariate(0,10) a[i,j] = value a[j,i] = -_conjugate(value) return a def makeRandomSPDMatrix(size, typecode): eigenvalues = makeRandomVector(size, typecode) eigenmat = num.zeros((size,size), typecode) for i in range(size): eigenmat[i,i] = abs(eigenvalues[i]) orthomat = makeRandomOrthogonalMatrix(size, typecode) return num.matrixmultiply(hermite(orthomat), num.matrixmultiply(eigenmat,orthomat)) def makeFullRandomMatrix(size, typecode): result = num.zeros((size, size), typecode) for row in range(size): for col in range(size): value = random.normalvariate(0,10) if typecode == num.Complex64: value += 1j*random.normalvariate(0,10) result[row,col] = value return result def makeRandomMatrix(size, typecode, matrix_type = num.DenseMatrix): result = num.zeros((size, size), typecode, matrix_type) elements = size ** 2 / 10 for i in range(elements): row = random.randrange(0, size) col = random.randrange(0, size) value = random.normalvariate(0,10) if typecode == num.Complex64: value += 1j*random.normalvariate(0,10) result[row,col] += value return result # matrix type tests ----------------------------------------------------------- def hermiticityError(mat): return frobeniusNorm(num.hermite(mat) - mat) def skewHermiticityError(mat): return frobeniusNorm(num.hermite(mat) + mat) def symmetricityError(mat): return frobeniusNorm(num.transpose(mat) - mat) def skewSymmetricityError(mat): return frobeniusNorm(num.transpose(mat) + mat) def unitarietyError(mat): mm = num.matrixmultiply return identityError(mm(num.hermite(mat), mat)) def orthogonalityError(mat): mm = num.matrixmultiply return identityError(mm(num.transpose(mat), mat)) def identityError(mat): id = num.identity(mat.shape[0], mat.typecode()) return frobeniusNorm(mat - id) PyLinear-0.91/test/0000755000175000001440000000000010135231541013712 5ustar akusers00000000000000PyLinear-0.91/test/test_codiag.py0000644000175000001440000000112210135202257016547 0ustar akusers00000000000000import sys import pylinear.matrices as num import pylinear.linear_algebra as la import pylinear.matrix_tools as mtools def off_diag_norm_squared(a): result = 0 for i,j in a.indices(): if i != j: result += abs(a[i,j])**2 return result def off_diag_norms_squared(matrices): return sum([off_diag_norm_squared(mat) for mat in matrices]) size = 20 tc = num.Float matrices = [mtools.makeFullRandomMatrix(size, tc) for i in range(2)] print off_diag_norms_squared(matrices) q, mats, achieved = mtools.codiagonalize(matrices) print off_diag_norms_squared(mats) PyLinear-0.91/test/test_matrices.py0000644000175000001440000003467710135202257017155 0ustar akusers00000000000000import sys, random import pylinear.matrices as num import pylinear.algorithms as algo import pylinear.matrix_tools as mtools import pylinear.linear_algebra as la import pylinear.iteration as iteration from test_tools import * import unittest # TEST ME! class tMyMatrixOperator(algo.MatrixOperatorFloat64): def __init__(self, mat): self.Matrix = mat def typecode(self): return num.Float64 def size(self): w,h = self.Matrix.shape return w def apply(self, before, after): after[:] = num.matrximultiply(self.Matrix, after) class tTestMatrices(unittest.TestCase): def forAllTypecodes(self, f): f(num.Float) f(num.Complex) def assertSmall(self, matrix): self.assert_(mtools.frobeniusNorm(matrix) < 1e-10) def assertZero(self, matrix): for i in matrix: for j in i: self.assert_(j == 0) def testElementaryStuff(self): mat = num.zeros((3, 3), num.Complex64) mat[1,2] += 5+3j mat[2,1] += 7-8j #print num.hermite(mat)[1] #print num.hermite(mat)[1,:] vec = num.zeros((3,), num.Complex64) for i in vec.indices(): vec[i] = 17 mat[0] = vec h,w = mat.shape count = 0 for i in mat: count += 1 self.assert_(count == h) count = 0 for i in mat.indices(): count += 1 self.assert_(count == h*w) sum(vec) num.matrixmultiply(mat, mat) def doTestAddScattered(self,typecode): a = num.zeros((10,10), typecode) vec = num.array([3., 5.]) b = num.asarray(num.outerproduct(vec, num.array([2., 4.])), typecode) a.addScattered([5,7], [1,3], b) def testAddScattered(self): self.forAllTypecodes(self.doTestAddScattered) def doTestBroadcast(self, typecode): size = 10 a = makeFullRandomMatrix(size, typecode) def scalar_broadcast(a): a[3:7, 5:9] = 0 self.assertZero(a[3:7, 5:9]) def scalar_broadcast2(a): a[3:7] = 0 self.assertZero(a[3:7]) def vec_broadcast(a): v = num.zeros((size,), typecode) a[3:7] = v self.assertZero(a[3:7]) def vec_broadcast2(a): v = num.zeros((2,), typecode) a[:,2:4] = v self.assertZero(a[:, 2:4]) scalar_broadcast(a.copy()) scalar_broadcast2(a.copy()) vec_broadcast(a.copy()) vec_broadcast2(a.copy()) def testBroadcast(self): self.forAllTypecodes(self.doTestBroadcast) def testUfunc(self): vec = num.array([3., 5.]) a = num.outerproduct(vec, num.array([2., 4.])) vec2 = num.array([1., 17.]) b = num.outerproduct(vec2, num.array([5., 1.])) minab = num.minimum(a,b) maxab = num.maximum(a,b) self.assertSmall(num.multiply(a, 2) - 2 * a) num.multiply(a, a) self.assertSmall(num.multiply(a, 2) - num.multiply(2, a)) self.assertSmall(num.multiply(a, vec) - num.multiply(vec, a)) def doTestCG(self, typecode): size = 100 A = makeRandomSPDMatrix(size, typecode) Aop = algo.makeMatrixOperator(A) b = makeRandomVector(size, typecode) cg_op = algo.makeCGMatrixOperator(Aop, 4000, 1e-10) x = num.zeros((size,), typecode) initial_resid = norm2(b - num.matrixmultiply(A, x)) cg_op.apply(b, x) end_resid = norm2(b - num.matrixmultiply(A, x)) self.assert_(end_resid/initial_resid < 1e-10) def testCG(self): self.forAllTypecodes(self.doTestCG) def doTestUmfpack(self, typecode): size = 100 A = num.asarray(makeRandomMatrix(size, typecode), typecode, num.SparseExecuteMatrix) umf_op = algo.makeUMFPACKMatrixOperator(A) b = makeRandomVector(size, typecode) x = num.zeros((size,), typecode) umf_op.apply(b, x) self.assert_(norm2(b - num.matrixmultiply(A, x)) < 1e-10) def testUmfpack(self): self.forAllTypecodes(self.doTestUmfpack) def doTestArpackGeneralized(self, typecode): size = 100 A = makeRandomMatrix(size, typecode) Aop = algo.makeMatrixOperator(A) M = num.asarray(makeRandomSPDMatrix(size, typecode), typecode, num.SparseExecuteMatrix) Mop = algo.makeMatrixOperator(M) Minvop = algo.makeUMFPACKMatrixOperator(M) OP = algo.composeMatrixOperators(Minvop, Aop) results = algo.runArpack(OP, Mop, algo.REGULAR_GENERALIZED, 0, 5, 10, algo.LARGEST_MAGNITUDE, 1e-12, False, 0) Acomplex = num.asarray(A, num.Complex) Mcomplex = num.asarray(M, num.Complex) for value,vector in zip(results.RitzValues, results.RitzVectors): self.assert_(norm2(num.matrixmultiply(Acomplex,vector) - value * num.matrixmultiply(Mcomplex, vector)) < 1e-7) def testArpackGeneralized(self): self.forAllTypecodes(self.doTestArpackGeneralized) def doTestArpackShiftInvert(self, typecode): size = 100 sigma = 1 A = makeRandomMatrix(size, typecode) M = makeRandomSPDMatrix(size, typecode) Mop = algo.makeMatrixOperator(M) shifted_mat = num.asarray(A - sigma * M, typecode, num.SparseExecuteMatrix) shifted_mat_invop = algo.makeUMFPACKMatrixOperator(shifted_mat) OP = algo.composeMatrixOperators(shifted_mat_invop, Mop) results = algo.runArpack(OP, Mop, algo.SHIFT_AND_INVERT_GENERALIZED, sigma, 5, 10, algo.LARGEST_MAGNITUDE, 1e-12, False, 0) Acomplex = num.asarray(A, num.Complex) Mcomplex = num.asarray(M, num.Complex) for value,vector in zip(results.RitzValues, results.RitzVectors): self.assert_( norm2(num.matrixmultiply(Acomplex,vector) - value * num.matrixmultiply(Mcomplex, vector)) < 1e-10) def testArpackShiftInvert(self): self.forAllTypecodes(self.doTestArpackShiftInvert) def doTestCholesky(self, typecode): size = 100 A = makeRandomSPDMatrix(size, typecode) L = la.cholesky_decomposition(A) self.assertSmall(num.matrixmultiply(L,hermite(L))-A) def testCholesky(self): self.forAllTypecodes(self.doTestCholesky) def doTestSolve(self, typecode): size = 200 A = makeFullRandomMatrix(size, typecode) b = num.zeros((size,), typecode) writeRandomVector(b) x = la.solve_linear_equations(A,b) self.assert_(norm2(num.matrixmultiply(A,x)-b) < 1e-10) def testSolve(self): self.forAllTypecodes(self.doTestSolve) def doTestLU(self, typecode): size = 100 A = makeFullRandomMatrix(size, typecode) L,U,permut,sign = algo.lu(A) permut_mat = makePermutationMatrix(permut, typecode) permut_a = num.matrixmultiply(permut_mat, A) self.assertSmall(num.matrixmultiply(L, U)-permut_a) def testLU(self): self.forAllTypecodes(self.doTestLU) def doTestSparse(self, typecode): def countElements(mat): count = 0 for i in mat.indices(): count += 1 return count size = 100 A1 = makeRandomMatrix(size, typecode, num.SparseBuildMatrix) A2 = num.asarray(A1, typecode, num.SparseExecuteMatrix) self.assert_(countElements(A1) == countElements(A2)) def testSparse(self): self.forAllTypecodes(self.doTestSparse) def doTestInverse(self,typecode): size = 100 A = makeFullRandomMatrix(size, typecode) Ainv = la.inverse(A) Id = num.identity(size, typecode) self.assertSmall(num.matrixmultiply(Ainv,A)-Id) self.assertSmall(num.matrixmultiply(A,Ainv)-Id) def testInverse(self): self.forAllTypecodes(self.doTestInverse) def doTestDeterminant(self, typecode): size = 10 A = makeFullRandomMatrix(size, typecode) detA = la.determinant(A) A2 = num.matrixmultiply(A, A) detA2 = la.determinant(A2) self.assert_(abs((detA**2-detA2) / detA2) < 1e-10) def testDeterminant(self): self.forAllTypecodes(self.doTestDeterminant) def doTestSVD(self, typecode): size = 100 mat = mtools.makeFullRandomMatrix(size, num.Complex) u, s_vec, vt = la.singular_value_decomposition(mat) s = num.zeros(mat.shape, s_vec.typecode()) for i, v in enumerate(s_vec): s[i,i] = v mm = num.matrixmultiply mat_prime = mm(u, mm(s, vt)) self.assertSmall(mat_prime - mat) def testSVD(self): self.forAllTypecodes(self.doTestSVD) def doTestJacobi(self, typecode): size = 10 def off_diag_norm_squared(a): result = 0 for i,j in a.indices(): if i != j: result += abs(a[i,j])**2 return result a = mtools.makeRandomSPDMatrix(size, typecode) before = math.sqrt(off_diag_norm_squared(a)) q, aprime = mtools.diagonalize(a, iteration.makeObserver(rel_goal = 1e-10)) after = math.sqrt(off_diag_norm_squared(aprime)) mm = num.matrixmultiply herm = num.hermite for i in range(size): evec = q[:,i] evalue = aprime[i,i] self.assert_(mtools.norm2(mm(a, evec) - evalue * evec) / mtools.norm2(evec) < 1e-8) self.assertSmall(mm(q, mm(aprime, herm(q))) - a) self.assert_(after / before <= 1e-10) def testJacobi(self): self.forAllTypecodes(self.doTestJacobi) def doTestCodiagonalization(self, typecode): size = 10 def off_diag_norm_squared(a): result = 0 for i,j in a.indices(): if i != j: result += abs(a[i,j])**2 return result a = mtools.makeRandomSPDMatrix(size, typecode) before = math.sqrt(off_diag_norm_squared(a)) q, mats_post, achieved = mtools.codiagonalize( [a], iteration.makeObserver(stall_thresh = 1e-5, rel_goal = 1e-10)) aprime = mats_post[0] after = math.sqrt(off_diag_norm_squared(aprime)) mm = num.matrixmultiply herm = num.hermite for i in range(size): evec = q[:,i] evalue = aprime[i,i] self.assert_(mtools.norm2(mm(a, evec) - evalue * evec) / mtools.norm2(evec) < 1e-8) self.assertSmall(mm(q, mm(aprime, herm(q))) - a) self.assert_(after / before <= 1e-10) def testCodiagonalization(self): self.forAllTypecodes(self.doTestCodiagonalization) def doTestMatrixExp(self, typecode): a = mtools.makeRandomSPDMatrix(20, num.Complex) e_a1 = mtools.matrixExp(a) e_a2 = mtools.matrixExpByDiagonalization(a) e_a3 = mtools.matrixExpBySymmetricDiagonalization(a) self.assert_(mtools.frobeniusNorm(e_a1-e_a2) / mtools.frobeniusNorm(e_a1) / mtools.frobeniusNorm(e_a2) <= 1e-15) self.assert_(mtools.frobeniusNorm(e_a1-e_a3) / mtools.frobeniusNorm(e_a1) / mtools.frobeniusNorm(e_a3) <= 1e-15) def testMatrixExp(self): self.forAllTypecodes(self.doTestMatrixExp) def doTestHeigenvectors(self, typecode): size = 100 a = mtools.makeRandomSPDMatrix(size, typecode) q, w = la.Heigenvectors(a) w2 = la.Heigenvalues(a) self.assert_(abs(sum(w) - sum(w2)) < 1e-12) d = num.zeros(a.shape, a.typecode()) for i in range(size): d[i,i] = w[i] mm = num.matrixmultiply self.assertSmall(a - mm(q, mm(d, num.hermite(q)))) def testHeigenvectors(self): self.forAllTypecodes(self.doTestHeigenvectors) def doTestEigenvectors(self, typecode): size = 100 a = mtools.makeFullRandomMatrix(size, typecode) evecs, evals = la.eigenvectors(a) evals2 = la.eigenvalues(a) self.assert_(abs(sum(evals) - sum(evals2)) < 1e-12) d = num.zeros(a.shape, num.Complex) for i in range(size): d[i,i] = evals[i] mm = num.matrixmultiply self.assertSmall(mm(a, evecs) - mm(evecs, d)) def testEigenvectors(self): self.forAllTypecodes(self.doTestEigenvectors) def doTestBiCGSTAB(self, typecode): # real case fails sometimes size = 30 A = makeFullRandomMatrix(size, typecode) b = makeRandomVector(size, typecode) A_op = algo.makeMatrixOperator(A) bicgstab_op = algo.makeBiCGSTABMatrixOperator(A_op, 40000, 1e-10) #bicgstab_op.debug_level = 1 x = num.zeros((size,), typecode) initial_resid = norm2(b - num.matrixmultiply(A, x)) bicgstab_op.apply(b, x) end_resid = norm2(b - num.matrixmultiply(A, x)) #print typecode, end_resid/initial_resid self.assert_(end_resid/initial_resid < 1e-10) def testBiCGSTAB(self): self.forAllTypecodes(self.doTestBiCGSTAB) def testComplexAdaptor(self): size = 40 a = makeFullRandomMatrix(size, num.Complex) a_op = algo.makeMatrixOperator(a) a2_op = algo.adaptRealToComplexOperator( algo.makeMatrixOperator(a.real), algo.makeMatrixOperator(a.imaginary)) for i in range(20): b = makeRandomVector(size, num.Complex) result1 = num.zeros((size,), num.Complex) result2 = num.zeros((size,), num.Complex) a_op.apply(b, result1) a2_op.apply(b, result2) self.assert_(mtools.norm2(result1 - result2) < 1e-11) def doTestInterpolation(self, typecode): size = 4 def eval_at(x): # Horner evaluation result = 0. for i in coefficients[::-1]: result = i + x*result return result abscissae = makeRandomVector(size, typecode) coefficients = makeRandomVector(size, typecode) values = num.array([eval_at(abscissa) for abscissa in abscissae]) for i in range(10): to_x = random.normalvariate(0,100) i_coeff = mtools.findInterpolationCoefficients(abscissae, to_x) f_x1 = eval_at(to_x) self.assert_(abs(num.innerproduct(i_coeff, values)-f_x1) < 1e-7) def testInterpolation(self): self.forAllTypecodes(self.doTestInterpolation) if __name__ == '__main__': unittest.main() PyLinear-0.91/test/test_pickler.py0000644000175000001440000000044510135202257016761 0ustar akusers00000000000000import pylinear.matrices as num import pickle a = num.zeros((4,4,), num.Complex, num.SparseExecuteMatrix) #a = num.zeros((4,4,), num.Complex) a[0,0] = 4 a[1,0] = 7 a[3,2] = 9 print a.__getstate__() a_pickled = pickle.dumps(a) other_a = pickle.loads(a_pickled) print other_a, a, type(other_a) PyLinear-0.91/test/test_polyfit.py0000644000175000001440000000100310135202257017005 0ustar akusers00000000000000import pylinear.matrices as num import pylinear.linear_algebra as la import pylinear.matrix_tools as mtools import math def f(x): return math.sqrt(math.fabs(math.sin(5*x)+2*math.cos(x)-1)) x = num.array(mtools.linspace(0, 1)) approximant = mtools.get_approximant(x, f, 10) x2 = mtools.linspace(0., 1.) gnuplot_file = file(",,approx.data", "w") for i in x2: gnuplot_file.write("%f %f\n" % (i, approximant(i))) gnuplot_file = file(",,f.data", "w") for i in x2: gnuplot_file.write("%f %f\n" % (i, f(i))) PyLinear-0.91/test/test_tools.py0000644000175000001440000000112610135202257016465 0ustar akusers00000000000000import math import cmath import pylinear.matrices as num #import Numeric as num #import numarray as num import stopwatch import random from pylinear.matrix_tools import * def makePermutationMatrix(permutation, typecode): size = len(permutation) result = num.zeros((size,size), typecode) for index, value in zip(range(size), permutation): result[index,value] = 1 return result def _test(): size = 10 job = stopwatch.tJob( "make spd" ) for i in range(100): A = makeRandomSPDMatrix(size, num.Complex64) job.done() #print A if __name__ == "__main__": _test() PyLinear-0.91/README0000644000175000001440000000230210135202257013612 0ustar akusers00000000000000TODO: -------------------------------------------------------------------------- product (?) put concatenate? more ufuncs - with their different methods? - comparison ufuncs (convert to what if not bool?) from/to numeric conversion UMFPACK crash with *really* singular matrix save time in arpack: avoid copies for multiplication make it possible to take advantage of difference IDO=+/- 1 QUESTIONS: BPL: non-compiling derivation example -> impact on matrix operators BPL: PyNumberMethods? BPL: why can't you specify call policies for attributes in Boost.Python? UBLAS: unify indexing, provide multidimensional arrays UBLAS: managed_XXX_adaptor UBLAS: doc bug: h/s_adaptors don't have expression constructors UBLAS: traits cannot be included by itself (?) UBLAS: matrix_proxy cannot be included by itself UBLAS: casts needed in cholesky UBLAS: Permutation matrices UBLAS: Toeplitz matrices UBLAS: Vandermonde matrices UBLAS: lu doesn't have any headers included UBLAS: insert discrepance: coordinate_matrix vs. everybody else. UBLAS: Warum ist end2 nicht das Ende der Matrix? UBLAS: Was ist rank bei find1/2? out-of-bounds index [0:8, 0:8] on 6x6 matrix causes no error utilize __coerce__, PyNumberMethods PyLinear-0.91/setup.py0000644000175000001440000000362310135202257014453 0ustar akusers00000000000000#!/usr/bin/env python from distutils.core import setup,Extension import glob import os import os.path home = os.getenv("HOME") boost_path = "%s/work/boost" % home boost_ublas_bindings_path = "%s/work/boost-sandbox" % home library_dirs = ["%s/pool/lib" % home] include_dirs = [boost_path, "algorithms"] libraries = ["boost_python"] extra_compile_args = ["-fmessage-length=0"] #blas_libraries = ["f77blas", "atlas", "g2c"] blas_libraries = ["blas2"] setup(name="PyLinear", version="0.91", description="Matrix handling in Python", author="Andreas Kloeckner", author_email="ak@ixion.net", license = "BSD-Style", url="http://pylinear.sf.net", packages=["pylinear"], ext_package="pylinear", ext_modules=[ Extension("_matrices", ["extensions/matrices.cpp", "extensions/vectors.cpp", "extensions/matrices_sparse_build.cpp", "extensions/matrices_sparse_ex.cpp", #"extensions/matrices_sym_ex.cpp", #"extensions/matrices_sym_build.cpp", ], include_dirs = include_dirs, library_dirs = library_dirs, libraries = libraries, extra_compile_args = extra_compile_args, ), Extension( "_algorithms", ["extensions/algorithms.cpp", ], include_dirs = include_dirs + [boost_ublas_bindings_path, "3rdparty/arpack"], library_dirs = library_dirs, libraries = libraries + ["umfpack", "amd", "arpack", "lapack"] + blas_libraries, extra_compile_args = extra_compile_args, ), ] ) PyLinear-0.91/PKG-INFO0000644000175000001440000000034710135231541014034 0ustar akusers00000000000000Metadata-Version: 1.0 Name: PyLinear Version: 0.91 Summary: Matrix handling in Python Home-page: http://pylinear.sf.net Author: Andreas Kloeckner Author-email: ak@ixion.net License: BSD-Style Description: UNKNOWN Platform: UNKNOWN