boost-bindings/0000755000175000017500000000000010776013426013621 5ustar andreasandreasboost-bindings/libs/0000755000175000017500000000000010776014523014551 5ustar andreasandreasboost-bindings/libs/Jamfile0000644000175000017500000000023510776013426016044 0ustar andreasandreassubproject libs/numeric/bindings ; subinclude libs/numeric/bindings/amos ; subinclude libs/numeric/bindings/blas ; subinclude libs/numeric/bindings/lapack ; boost-bindings/libs/numeric/0000755000175000017500000000000010776014503016211 5ustar andreasandreasboost-bindings/libs/numeric/bindings/0000755000175000017500000000000010776014523020010 5ustar andreasandreasboost-bindings/libs/numeric/bindings/amos/0000755000175000017500000000000010776160766020762 5ustar andreasandreasboost-bindings/libs/numeric/bindings/amos/test/0000755000175000017500000000000010776160766021741 5ustar andreasandreasboost-bindings/libs/numeric/bindings/amos/test/amos.cpp0000644000175000017500000000060110776160766023401 0ustar andreasandreas#include #include #include int main() { boost::numeric::ublas::vector< std::complex< double > > z(10) ; boost::numeric::ublas::vector< std::complex< double > > cy(10) ; int nz; boost::numeric::bindings::amos::besi( z, 1.0, 1, cy, nz ) ; return 0 ; } boost-bindings/libs/numeric/bindings/amos/test/Jamfile0000644000175000017500000000042010776160766023227 0ustar andreasandreassubproject libs/numeric/bindings/amos/test ; AMOS_PATH = /usr/lib ; AMOS_LIB = amos ; exe amos : amos.cpp ../bindings_amos : $(BOOST_ROOT) $(B_ROOT) $(AMOS_PATH) $(AMOS_LIB) ; boost-bindings/libs/numeric/bindings/amos/Jamfile0000644000175000017500000000030010776160766022245 0ustar andreasandreassubproject libs/numeric/bindings/amos ; subinclude libs/numeric/bindings/amos/test ; lib bindings_amos : amos.cpp : $(BOOST_ROOT) $(B_ROOT) ; boost-bindings/libs/numeric/bindings/atlas/0000755000175000017500000000000010776160766021127 5ustar andreasandreasboost-bindings/libs/numeric/bindings/atlas/doc/0000755000175000017500000000000010776013426021662 5ustar andreasandreasboost-bindings/libs/numeric/bindings/atlas/doc/index.html0000644000175000017500000012110110776013426023653 0ustar andreasandreas Boost.Numeric.Bindings.ATLAS

C++ Boost

Boost.Numeric.Bindings.ATLAS

Back to Bindings Library Synopsis

Contents

  1. Introduction
  2. Using ATLAS bindings
    1. ATLAS path
    2. Level 1 BLAS
    3. Level 2 BLAS
    4. Level 3 BLAS
    5. LAPACK routines
      1. General system of linear equations
      2. Positive definite system of linear equations

1. Introduction

``The ATLAS (Automatically Tuned Linear Algebra Software) project is an ongoing research effort focusing on applying empirical techniques in order to provide portable performance. At present, it provides C and Fortran77 interfaces to a portably efficient BLAS implementation, as well as a few routines from LAPACK.'' [quote from the ATLAS web page]

``ATLAS is an approach for the automatic generation and optimization of numerical software for processors with deep memory hierarchies and pipelined functional units. The production of such software for machines ranging from desktop workstations to embedded processors can be a tedious and time consuming task. ATLAS has been designed to automate much of this process. We concentrate our efforts on the widely used linear algebra kernels called the Basic Linear Algebra Subroutines (BLAS).'' [BLAS FAQ: What is ATLAS?]

ATLAS Bindings Library provides generic, higher level interface to ATLAS C interface. By `generic' we mean that bindings can be used with various vector and matrix classes, and by `higher level' that some complexities of the C interface are hidden. For example, to compute the Euclidean norm of a vector, ATLAS provides four functions: 

  float cblas_snrm2 (const int N, const float *X, const int incX);
  double cblas_dnrm2 (const int N, const double *X, const int incX);
  float cblas_scnrm2 (const int N, const void *X, const int incX);
  double cblas_dznrm2 (const int N, const void *X, const int incX);
for float, double, float complex and double complex vectors. Parameters of these functions are the length of the vector X, pointer[1] to the first element of X and the so-called stride of X. This interface is rather flexible: functions can be used not only for `complete' vectors, but also for vector ranges (if pointer points to the first element of a range) and vector slices (if pointer points to the first element of a slice and stride is not one); but it also leads to long parameter/argument lists. Vectors, vector ranges and vector slices in C++, being object of classes, usually `carry' all required information and there is no need to supply them explicitly. Furthermore, overloading makes the encoding of vector component types in function names unnecessary. Using templates and traits classes, function can be written to manipulate various vector types: 
  #include <iostream>
  #include <complex>
  #include <boost/numeric/bindings/traits/std_vector.hpp>
  #include <boost/numeric/bindings/traits/std_valarray.hpp>
  #include <boost/numeric/bindings/traits/ublas_vector.hpp>
  #include <boost/numeric/bindings/traits/ublas_matrix.hpp>
  #include <boost/numeric/bindings/atlas/cblas1.hpp> 

  namespace ublas = boost::numeric::ublas; 
  namespace atlas = boost::numeric::bindings::atlas;

  int main() {
    std::vector<float> sv (8);
    // initialisation...
    std::cout << atlas::nrm2 (sv) << std::endl; 

    std::valarray<std::complex<double> > va (10); 
    // ...
    std::cout << atlas::nrm2 (va) << std::endl; 

    ublas::vector<double> uv (18);
    // ...
    std::cout << atlas::nrm2 (uv) << std::endl; 
    ublas::vector_range<ublas::vector<double> > ur (uv, ublas::range (3, 15));
    std::cout << atlas::nrm2 (ur) << std::endl; 
    ublas::vector_slice<ublas::vector<double> > us (uv, ublas::slice (1, 3, 5));
    std::cout << atlas::nrm2 (us) << std::endl; 
    ublas::vector_slice<ublas::vector_range<ublas::vector<double> > > 
      usr (ur, ublas::slice (2, 2, 4));
    std::cout << atlas::nrm2 (usr) << std::endl; 

    ublas::matrix<double> um (5, 5); 
    // ...
    ublas::matrix_row<ublas::matrix<double> > umr (um, 1);
    std::cout << atlas::nrm2 (umr) << std::endl; 
    ublas::matrix_column<ublas::matrix<double> > umc (um, 2);
    std::cout << atlas::nrm2 (umc) << std::endl; 
  }

2. Using ATLAS bindings

ATLAS is an implementation of the BLAS (with C and Fortran 77 interfaces). ``The BLAS (Basic Linear Algebra Subroutines) are high quality `building block' routines for performing basic vector and matrix operations. Level 1 BLAS do vector-vector operations, Level 2 BLAS do matrix-vector operations, and Level 3 BLAS do matrix-matrix operations.'' [quote from BLAS FAQ: What are BLAS?]

ATLAS also contains some LAPACK routines for solving systems of simultaneous linear equations.

All ATLAS bindings header files are in the directory boost/numeric/bindings/atlas.

All `public' ATLAS bindings functions are in the namespace boost::numeric::bindings::atlas.

2.1 ATLAS path

The location of ATLAS header files may depend on your installation. Files cblas_inc.hpp and clapack_inc.hpp, which only include ATLAS headers cblas.h and clapack.h[2] respectively, are therefore introduced. You should edit these two files providing your paths. All other files then include these two files, so there is no need to edit other files.

2.2 Level 1 BLAS

Defined in boost/numeric/bindings/atlas/cblas1.hpp.

Namespace is boost::numeric::bindings::atlas.

Level 1 BLAS do vector-vector operations.

In the following table x, y are vectors, a, b, c are scalars and i, k integer indices.

ExpressionSemantics
set(a,x)xi <- a   for all i    [1]
copy(x,y)y <- x
swap(x,y)x <-> y
scal(a,x)x <- a x
axpy(a,x,y)y <- a x + y
xpy(x,y)y <- x + y    [2]
axpby(a,x,b,y)y <- a x + b y    [1]
dot(x,y)returns xT y    [3]
dsdot(x,y)returns xT y    [4]
sdsdot(x,y)returns a + xT y    [4]
dotu(x,y)returns xT y    [5]
dotu(x,y,c)c <- xT y    [5]
dotc(x,y)returns xH y    [5]
dotc(x,y,c)c <- xH y    [5]
nrm2(x)returns ||x||2
asum(x)returns ||re(x)||1 + ||im(x)||1
iamax(x)returns 1st k such that |re(xk)| + |im(xk)| = max (|re(xi)| + |im(xi)|)

[1] ATLAS extension (i.e. not mandated by the BLAS standard)

[2] ATLAS bindings extension

[3] in BLAS/ATLAS float and double vectors only, complex vectors ATLAS bindings extension (same as dotu())

[4] float vectors only, with double accumulation

[5] complex types only

2.3 Level 2 BLAS

Defined in boost/numeric/bindings/atlas/cblas2.hpp.

Namespace is boost::numeric::bindings::atlas.

Level 2 BLAS do matrix-vector operations.

In the following table a, b are scalars, x, y are vectors and A is a matrix. Trans can be CblasNoTrans, CblasTrans or CblasConjTrans, denoting A, AT or AH, respectively. Uplo can be CblasUpper or CblasLower, denoting that leading upper or lower, respectively, triangular part of A contains the upper or lower triangular part of the symmetric/Hermitian matrix (and that the lower or upper triangular part, respectively, is not referenced).

ExpressionSemantics
gemv(Trans,a,A,x,b,y) y <- a op(A) x + b y   where   op (A) == A || AT || AH
gemv(a,A,x,b,y)y <- a A x + b y
gemv(A,x,y)y <- A x
symv(Uplo,a,A,x,b,y)y <- a A x + b y,  A symmetric real matrix
symv(a,A,x,b,y)y <- a A x + b y,  A symmetric real matrix    [1]
symv(A,x,y)y <- A x ,  A symmetric real matrix    [1]
spmv(a,A,x,b,y)y <- a A x + b y,  A symmetric real matrix in packed format
spmv(A,x,y)y <- A x ,  A symmetric real matrix in packed format
hemv(Uplo,a,A,x,b,y)y <- a A x + b y,  A Hermitian matrix
hemv(a,A,x,b,y)y <- a A x + b y,  A Hermitian matrix    [1]
hemv(A,x,y)y <- A x ,  A Hermitian matrix    [1]
hpmv(a,A,x,b,y)y <- a A x + b y,  A Hermitian matrix in packed format
hpmv(A,x,y)y <- A x ,  A Hermitian matrix in packed format
ger(a,x,y,A)A <- a x yT + A    [2]
ger(x,y,A)A <- x yT + A    [2]
geru(a,x,y,A)A <- a x yT + A    [3]
geru(x,y,A)A <- x yT + A    [3]
gerc(a,x,y,A)A <- a x yH + A    [3]
gerc(x,y,A)A <- x yH + A    [3]
syr(Uplo,a,x,A)A <- a x xT + A,  A symmetric real matrix
syr(a,x,A)A <- a x xT + A,  A symmetric real matrix    [1]
syr(x,A)A <- x xT + A,  A symmetric real matrix    [1]
spr(a,x,A)A <- a x xT + A,  A symmetric real matrix in packed format
spr(x,A)A <- x xT + A,  A symmetric real matrix in packed format
syr2(Uplo,a,x,y,A) A <- a x yT + a y xT + A,  A symmetric real matrix
syr2(a,x,y,A) A <- a x yT + a y xT + A,  A symmetric real matrix    [1]
syr2(x,y,A) A <- x yT + y xT + A,  A symmetric real matrix    [1]
spr2(a,x,y,A) A <- a x yT + a y xT + A,  A symmetric real matrix in packed format
spr2(x,y,A) A <- x yT + y xT + A,  A symmetric real matrix in packed format
her(Uplo,a,x,A)A <- a x xH + A,  A Hermitian matrix
her(a,x,A)A <- a x xH + A,  A Hermitian matrix    [1]
her(x,A)A <- x xH + A,  A Hermitian matrix    [1]
hpr(a,x,A)A <- a x xH + A,  A Hermitian matrix in packed format
hpr(x,A)A <- x xH + A,  A Hermitian matrix in packed format
her2(Uplo,a,x,y,A) A <- a x yH + y (a x)H + A,  A Hermitian matrix
her2(a,x,y,A) A <- a x yH + y (a x)H + A,  A Hermitian matrix    [1]
her2(x,y,A) A <- x yH + y xH + A,  A Hermitian matrix    [1]
hpr2(a,x,y,A) A <- a x yH + y (a x)H + A,  A Hermitian matrix in packed format
hpr2(x,y,A) A <- x yH + y xH + A,  A Hermitian matrix in packed format

[1] It is assumed that matrix traits class can determine whether upper or lower triangular part of A contains the corresponding part of the symmetric/Hermitian matrix (e.g. traits for ublas::symmetric_adaptor<> and ublas::hermitian_adaptor<>).

[2] in BLAS/ATLAS float and double vectors only, complex vectors ATLAS bindings extension (same as geru())

[3] complex types only

2.4 Level 3 BLAS

Defined in boost/numeric/bindings/atlas/cblas3.hpp.

Namespace is boost::numeric::bindings::atlas.

Level 3 BLAS do matrix-matrix operations.

In the following table a, b are scalars (with a' denoting conj(a)) and A, B, C are matrices. For Trans, TransA, TransB see Trans in 2.3; also, for Uplo see 2.3. Side can be CblasLeft or CblasRight, specifying whether the symmetric/Hermitian matrix A appears on the left or right in the multiplication, i.e. AB or BA.

ExpressionSemantics
gemm(TransA,TransB,a,A,B,b,C) C <- a op(A) op(B) + b C   where   op (A) == A || AT || AH
gemm(a,A,B,b,C)C <- a A B + b C  
gemm(A,B,C)C <- A B  
symm(Side,Uplo,a,A,B,b,C)C <- a A B + b C   or   C <- a B A + b C,   A symmetric matrix
symm(Side,a,A,B,b,C)C <- a A B + b C   or   C <- a B A + b C,   A symmetric matrix    [1]
symm(a,A,B,b,C)C <- a A B + b C,   A symmetric matrix    [1][2]
symm(a,B,A,b,C)C <- a B A + b C,   A symmetric matrix    [1][2]
symm(A,B,C)C <- A B,   A symmetric matrix    [1][2]
symm(B,A,C)C <- B A,   A symmetric matrix    [1][2]
hemm(Side,Uplo,a,A,B,b,C)C <- a A B + b C   or   C <- a B A + b C,   A Hermitian matrix
hemm(Side,a,A,B,b,C)C <- a A B + b C   or   C <- a B A + b C,   A Hermitian matrix    [1]
hemm(a,A,B,b,C)C <- a A B + b C,   A Hermitian matrix    [1][2]
hemm(a,B,A,b,C)C <- a B A + b C,   A Hermitian matrix    [1][2]
hemm(A,B,C)C <- A B,   A Hermitian matrix    [1][2]
hemm(B,A,C)C <- B A,   A Hermitian matrix    [1][2]
syrk(Uplo,Trans,a,A,b,C) C <- a A AT + b C   or   C <- a AT A + b C,   A symmetric matrix
syrk(Trans,a,A,b,C) C <- a A AT + b C   or   C <- a AT A + b C,   A symmetric matrix    [1]
syrk(Trans,A,C) C <- A AT + C   or   C <- AT A + C,   A symmetric matrix    [1]
syr2k(Uplo,Trans,a,A,B,b,C) C <- a A BT + a' B AT + b C   or   C <- a AT B + a' BT A + b C,   A symmetric matrix
syr2k(Trans,a,A,B,b,C) C <- a A BT + a' B AT + b C   or   C <- a AT B + a' BT A + b C,   A symmetric matrix    [1]
syr2k(Trans,A,B,C) C <- A BT + B AT + C   or   C <- AT B + BT A + C,   A symmetric matrix    [1]
herk(Uplo,Trans,a,A,b,C) C <- a A AH + b C   or   C <- a AH A + b C,   A Hermitian matrix
herk(Trans,a,A,b,C) C <- a A AH + b C   or   C <- a AH A + b C,   A Hermitian matrix    [1]
herk(Trans,A,C) C <- A AH + C   or   C <- AH A + C,   A Hermitian matrix    [1]
her2k(Uplo,Trans,a,A,B,b,C) C <- a A BH + a' B AH + b C   or   C <- a AH B + a' BH A + b C,   A Hermitian matrix
her2k(Trans,a,A,B,b,C) C <- a A BH + a' B AH + b C   or   C <- a AH B + a' BH A + b C,   A Hermitian matrix    [1]
her2k(Trans,A,B,C) C <- A BH + B AH + C   or   C <- AH B + BH A + C,   A Hermitian matrix    [1]

[1] It is assumed that matrix traits class can determine whether upper or lower triangular part of A contains the corresponding part of the symmetric/Hermitian matrix (e.g. traits for ublas::symmetric_adaptor<>) and ublas::hermitian_adaptor<>).

[2] Requires proper traits classes and therefore does not work with all compilers.

2.5 LAPACK routines

Defined in boost/numeric/bindings/atlas/clapack.hpp.

Namespace is boost::numeric::bindings::atlas.

ATLAS contains only few LAPACK routines: for the solutions of systems of simultaneous linear equations with general and with symmetric or Hermitian positive definite coefficient matrices[3].

ATLAS functions can be applied to matrices with both column major and row major storage orders. But there is a `catch' with row major solves and factorisations. To quote from ATLAS FAQ: ``Most users are confused by the row major factorization and related solves. The right-hand side vectors are probably the biggest source of confusion. The RHS array does not represent a matrix in the mathematical sense, it is instead a pasting together of the various RHS into one array for calling convenience. As such, RHS vectors are always stored contiguously, regardless of the row/col major that is chosen.'' That is, if B is row-major, it should be nrhs-by-n, and RHS vectors should be its rows, not columns; also, solution vectors will be its rows.

For more informations about LAPACK routines see LAPACK Users' Guide. Also, see LAPACK bindings.

2.5.1 General system of linear equations

gesv
computes the solution to a system of linear equations A X = B, where A is general n-by-n matrix and X and B are n-by-nrhs matrices (nrhs denotes the number of right-hand side vectors). A is overwritten with the appropriate LU factorization and B is overwritten with the solution X.
getrf
computes an LU factorisation of a general m-by-n matrix A using partial pivoting. Factorisation is A = PLU, where:
  • if A is column major, P is a row-permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m>n), and U is upper triangular (upper trapezoidal if m<n);
  • if A is row major, P is a column-permutation matrix, L is lower triangular (lower trapezoidal if m>n), and U is upper triangular with unit diagonals (upper trapezoidal if m<n).
A is overwritten with the LU factorization.
getrs
solves a system of linear equations AX = B (or ATX = B or AHX = B) with a general n-by-n matrix A using the LU factorization previously computed by getrf(). B is overwritten with the solution X.
getri
computes the inverse of a general matrix A using the LU factorization previously computed by getrf(). Factors LU are overwritten with A-1.

In the following table A, B, L, U are matrices, ipiv is a vector of pivot indices (representing premutation matrix P), Trans can be CblasNoTrans, CblasTrans or CblasConjTrans, denoting A, AT or AH, respectively, and ierr is `diagnostic argument' INFO (as described in LAPACK Users' Guide).

ExpressionSemantics
gesv(A,ipiv,B)using AP=LU, B <- A-1B, A <- LU, ipiv <- P;   returns ierr
gesv(A,B)as above, with ipiv allocated and deallocated internally
lu_solve(A,B)same as gesv(A,B)
getrf(A,ipiv)using AP=LU, A <- LU, ipiv <- P;   returns ierr
lu_factor(A,ipiv)same as getrf(A,ipiv)
getrs(Trans,A,ipiv,B) B <- op(A)-1B assuming A <- LU and ipiv <- P,   op (A) == A || AT || AH;   returns ierr
getrs(A,ipiv,B)B <- A-1B assuming A <- LU and ipiv <- P;   returns ierr
lu_substitute(A,ipiv,B)same as getrs(A,ipiv,B)
getri(A,ipiv)A <- A-1 assuming A <- LU and ipiv <- P;   returns ierr
lu_invert(A,ipiv)same as getri(A,ipiv)

Example. Solution to A X = B using gesv(); A and B are column major: 

  #include <iostream>
  #include <boost/numeric/bindings/atlas/clapack.hpp>
  #include <boost/numeric/bindings/traits/ublas_matrix.hpp>
  #include <boost/numeric/ublas/io.hpp>

  namespace ublas = boost::numeric::ublas;
  namespace atlas = boost::numeric::bindings::atlas;

  int main() {
    // system matrix A: 
    ublas::matrix<double, ublas::column_major> A(3,3);  
    A(0,0) = 1.; A(0,1) = 1.; A(0,2) = 1.;
    A(1,0) = 2.; A(1,1) = 3.; A(1,2) = 1.;
    A(2,0) = 1.; A(2,1) = -1.; A(2,2) = -1.;
    std::cout << "A: " << A << std::endl;

    // right-hand side matrix B:
    ublas::matrix<double, ublas::column_major> B(3,1);  
    B(0,0) = 4.; B(1,0) = 9.; B(2,0) = -2.;
    std::cout << "B: " << B << std::endl;

    // solve system: 
    atlas::gesv (A, B);
    // B now contains solution: 
    std::cout << "X: " << B << std::endl;
  }
Output is: 
  A: [3,3]((1,1,1),(2,3,1),(1,-1,-1))
  B: [3,1]((4),(9),(-2))
  X: [3,1]((1),(2),(1))
Same system, but with A and B row major: 
  #include <iostream>
  #include <boost/numeric/bindings/atlas/clapack.hpp>
  #include <boost/numeric/bindings/traits/ublas_matrix.hpp>
  #include <boost/numeric/ublas/io.hpp>

  namespace ublas = boost::numeric::ublas;
  namespace atlas = boost::numeric::bindings::atlas;

  int main() {
    // system matrix A: 
    ublas::matrix<double, ublas::row_major> A(3,3);  
    A(0,0) = 1.; A(0,1) = 1.; A(0,2) = 1.;
    A(1,0) = 2.; A(1,1) = 3.; A(1,2) = 1.;
    A(2,0) = 1.; A(2,1) = -1.; A(2,2) = -1.;
    std::cout << "A: " << A << std::endl;

    // right-hand side matrix B:
    ublas::matrix<double, ublas::row_major> B(1,3);  
    B(0,0) = 4.; B(0,1) = 9.; B(0,2) = -2.;
    std::cout << "B: " << B << std::endl;

    // solve system: 
    atlas::gesv (A, B);
    std::cout << "X: " << B << std::endl;
  }
Output is: 
  A: [3,3]((1,1,1),(2,3,1),(1,-1,-1))
  B: [1,3]((4,9,-2))
  X: [1,3]((1,2,1))

Example. Solution to A X = B using functions getrf() and getrs(): 

  #include <iostream>
  #include <boost/numeric/bindings/atlas/clapack.hpp>
  #include <boost/numeric/bindings/traits/std_vector.hpp>
  #include <boost/numeric/bindings/traits/ublas_matrix.hpp>
  #include <boost/numeric/ublas/io.hpp>

  namespace ublas = boost::numeric::ublas;
  namespace atlas = boost::numeric::bindings::atlas;

  int main() {
    // n -- no. of equations; nrhs -- no. of right-hand side vectors
    ublas::matrix<double, ublas::column_major> A(n,n);  // system matrix
    ublas::matrix<double, ublas::column_major> B(n,nrhs);  // right-hand side matrix
    // fill A & B
    std::vector<int> ipiv(n);  // pivot vector

    int ierr = atlas::getrf (A, ipiv);  // factorise A
    if (ierr == 0) {
      atlas::getrs (A, ipiv, B);  // solve from factorization 
      std::cout << "X: " << B << std::endl;
    }
    else 
      std::cout << "matrix is singular: ierr = " << ierr << std::endl;
  }

2.5.2 Positive definite system of linear equations

IMPORTANT: If you are using stable version of ATLAS prior to 3.4.2 or developer version prior to 3.5.8 and if you didn't apply fix described in ATLAS errata, you must define BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG in clapack.hpp, line 30 (before the inclusion of clapack_overloads.hpp).

Symmetric/Hermitian matrix A should be represented by n-by-n array; there are two possibilities:

  • the leading n-by-n upper triangular part of the array contains the upper triangular part of A, and the strictly lower triangular part is not referenced;
  • the leading n-by-n lower triangular part of the array contains the lower triangular part of A, and the strictly upper triangular part is not referenced.
In the case of ublas::symmetric_adaptor<> and ublas::hermitian_adaptor<>, traits mechanism can automagickly determine which part of the matrix A is stored.
posv
computes the solution to a system of linear equations A X = B, where A is n-by-n symmetric/Hermitian positive definite matrix and X and B are n-by-nrhs matrices (nrhs denotes the number of right-hand side vectors). Stored part of A is overwritten with the factor U or L from the Cholesky factorization A = UTU or A = LLT (or A = UHU or A = LLH) and B is overwritten with the solution X.
potrf
computes the Cholesky factorisation of a symmetric or Hermitian positive definite n-by-n matrix A: A = UTU or A = LLT (or A = UHU or A = LLH). Factors U or L overwrite stored part of A.
potrs
solves a system of linear equations AX = B with a symmetric or Hermitian positive definite n-by-n matrix A using the Cholesky factorization previously computed by potrf(). B is overwritten with the solution X.
potri
computes the inverse of symmetric or Hermitian positive definite matrix A using the Cholesky factorization previously computed by potrf(). Factors U or L are overwritten with appropriate part of A-1.

In the following table A, B, L, U are matrices and ierr is LAPACK's `diagnostic argument' INFO. Uplo can be CblasUpper or CblasLower, denoting that leading upper or lower, respectively, triangular part of A contains the upper or lower triangular part of the symmetric/Hermitian matrix (and that the lower or upper triangular part, respectively, is not referenced).

ExpressionSemantics
posv(Uplo,A,B) B <- A-1B, using A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
posv(A,B) B <- A-1B, using A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr    [1]
cholesky_solve(A,B)same as posv(A,B)
potrf(Uplo,A) A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
potrf(A) A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr    [1]
cholesky_factor(A)same as potrf(A)
potrs(Uplo,A,B) B <- A-1B assuming A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
potrs(A,B) B <- A-1B assuming A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr    [1]
cholesky_substitute(A,B)same as potrs(A,B)
potri(Uplo,A)A <- A-1 assuming A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
potri(A)A <- A-1 assuming A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr    [1]
cholesky_invert(A)same as getri(A)

[1] It is assumed that matrix traits class can determine whether upper or lower triangular part of A contains the corresponding part of the symmetric/Hermitian matrix (e.g. traits for ublas::symmetric_adaptor<>) and ublas::hermitian_adaptor<>).

Example. Solution to A X = B, with A Hermitian positive definite matrix (lower triangular part is stored): 

  #include <iostream>
  #include <complex>
  #include <boost/numeric/bindings/atlas/clapack.hpp>
  #include <boost/numeric/bindings/traits/ublas_matrix.hpp>
  #include <boost/numeric/bindings/traits/ublas_hermitian.hpp>
  #include <boost/numeric/ublas/io.hpp>

  namespace ublas = boost::numeric::ublas;
  namespace atlas = boost::numeric::bindings::atlas;

  typedef std::complex<double> cmplx_t;
  typedef ublas::matrix<cmplx_t, ublas::column_major> cm_t;
  typedef ublas::hermitian_adaptor<cm_t, ublas::lower> herm_t;

  int main() {
    cm_t CA(3,3);  // matrix (storage)
    herm_t HA(CA);  // hermitian adaptor 
    HA(0,0) = cmplx_t (25,0);
    HA(1,0) = cmplx_t (-5,5);  
    HA(1,1) = cmplx_t (51,0);
    HA(2,0) = cmplx_t (10,-5);
    HA(2,1) = cmplx_t (4,6);
    HA(2,2) = cmplx_t (71,0);

    cm_t CB(3,2);  // right-hand side 
    CB(0,0) = cmplx_t (60,-55);
    CB(1,0) = cmplx_t (34,58);
    CB(2,0) = cmplx_t (13,-152);
    CB(0,1) = cmplx_t (70,10);
    CB(1,1) = cmplx_t (-51,110);
    CB(2,1) = cmplx_t (75,63);
  
    atlas::posv (HA, CB);  // solve system
    std::cout << "X: " << CB << std::endl; 
  }

Example. Inverse of the symmetric positive definite matrix A (upper triangular part is stored): 

  #include <iostream>
  #include <boost/numeric/bindings/atlas/cblas3.hpp>
  #include <boost/numeric/bindings/atlas/clapack.hpp>
  #include <boost/numeric/bindings/traits/ublas_matrix.hpp>
  #include <boost/numeric/bindings/traits/ublas_hermitian.hpp>
  #include <boost/numeric/ublas/io.hpp>

  namespace ublas = boost::numeric::ublas;
  namespace atlas = boost::numeric::bindings::atlas;

  typedef ublas::matrix<double> m_t;
  typedef ublas::symmetric_adaptor<m_t, ublas::upper> symm_t;

  int main() {
    m_t A(5,5);  // matrix (storage)
    // A = 
    //   [5 4 3 2 1]
    //   [0 5 4 3 2]
    //   [0 0 5 4 3]
    //   [0 0 0 5 4]
    //   [0 0 0 0 5]
    symm_t SA(A);  // symmetric adaptor 
    m_t A2(SA);  // copy of SA (full symmetric) 

    atlas::potrf (SA);  // factorise SA
    atlas::potri (SA);  // compute inverse 

    // RI is (almost) identity matrix: 
    m_t RI(5,5);
    atlas::symm (A2, SA, RI);  
    std::cout << "I = A * A^(-1): " << RI << std::endl;
    atlas::symm (SA, A2, RI);  
    std::cout << "I = A^(-1) * A: " << RI << std::endl;
  }
(BLAS level 3 function symm() computes AB or BA, where A is symmetric (only upper or lower triangular part is referenced) and B is general ('full') matrix -- in our example, as SA is symmetric matrix, A2 must be `full'.)

[1] C, prior to C99, didn't have complex data type. Parameters of complex versions are therefore void* or const void*, and it is assumed that ``a complex element consists of two consecutive memory locations of the underlying data type (i.e., float or double), where the first location contains the real component, and the second contains the imaginary component''.

[2] If you are using stable version of ATLAS prior to 3.4.2 or developer version prior to 3.5.6 and if you didn't apply fix described in ATLAS errata, clapack_inc.hpp must include both atlas_enum.h and clapack.h.

[3] There are two more functions: xlauum() and xtrtri(). Currently, bindings for them are not provided. boost-bindings/libs/numeric/bindings/atlas/ublas_symm2syr.cc0000644000175000017500000000752510776013426024430 0ustar andreasandreas // BLAS level 2 // symmetric matrices //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef ublas::vector vct_t; typedef ublas::symmetric_matrix< real_t, ublas::upper, ublas::column_major > ucsymm_t; typedef ublas::symmetric_matrix< real_t, ublas::lower, ublas::column_major > lcsymm_t; typedef ublas::symmetric_matrix< real_t, ublas::upper, ublas::row_major > ursymm_t; typedef ublas::symmetric_matrix< real_t, ublas::lower, ublas::row_major > lrsymm_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::symmetric_adaptor ucsa_t; typedef ublas::symmetric_adaptor lcsa_t; typedef ublas::symmetric_adaptor ursa_t; typedef ublas::symmetric_adaptor lrsa_t; int main() { cout << endl; size_t n; cout << "n -> "; cin >> n; cout << endl; vct_t vx (n), vy (n); atlas::set (1., vx); print_v (vx, "vx"); vy (1) = 1.; print_v (vy, "vy"); // symmetric matrix ucsymm_t ucs (n, n); lcsymm_t lcs (n, n); ursymm_t urs (n, n); lrsymm_t lrs (n, n); init_symm (ucs, 'u'); init_symm (lcs, 'l'); init_symm (urs, 'u'); init_symm (lrs, 'l'); print_m (ucs, "ucs"); cout << endl; print_m (lcs, "lcs"); cout << endl; print_m (urs, "urs"); cout << endl; print_m (lrs, "lrs"); cout << endl; // m += x x^T atlas::spr (vx, ucs); print_m (ucs, "ucs += x x^T"); cout << endl; atlas::spr (1, vx, lcs); print_m (lcs, "lcs += x x^T"); cout << endl; atlas::spr (1.0f, vx, urs); print_m (urs, "urs += x x^T"); cout << endl; atlas::spr (vx, lrs); print_m (lrs, "lrs += x x^T"); cout << endl; // m += x y^T + y x^T atlas::spr2 (1, vx, vy, ucs); print_m (ucs, "ucs += x y^T + y x^T"); cout << endl; atlas::spr2 (vx, vy, lcs); print_m (lcs, "lcs += x y^T + y x^T"); cout << endl; atlas::spr2 (vx, vy, urs); print_m (urs, "urs += x y^T + y x^T"); cout << endl; atlas::spr2 (1., vx, vy, lrs); print_m (lrs, "lrs += x y^T + y x^T"); cout << endl; // symmetric adaptor cm_t cmu (n, n); cm_t cml (n, n); rm_t rmu (n, n); rm_t rml (n, n); ucsa_t ucsa (cmu); lcsa_t lcsa (cml); ursa_t ursa (rmu); lrsa_t lrsa (rml); init_symm (ucsa, 'u'); init_symm (lcsa, 'l'); init_symm (ursa, 'u'); init_symm (lrsa, 'l'); print_m (ucsa, "ucsa"); cout << endl; print_m (lcsa, "lcsa"); cout << endl; print_m (ursa, "ursa"); cout << endl; print_m (lrsa, "lrsa"); cout << endl; // m += x x^T atlas::syr (vx, ucsa); print_m (ucsa, "ucsa += x x^T"); cout << endl; atlas::syr (1, vx, lcsa); print_m (lcsa, "lcsa += x x^T"); cout << endl; atlas::syr (1.0f, vx, ursa); print_m (ursa, "ursa += x x^T"); cout << endl; atlas::syr (vx, lrsa); print_m (lrsa, "lrsa += x x^T"); cout << endl; // m += x y^T + y x^T atlas::syr2 (1, vx, vy, ucsa); print_m (ucsa, "ucsa += x y^T + y x^T"); cout << endl; atlas::syr2 (vx, vy, lcsa); print_m (lcsa, "lcsa += x y^T + y x^T"); cout << endl; atlas::syr2 (vx, vy, ursa); print_m (ursa, "ursa += x y^T + y x^T"); cout << endl; atlas::syr2 (1., vx, vy, lrsa); print_m (lrsa, "lrsa += x y^T + y x^T"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_symm2.cc0000644000175000017500000001340610776013426023665 0ustar andreasandreas // BLAS level 2 // symmetric & hermitian matrices //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::vector vct_t; typedef ublas::vector cvct_t; typedef ublas::symmetric_matrix< real_t, ublas::upper, ublas::column_major > ucsymm_t; typedef ublas::symmetric_matrix< real_t, ublas::lower, ublas::column_major > lcsymm_t; typedef ublas::symmetric_matrix< real_t, ublas::upper, ublas::row_major > ursymm_t; typedef ublas::symmetric_matrix< real_t, ublas::lower, ublas::row_major > lrsymm_t; typedef ublas::hermitian_matrix< cmplx_t, ublas::upper, ublas::column_major > ucherm_t; typedef ublas::hermitian_matrix< cmplx_t, ublas::lower, ublas::column_major > lcherm_t; typedef ublas::hermitian_matrix< cmplx_t, ublas::upper, ublas::row_major > urherm_t; typedef ublas::hermitian_matrix< cmplx_t, ublas::lower, ublas::row_major > lrherm_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::hermitian_adaptor ucha_t; typedef ublas::hermitian_adaptor lcha_t; typedef ublas::hermitian_adaptor urha_t; typedef ublas::hermitian_adaptor lrha_t; int main() { cout << endl; cout << "symmetric matrix" << endl << endl; size_t n; cout << "n -> "; cin >> n; cout << endl; vct_t vx (n), vy (n); atlas::set (1., vx); print_v (vx, "vx"); ucsymm_t ucs (n, n); lcsymm_t lcs (n, n); ursymm_t urs (n, n); lrsymm_t lrs (n, n); init_symm (ucs, 'u'); init_symm (lcs, 'l'); init_symm (urs, 'u'); init_symm (lrs, 'l'); print_m (ucs, "ucs"); cout << endl; print_m_data (ucs, "ucs"); cout << endl; print_m (lcs, "lcs"); cout << endl; print_m_data (lcs, "lcs"); cout << endl; print_m (urs, "urs"); cout << endl; print_m_data (urs, "urs"); cout << endl; print_m (lrs, "lrs"); cout << endl; print_m_data (lrs, "lrs"); cout << endl; // vy = symm vx atlas::spmv (ucs, vx, vy); print_v (vy, "vy = ucs vx"); cout << endl; atlas::spmv (1, lcs, vx, 0, vy); print_v (vy, "vy = lcs vx"); cout << endl; atlas::spmv (1., urs, vx, 0., vy); print_v (vy, "vy = urs vx"); cout << endl; atlas::spmv (1.0f, lrs, vx, 0.0f, vy); print_v (vy, "vy = lrs vx"); cout << endl; #ifdef F_COMPILATION_FAILURE atlas::symv (ucs, vx, vy); print_v (vy, "vy = ucs vx"); cout << endl; atlas::hpmv (lcs, vx, vy); print_v (vy, "vy = lcs vx"); cout << endl; atlas::gemv (urs, vx, vy); print_v (vy, "vy = urs vx"); cout << endl; atlas::spmv (cmplx_t (1., 0.), lrs, vx, cmplx_t (0., 0.), vy); print_v (vy, "vy = lrs vx"); cout << endl; #endif /////////////////////////////////////////////////// cout << endl << "hermitian matrix" << endl << endl; size_t n2 = 3; cvct_t cvx (n2), cvy (n2); atlas::set (1., cvx); print_v (cvx, "cvx"); cout << endl; ucherm_t uch (n2, n2); uch (0, 0) = cmplx_t (3, 0); uch (0, 1) = cmplx_t (2, -2); uch (1, 1) = cmplx_t (3, 0); uch (0, 2) = cmplx_t (1, -1); uch (1, 2) = cmplx_t (2, 2); uch (2, 2) = cmplx_t (3, 0); print_m (uch, "uch"); cout << endl; print_m_data (uch, "uch"); cout << endl; lcherm_t lch (n2, n2); lch = uch; print_m (lch, "lch"); cout << endl; print_m_data (lch, "lch"); cout << endl; urherm_t urh (uch); print_m (urh, "urh"); cout << endl; print_m_data (urh, "urh"); cout << endl; lrherm_t lrh (uch); print_m (lrh, "lrh"); cout << endl; print_m_data (lrh, "lrh"); cout << endl; // cvy = herm cvx atlas::hpmv (uch, cvx, cvy); print_v (cvy, "cvy = uch cvx"); cout << endl; atlas::hpmv (1, lch, cvx, 0, cvy); print_v (cvy, "cvy = lch cvx"); cout << endl; atlas::hpmv (1., urh, cvx, 0., cvy); print_v (cvy, "cvy = urh cvx"); cout << endl; atlas::hpmv (cmplx_t (1., 0.), lrh, cvx, cmplx_t (0., 0.), cvy); print_v (cvy, "cvy = lrh cvx"); cout << endl; /////////////////////////////////////////////////// cout << endl << "hermitian adaptor" << endl << endl; cm_t cm1 (n2, n2); ucha_t ucha (cm1); ucha = uch; print_m (ucha, "ucha"); cout << endl; print_m_data (ucha, "ucha"); cout << endl; cm_t cm2 (n2, n2); lcha_t lcha (cm2); lcha = uch; print_m (lcha, "lcha"); cout << endl; print_m_data (lcha, "lcha"); cout << endl; rm_t rm1 (n2, n2); urha_t urha (rm1); urha = uch; print_m (urha, "urha"); cout << endl; print_m_data (urha, "urha"); cout << endl; rm_t rm2 (n2, n2); lrha_t lrha (rm2); lrha = uch; print_m (lrha, "lrha"); cout << endl; print_m_data (lrha, "lrha"); cout << endl; // cvy = herma cvx atlas::hemv (ucha, cvx, cvy); print_v (cvy, "cvy = uch cvx"); cout << endl; atlas::hemv (1, lcha, cvx, 0, cvy); print_v (cvy, "cvy = lch cvx"); cout << endl; atlas::hemv (1., urha, cvx, 0., cvy); print_v (cvy, "cvy = urh cvx"); cout << endl; atlas::hemv (cmplx_t (1., 0.), lrha, cvx, cmplx_t (0., 0.), cvy); print_v (cvy, "cvy = lrh cvx"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_matr22.cc0000644000175000017500000000564010776160766023740 0ustar andreasandreas // BLAS level 2 //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #ifdef F_USE_STD_VECTOR #include #include #endif #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; #ifndef F_USE_STD_VECTOR typedef ublas::vector vct_t; typedef ublas::matrix m_t; #else typedef ublas::vector > vct_t; typedef ublas::matrix > m_t; #endif int main() { cout << endl; m_t m (10, 8); init_m (m, times_plus (10, 1, 1)); print_m (m, "m"); cout << endl; vct_t v (8); atlas::set (1., v); print_v (v, "v"); cout << endl; vct_t vy (12); // vector size can be larger // than corresponding matrix size // vy = m v atlas::gemv (CblasNoTrans, 1.0, m, v, 0.0, vy); print_v (vy, "vy = m v"); atlas::gemv (1.0, m, v, 0.0, vy); print_v (vy, "vy = m v"); atlas::gemv (m, v, vy); print_v (vy, "vy = m v"); cout << endl; atlas::set (1, vy); print_v (vy, "vy"); // v = m^T vy atlas::gemv (CblasTrans, 1.0, m, vy, 0.0, v); print_v (v, "v = m^T vy"); cout << endl; // vy = 2.0 m v + 0.5 vy atlas::set (1., v); print_v (v, "v"); print_v (vy, "vy"); atlas::gemv (CblasNoTrans, 2.0, m, v, 0.5, vy); print_v (vy, "vy = 2.0 m v + 0.5 vy"); cout << endl; cout << endl; atlas::set (1, v); atlas::set (0, vy); print_v (v, "v"); print_v (vy, "vy"); cout << endl; // m[2..8][1..7] ublas::matrix_range mr (m, ublas::range (2, 8), ublas::range (1, 7)); print_m (mr, "mr = m[2..8][1..7]"); cout << endl; // vy = m[2..8][1..7] v atlas::gemv (mr, v, vy); print_v (vy, "vy = mr v"); cout << endl; // vy = m[2..8][1..7]^T v atlas::gemv (CblasTrans, 1.0, mr, v, 0.0, vy); print_v (vy, "vy = mr^T v"); cout << endl; cout << endl; // mrr = (m[2..8][1..7])[1..4][2..5] ublas::matrix_range > mrr (mr, ublas::range (1, 4), ublas::range (2, 5)); print_m (mrr, "mrr = (m[2..8][1..7])[1..4][2..5]"); cout << endl; // vy = mrr v atlas::set (0, vy); atlas::gemv (CblasNoTrans, 1.0, mrr, v, 0.0, vy); print_v (vy, "vy = mrr v"); cout << endl; #ifdef F_COMPILATION_FAILURE ublas::matrix_slice ms (m, ublas::slice (2, 1, 4), ublas::slice (1, 2, 4)); print_m (ms, "ms = m[2:1:4][1:2:4]"); cout << endl; atlas::set (0, vy); atlas::gemv (CblasNoTrans, 1.0, ms, v, 0.0, vy); print_v (vy, "vy = ms v"); cout << endl; #endif } boost-bindings/libs/numeric/bindings/atlas/ublas_getrf_getrs.cc0000644000175000017500000000404010776160766025135 0ustar andreasandreas // solving A * X = B // in two steps -- factor (getrf()) and solve (getrs()) //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; #ifndef F_ROW_MAJOR typedef ublas::matrix m_t; #else typedef ublas::matrix m_t; #endif int main() { cout << endl; size_t n = 5; m_t a (n, n); // system matrix size_t nrhs = 2; m_t x (n, nrhs); // b -- right-hand side matrix: // .. see leading comments for `gesv()' in clapack.hpp #ifndef F_ROW_MAJOR m_t b (n, nrhs); #else m_t b (nrhs, n); #endif init_symm (a); // [n n-1 n-2 ... 1] // [n-1 n n-1 ... 2] // a = [n-2 n-1 n ... 3] // [ ... ] // [1 2 ... n-1 n] ublas::matrix_row ar1 (a, 0), ar3 (a, 3); ublas::swap (ar1, ar3); // swap rows to force pivoting ublas::matrix_column xc0 (x, 0), xc1 (x, 1); atlas::set (1., xc0); // x[.,0] = 1 atlas::set (2., xc1); // x[.,1] = 2 #ifndef F_ROW_MAJOR atlas::gemm (a, x, b); // b = a x, so we know the result ;o) #else // see leading comments for `gesv()' in clapack.hpp ublas::matrix_row br0 (b, 0), br1 (b, 1); atlas::gemv (a, xc0, br0); // b[0,.] = a x[.,0] atlas::gemv (a, xc1, br1); // b[1,.] = a x[.,1] => b^T = a x #endif print_m (a, "A"); cout << endl; print_m (b, "B"); cout << endl; std::vector ipiv (n); // pivot vector atlas::getrf (a, ipiv); // factor a atlas::getrs (a, ipiv, b); // solve from factorization print_m (b, "X"); cout << endl; print_v (ipiv, "pivots"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_symmc3.cc0000644000175000017500000000565110776013426024034 0ustar andreasandreas // BLAS level 3 // symmetric complex matrix #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::symmetric_adaptor ucsymm_t; typedef ublas::symmetric_adaptor lcsymm_t; typedef ublas::symmetric_adaptor ursymm_t; typedef ublas::symmetric_adaptor lrsymm_t; int main() { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS cout << endl; size_t n; cout << "n -> "; cin >> n; cout << endl; cm_t uc (n, n); ucsymm_t ucs (uc); cm_t lc (n, n); lcsymm_t lcs (lc); rm_t ur (n, n); ursymm_t urs (ur); rm_t lr (n, n); lrsymm_t lrs (lr); init_symm (ucs, 'u'); init_symm (lcs, 'l'); init_symm (urs, 'u'); init_symm (lrs, 'l'); print_m (ucs, "a == ucs"); cout << endl; print_m_data (ucs, "ucs"); cout << endl; print_m (lcs, "a == lcs"); cout << endl; print_m_data (lcs, "lcs"); cout << endl; print_m (urs, "a == urs"); cout << endl; print_m_data (urs, "urs"); cout << endl; print_m (lrs, "a == lrs"); cout << endl; print_m_data (lrs, "lrs"); cout << endl; cm_t cbl (n, n+1); rm_t rbl (n, n+1); cm_t ccl (n, n+1); rm_t rcl (n, n+1); init_m (cbl, rws1()); init_m (rbl, rws1()); print_m (cbl, "b == cb"); cout << endl; print_m (rbl, "b == rb"); cout << endl; atlas::symm (ucs, cbl, ccl); print_m (ccl, "c = a b"); cout << endl; atlas::symm (lcs, cbl, ccl); print_m (ccl, "c = a b"); cout << endl; atlas::symm (urs, rbl, rcl); print_m (rcl, "c = a b"); cout << endl; atlas::symm (lrs, rbl, rcl); print_m (rcl, "c = a b"); cout << endl; cm_t cbr (n+1, n); rm_t rbr (n+1, n); cm_t ccr (n+1, n); rm_t rcr (n+1, n); init_m (cbr, cls1()); init_m (rbr, cls1()); print_m (cbr, "b == cb"); cout << endl; print_m (rbr, "b == rb"); cout << endl; atlas::symm (cbr, ucs, ccr); print_m (ccr, "c = b a"); cout << endl; atlas::symm (cbr, lcs, ccr); print_m (ccr, "c = b a"); cout << endl; atlas::symm (rbr, urs, rcr); print_m (rcr, "c = b a"); cout << endl; atlas::symm (rbr, lrs, rcr); print_m (rcr, "c = b a"); cout << endl; cout << endl; #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS cout << "requires proper traits classes :o(" << endl; #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS } boost-bindings/libs/numeric/bindings/atlas/utils.h0000644000175000017500000001361110776160766022442 0ustar andreasandreas #ifndef F_UTILS_H #define F_UTILS_H #include #include #include /////////////////////////////// // vectors #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS // element access: template struct vct_access_traits { typedef typename boost::numeric::bindings::traits::vector_traits::value_type val_t; typedef val_t& ref_t; static ref_t elem (V& v, size_t i) { return v[i]; } }; template struct vct_access_traits { typedef typename boost::numeric::bindings::traits::vector_traits::value_type val_t; typedef val_t ref_t; static ref_t elem (V const& v, size_t i) { return v[i]; } }; template inline typename vct_access_traits::ref_t elem_v (V& v, size_t i) { return vct_access_traits::elem (v, i); } #endif // initialization: struct ident { size_t operator() (size_t i) const { return i; } }; struct iplus1 { size_t operator() (size_t i) const { return i + 1; } }; template struct const_val { T val; const_val (T v = T()) : val (v) {} T operator() (size_t) const { return val; } T operator() (size_t, size_t) const { return val; } }; struct kpp { size_t val; kpp (size_t v = 0) : val (v) {} size_t operator() (size_t) { size_t tmp = val; ++val; return tmp; } size_t operator() (size_t, size_t) { size_t tmp = val; ++val; return tmp; } }; template struct times_plus { T s, a, b; times_plus (T ss, T aa = T(), T bb = T()) : s (ss), a (aa), b (bb) {} T operator() (size_t i) const { return s * (T) i + a; } T operator() (size_t i, size_t j) const { return s * ((T) i + a) + (T) j + b; } }; template void init_v (V& v, F f = F()) { size_t sz = boost::numeric::bindings::traits::vector_size (v); for (std::size_t i = 0; i < sz; ++i) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS elem_v (v, i) = f (i); #else v[i] = f (i); #endif } } // printing: template void print_v (V const& v, char const* ch = 0) { if (ch) std::cout << ch << ": "; size_t sz = boost::numeric::bindings::traits::vector_size (v); for (std::size_t i = 0; i < sz; ++i) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS std::cout << elem_v (v, i) << " "; #else std::cout << v[i] << " "; #endif } std::cout << std::endl; } ///////////////////////////////////// // matrices #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS // element access: template struct matr_access_traits { typedef typename boost::numeric::bindings::traits::matrix_traits::value_type val_t; typedef val_t& ref_t; static ref_t elem (M& m, size_t i, size_t j) { return m (i, j); } }; template struct matr_access_traits { typedef typename boost::numeric::bindings::traits::matrix_traits::value_type val_t; typedef val_t ref_t; static ref_t elem (M const& m, size_t i, size_t j) { return m (i, j); } }; template inline typename matr_access_traits::ref_t elem_m (M& m, size_t i, size_t j) { return matr_access_traits::elem (m, i, j); } #endif // initialization: struct rws { size_t operator() (size_t i, size_t) const { return i; } }; struct rws1 { size_t operator() (size_t i, size_t) const { return i + 1; } }; struct cls { size_t operator() (size_t, size_t j) const { return j; } }; struct cls1 { size_t operator() (size_t, size_t j) const { return j + 1; } }; template void init_m (M& m, F f = F()) { size_t sz1 = boost::numeric::bindings::traits::matrix_size1 (m); size_t sz2 = boost::numeric::bindings::traits::matrix_size2 (m); for (std::size_t i = 0; i < sz1; ++i) for (std::size_t j = 0; j < sz2; ++j) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS elem_m (m, i, j) = f (i, j); #else m(i,j) = f (i, j); #endif } } template void init_symm (M& m, char uplo = 'f') { size_t n = boost::numeric::bindings::traits::matrix_size1 (m); for (size_t i = 0; i < n; ++i) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS elem_m (m, i, i) = n; #else m(i,i) = n; #endif for (size_t j = i + 1; j < n; ++j) { if (uplo == 'u' || uplo == 'U') { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS elem_m (m, i, j) = n - (j - i); #else m(i,j) = n - (j - i); #endif } else if (uplo == 'l' || uplo == 'L') { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS elem_m (m, j, i) = n - (j - i); #else m(j,i) = n - (j - i); #endif } else { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS elem_m (m, i, j) = elem_m (m, j, i) = n - (j - i); #else m(i,j) = m(j,i) = n - (j - i); #endif } } } } // printing: template void print_m (M const& m, char const* ch = 0) { if (ch) std::cout << ch << ":\n"; size_t sz1 = boost::numeric::bindings::traits::matrix_size1 (m); size_t sz2 = boost::numeric::bindings::traits::matrix_size2 (m); for (std::size_t i = 0 ; i < sz1 ; ++i) { for (std::size_t j = 0 ; j < sz2 ; ++j) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS std::cout << elem_m (m, i, j) << " "; #else std::cout << m(i,j) << " "; #endif } std::cout << std::endl; } // std::cout << std::endl; } template void print_m_data (M const& m, char const* ch = 0) { if (ch) std::cout << ch << " data:\n"; //#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS size_t sz = boost::numeric::bindings::traits::matrix_traits ::storage_size (m); typename boost::numeric::bindings::traits::matrix_traits::pointer st = boost::numeric::bindings::traits::matrix_traits::storage (m); for (std::size_t i = 0 ; i < sz ; ++i, ++st) std::cout << *st << " "; std::cout << std::endl; //#else // std::cout << ".. poor man\'s traits :o(" << std::endl; //#endif } #endif boost-bindings/libs/numeric/bindings/atlas/init.cc0000644000175000017500000000534410776013426022375 0ustar andreasandreas // nothing to do with ATLAS bindings ;o) // various initializations from `utils.h' #include #include #include #include #include #include #include "utils.h" #ifndef F_FLOAT typedef double real_t; #else typedef float real_t; #endif #ifndef F_COMPLEX typedef real_t elem_t; #else typedef std::complex elem_t; #endif typedef boost::numeric::ublas::vector vct_t; #ifdef F_ROW_MAJOR typedef boost::numeric::ublas::matrix matr_t; #else typedef boost::numeric::ublas::matrix< elem_t, boost::numeric::ublas::column_major > matr_t; #endif int main() { std::cout << std::endl; vct_t v (10); // v[i] = i || (i, 0) init_v (v); print_v (v); std::cout << std::endl; // v[i] = i+1 || (i+1, 0) init_v (v, iplus1()); print_v (v); std::cout << std::endl; // v[i] = k || (k, 0) ; i = 0, k = 5 ; ++i, ++k init_v (v, kpp (5)); print_v (v); std::cout << std::endl; // v[i] = 2 || (2, 0) init_v (v, const_val (2)); print_v (v); std::cout << std::endl; // v[i] = 10 i || (10 i, 0) init_v (v, times_plus (10)); print_v (v); std::cout << std::endl; // v[i] = i+0.1 || (i+0.1, 0) init_v (v, times_plus (1, 0.1)); print_v (v); std::cout << std::endl; std::cout << std::endl; matr_t m (5, 7); // m[i, j] = k ; i = 0, j = 0, k = 0 ; ++j, ++k init_m (m); print_m (m); std::cout << std::endl; #ifndef F_COMPLEX elem_t s (10); #else elem_t s (10, -1); #endif // m[i, j] = s (i+1) + (j+0.1) init_m (m, times_plus (s, 1, 0.1)); print_m (m); std::cout << std::endl; #ifndef F_COMPLEX elem_t c (-2); #else elem_t c (2, -2); #endif // m[i, j] = c init_m (m, const_val (c)); print_m (m); std::cout << std::endl; // m[i, j] = i init_m (m); print_m (m); std::cout << std::endl; // m[i, j] = j+1 init_m (m, cls1()); print_m (m); std::cout << std::endl; matr_t sm (4, 4); // [4 3 2 1] // [0 4 3 2] // [0 0 4 3] // [0 0 0 4] init_symm (sm, 'u'); print_m (sm); std::cout << std::endl; print_m_data (sm); std::cout << std::endl; init_m (sm, const_val (0)); // [4 3 2 1] // [3 4 3 2] // [2 3 4 3] // [1 2 3 4] init_symm (sm); print_m (sm); std::cout << std::endl; print_m_data (sm); std::cout << std::endl; init_m (sm, const_val (0)); // [4 0 0 0] // [3 4 0 0] // [2 3 4 0] // [1 2 3 4] init_symm (sm, 'L'); print_m (sm); std::cout << std::endl; print_m_data (sm); std::cout << std::endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_herm3.cc0000644000175000017500000000565610776013426023644 0ustar andreasandreas // BLAS level 3 // hermitian matrix (kind of ;o) #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::hermitian_adaptor uchemm_t; typedef ublas::hermitian_adaptor lchemm_t; typedef ublas::hermitian_adaptor urhemm_t; typedef ublas::hermitian_adaptor lrhemm_t; int main() { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS cout << endl; size_t n; cout << "n -> "; cin >> n; cout << endl; cm_t uc (n, n); uchemm_t ucs (uc); cm_t lc (n, n); lchemm_t lcs (lc); rm_t ur (n, n); urhemm_t urs (ur); rm_t lr (n, n); lrhemm_t lrs (lr); init_symm (ucs, 'u'); init_symm (lcs, 'l'); init_symm (urs, 'u'); init_symm (lrs, 'l'); print_m (ucs, "a == ucs"); cout << endl; print_m_data (ucs, "ucs"); cout << endl; print_m (lcs, "a == lcs"); cout << endl; print_m_data (lcs, "lcs"); cout << endl; print_m (urs, "a == urs"); cout << endl; print_m_data (urs, "urs"); cout << endl; print_m (lrs, "a == lrs"); cout << endl; print_m_data (lrs, "lrs"); cout << endl; cm_t cbl (n, n+1); rm_t rbl (n, n+1); cm_t ccl (n, n+1); rm_t rcl (n, n+1); init_m (cbl, rws1()); init_m (rbl, rws1()); print_m (cbl, "b == cb"); cout << endl; print_m (rbl, "b == rb"); cout << endl; atlas::hemm (ucs, cbl, ccl); print_m (ccl, "c = a b"); cout << endl; atlas::hemm (lcs, cbl, ccl); print_m (ccl, "c = a b"); cout << endl; atlas::hemm (urs, rbl, rcl); print_m (rcl, "c = a b"); cout << endl; atlas::hemm (lrs, rbl, rcl); print_m (rcl, "c = a b"); cout << endl; cm_t cbr (n+1, n); rm_t rbr (n+1, n); cm_t ccr (n+1, n); rm_t rcr (n+1, n); init_m (cbr, cls1()); init_m (rbr, cls1()); print_m (cbr, "b == cb"); cout << endl; print_m (rbr, "b == rb"); cout << endl; atlas::hemm (cbr, ucs, ccr); print_m (ccr, "c = b a"); cout << endl; atlas::hemm (cbr, lcs, ccr); print_m (ccr, "c = b a"); cout << endl; atlas::hemm (rbr, urs, rcr); print_m (rcr, "c = b a"); cout << endl; atlas::hemm (rbr, lrs, rcr); print_m (rcr, "c = b a"); cout << endl; cout << endl; #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS cout << "requires proper traits classes :o(" << endl; #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS } boost-bindings/libs/numeric/bindings/atlas/ublas_herm3h2k.cc0000644000175000017500000000646610776013426024251 0ustar andreasandreas // BLAS level 3 // hermitian matrices, her2k #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef float real_t; typedef std::complex cmplx_t; typedef ublas::matrix ccm_t; typedef ublas::matrix crm_t; typedef ublas::hermitian_adaptor cucha_t; typedef ublas::hermitian_adaptor clcha_t; typedef ublas::hermitian_adaptor curha_t; typedef ublas::hermitian_adaptor clrha_t; int main() { // complex const int n1 = 3; const int k1 = 2; ccm_t cac (n1, k1); crm_t car (n1, k1); cac(0,0) = car(0,0) = cmplx_t (1., 1.); cac(1,0) = car(1,0) = cmplx_t (2., 1.); cac(2,0) = car(2,0) = cmplx_t (3., 1.); cac(0,1) = car(0,1) = cmplx_t (1., 1.); cac(1,1) = car(1,1) = cmplx_t (2., 1.); cac(2,1) = car(2,1) = cmplx_t (3., 1.); print_m (cac, "cac"); cout << endl; print_m (car, "car"); cout << endl << endl; ccm_t cbc (n1, k1); crm_t cbr (n1, k1); cbc(0,0) = cbr(0,0) = cmplx_t (0., -1.); cbc(1,0) = cbr(1,0) = cmplx_t (0., -1.); cbc(2,0) = cbr(2,0) = cmplx_t (0., -1.); cbc(0,1) = cbr(0,1) = cmplx_t (0., -1.); cbc(1,1) = cbr(1,1) = cmplx_t (0., -1.); cbc(2,1) = cbr(2,1) = cmplx_t (0., -1.); print_m (cbc, "cbc"); cout << endl; print_m (cbr, "cbr"); cout << endl << endl; ccm_t ccmu (n1, n1); ccm_t ccml (n1, n1); crm_t crmu (n1, n1); crm_t crml (n1, n1); cucha_t cucha (ccmu); clcha_t clcha (ccml); curha_t curha (crmu); clrha_t clrha (crml); atlas::her2k (CblasNoTrans, cac, cbc, cucha); atlas::her2k (CblasNoTrans, cmplx_t(1,0), cac, cbc, 0., clcha); atlas::her2k (CblasNoTrans, cmplx_t(1,0), car, cbr, 0., curha); atlas::her2k (CblasNoTrans, car, cbr, clrha); print_m (cucha, "cucha"); cout << endl; print_m (clcha, "clcha"); cout << endl; print_m (curha, "curha"); cout << endl; print_m (clrha, "clrha"); cout << endl << endl; // part 2 ccm_t cact (ublas::herm (cac)); crm_t cart (ublas::herm (car)); print_m (cact, "cact"); cout << endl; print_m (cart, "cart"); cout << endl << endl; ccm_t cbct (ublas::herm (cbc)); crm_t cbrt (ublas::herm (cbr)); print_m (cbct, "cbct"); cout << endl; print_m (cbrt, "cbrt"); cout << endl << endl; init_m (ccmu, const_val (cmplx_t (0, 0))); init_m (ccml, const_val (cmplx_t (0, 0))); init_m (crmu, const_val (cmplx_t (0, 0))); init_m (crml, const_val (cmplx_t (0, 0))); atlas::her2k (CblasUpper, CblasConjTrans, 1.0, cact, cbct, 0.0, ccmu); atlas::her2k (CblasLower, CblasConjTrans, 1.0, cact, cbct, 0.0, ccml); atlas::her2k (CblasUpper, CblasConjTrans, 1.0, cart, cbrt, 0.0, crmu); atlas::her2k (CblasLower, CblasConjTrans, 1.0, cart, cbrt, 0.0, crml); print_m (ccmu, "ccmu"); cout << endl; print_m (ccml, "ccml"); cout << endl; print_m (crmu, "crmu"); cout << endl; print_m (crml, "crml"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_matr2.cc0000644000175000017500000000325710776013426023646 0ustar andreasandreas // BLAS level 2 //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; typedef ublas::vector vct_t; typedef ublas::matrix rm_t; typedef ublas::matrix cm_t; int main() { cout << endl; vct_t vx (2); vct_t vy (4); // row major matrix rm_t rm (4, 2); init_m (rm, kpp (1)); print_m (rm, "row major matrix m"); cout << endl; atlas::set (1., vx); print_v (vx, "vx"); cout << endl; // vy = m vx atlas::gemv (CblasNoTrans, 1.0, rm, vx, 0.0, vy); print_v (vy, "vy = m vx"); cout << endl; atlas::set (1., vy); print_v (vy, "vy"); cout << endl; // vx = m^T vy atlas::gemv (CblasTrans, 1.0, rm, vy, 0.0, vx); print_v (vx, "vx = m^T vy"); cout << endl; cout << endl; // column major matrix cm_t cm (4, 2); init_m (cm, kpp (1)); print_m (cm, "column major matrix m"); cout << endl; atlas::set (1., vx); print_v (vx, "vx"); cout << endl; // vy = m vx atlas::gemv (CblasNoTrans, 1.0, cm, vx, 0.0, vy); print_v (vy, "vy = m vx"); cout << endl; atlas::set (1., vy); print_v (vy, "vy"); cout << endl; // vx = m^T vy atlas::gemv (CblasTrans, 1.0, cm, vy, 0.0, vx); print_v (vx, "vx = m^T vy"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_gesv3.cc0000644000175000017500000000241010776013426023636 0ustar andreasandreas // solving A * X = B // using driver function gesv() //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; #ifndef F_ROW_MAJOR typedef ublas::matrix m_t; #else typedef ublas::matrix m_t; #endif int main() { cout << endl; size_t n = 3, nrhs = 1; m_t a (n, n); // system matrix a(0,0) = 1.; a(0,1) = 1.; a(0,2) = 1.; a(1,0) = 2.; a(1,1) = 3.; a(1,2) = 1.; a(2,0) = 1.; a(2,1) = -1.; a(2,2) = -1.; // see leading comments for `gesv()' in clapack.hpp #ifndef F_ROW_MAJOR m_t b (n, nrhs); // right-hand side matrix b(0,0) = 4.; b(1,0) = 9.; b(2,0) = -2.; #else m_t b (nrhs, n); b(0,0) = 4.; b(0,1) = 9.; b(0,2) = -2.; #endif cout << "A: " << a << endl; cout << "B: " << b << endl; atlas::lu_solve (a, b); cout << "X: " << b << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_symm3s2k.cc0000644000175000017500000001114110776013426024300 0ustar andreasandreas // BLAS level 3 // symmetric matrices, syr2k #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::symmetric_adaptor ucsa_t; typedef ublas::symmetric_adaptor lcsa_t; typedef ublas::symmetric_adaptor ursa_t; typedef ublas::symmetric_adaptor lrsa_t; typedef ublas::matrix ccm_t; typedef ublas::matrix crm_t; typedef ublas::symmetric_adaptor cucsa_t; typedef ublas::symmetric_adaptor clcsa_t; typedef ublas::symmetric_adaptor cursa_t; typedef ublas::symmetric_adaptor clrsa_t; int main() { int n, k; cout << "n -> "; cin >> n; cout << "k -> "; cin >> k; cm_t ac (n, k); rm_t ar (n, k); init_m (ac, rws1()); init_m (ar, rws1()); print_m (ac, "ac"); cout << endl; print_m (ar, "ar"); cout << endl << endl; cm_t bc (n, k); rm_t br (n, k); init_m (bc, const_val (1)); init_m (br, const_val (1)); print_m (bc, "bc"); cout << endl; print_m (br, "br"); cout << endl << endl; cm_t cmu (n, n); cm_t cml (n, n); rm_t rmu (n, n); rm_t rml (n, n); ucsa_t ucsa (cmu); lcsa_t lcsa (cml); ursa_t ursa (rmu); lrsa_t lrsa (rml); atlas::syr2k (CblasNoTrans, ac, bc, ucsa); atlas::syr2k (CblasNoTrans, 1.0, ac, bc, 0.0, lcsa); atlas::syr2k (CblasNoTrans, 1.0, ar, br, 0.0, ursa); atlas::syr2k (CblasNoTrans, ar, br, lrsa); print_m (ucsa, "ucsa"); cout << endl; print_m (lcsa, "lcsa"); cout << endl; print_m (ursa, "ursa"); cout << endl; print_m (lrsa, "lrsa"); cout << endl << endl; // part 2 cm_t act (k, n); rm_t art (k, n); init_m (act, cls1()); init_m (art, cls1()); print_m (act, "act"); cout << endl; print_m (art, "art"); cout << endl << endl; cm_t bct (k, n); rm_t brt (k, n); init_m (bct, rws1()); init_m (brt, rws1()); print_m (bct, "bct"); cout << endl; print_m (brt, "brt"); cout << endl << endl; init_m (cmu, const_val (0)); init_m (cml, const_val (0)); init_m (rmu, const_val (0)); init_m (rml, const_val (0)); atlas::syr2k (CblasUpper, CblasTrans, 1.0, act, bct, 0.0, cmu); atlas::syr2k (CblasLower, CblasTrans, 1.0, act, bct, 0.0, cml); atlas::syr2k (CblasUpper, CblasTrans, 1.0, art, brt, 0.0, rmu); atlas::syr2k (CblasLower, CblasTrans, 1.0, art, brt, 0.0, rml); print_m (cmu, "cmu"); cout << endl; print_m (cml, "cml"); cout << endl; print_m (rmu, "rmu"); cout << endl; print_m (rml, "rml"); cout << endl; // complex const int n1 = 3; const int k1 = 2; ccm_t cac (n1, k1); crm_t car (n1, k1); cac(0,0) = car(0,0) = cmplx_t (1., 1.); cac(1,0) = car(1,0) = cmplx_t (2., 1.); cac(2,0) = car(2,0) = cmplx_t (3., 1.); cac(0,1) = car(0,1) = cmplx_t (1., 1.); cac(1,1) = car(1,1) = cmplx_t (2., 1.); cac(2,1) = car(2,1) = cmplx_t (3., 1.); print_m (cac, "cac"); cout << endl; print_m (car, "car"); cout << endl << endl; ccm_t cbc (n1, k1); crm_t cbr (n1, k1); cbc(0,0) = cbr(0,0) = cmplx_t (0., -1.); cbc(1,0) = cbr(1,0) = cmplx_t (0., -1.); cbc(2,0) = cbr(2,0) = cmplx_t (0., -1.); cbc(0,1) = cbr(0,1) = cmplx_t (0., -1.); cbc(1,1) = cbr(1,1) = cmplx_t (0., -1.); cbc(2,1) = cbr(2,1) = cmplx_t (0., -1.); print_m (cbc, "cbc"); cout << endl; print_m (cbr, "cbr"); cout << endl << endl; ccm_t ccmu (n1, n1); ccm_t ccml (n1, n1); crm_t crmu (n1, n1); crm_t crml (n1, n1); cucsa_t cucsa (ccmu); clcsa_t clcsa (ccml); cursa_t cursa (crmu); clrsa_t clrsa (crml); atlas::syr2k (CblasNoTrans, cac, cbc, cucsa); atlas::syr2k (CblasNoTrans, cmplx_t(1,0), cac, cbc, cmplx_t(0,0), clcsa); atlas::syr2k (CblasNoTrans, cmplx_t(1,0), car, cbr, cmplx_t(0,0), cursa); atlas::syr2k (CblasNoTrans, car, cbr, clrsa); print_m (cucsa, "cucsa"); cout << endl; print_m (clcsa, "clcsa"); cout << endl; print_m (cursa, "cursa"); cout << endl; print_m (clrsa, "clrsa"); cout << endl << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_gesv5.cc0000644000175000017500000000344510776160766023663 0ustar andreasandreas // solving A * X = B // using driver function gesv() // with c_vector<> & c_matrix<> //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING //#define BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK //#define BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS # include #endif #include #include namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; typedef ublas::c_matrix m4x4_t; typedef ublas::c_matrix m3x3_t; typedef ublas::c_matrix mrhs_t; typedef ublas::c_vector v5_t; int main() { cout << endl; size_t n = 3; m4x4_t a (n, n); // system matrix a(0,0) = 1.; a(0,1) = 1.; a(0,2) = 1.; a(1,0) = 2.; a(1,1) = 3.; a(1,2) = 1.; a(2,0) = 1.; a(2,1) = -1.; a(2,2) = -1.; mrhs_t b (1, n); // right-hand side vector b(0,0) = 4.; b(0,1) = 9.; b(0,2) = -2.; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS m3x3_t a2; // for part 2 a2 = project (a, ublas::range (0,3), ublas::range (0,3)); v5_t b2 (n); b2 = row (b, 0); #endif // part 1: cout << "A: " << a << endl; cout << "B: " << b << endl; atlas::lu_solve (a, b); cout << "X: " << b << endl; cout << endl; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS // part 2: cout << "A: " << a2 << endl; cout << "B: " << b2 << endl; atlas::lu_solve (a2, b2); cout << "X: " << b2 << endl; cout << endl; #endif } boost-bindings/libs/numeric/bindings/atlas/ublas_cmatr3.cc0000644000175000017500000000350210776013426024003 0ustar andreasandreas // BLAS level 3 -- complex numbers //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #ifdef F_USE_STD_VECTOR #include #include #endif #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; #ifndef F_USE_STD_VECTOR typedef ublas::matrix m_t; #else typedef ublas::matrix > m_t; #endif int main() { cout << endl; m_t a (2, 2); a (0, 0) = cmplx_t (1., 0.); a (0, 1) = cmplx_t (2., 0.); a (1, 0) = cmplx_t (3., 0.); a (1, 1) = cmplx_t (4., 0.); print_m (a, "A"); cout << endl; m_t b (2, 3); b (0, 0) = cmplx_t (1., 0.); b (0, 1) = cmplx_t (2., 0.); b (0, 2) = cmplx_t (3., 0.); b (1, 0) = cmplx_t (1., 0.); b (1, 1) = cmplx_t (2., 0.); b (1, 2) = cmplx_t (3., 0.); print_m (b, "B"); cout << endl; m_t c (2, 3); // c = a b atlas::gemm (a, b, c); print_m (c, "A B"); cout << endl; a (0, 0) = cmplx_t (0., 1.); a (0, 1) = cmplx_t (0., 2.); a (1, 0) = cmplx_t (0., 3.); a (1, 1) = cmplx_t (0., 4.); print_m (a, "A"); cout << endl; // c = a b atlas::gemm (CblasNoTrans, CblasNoTrans, 1.0, a, b, 0.0, c); print_m (c, "A B"); cout << endl; // c = a^T b atlas::gemm (CblasTrans, CblasNoTrans, 1.0, a, b, 0.0, c); print_m (c, "A^T B"); cout << endl; // c = a^H b atlas::gemm (CblasConjTrans, CblasNoTrans, 1.0, a, b, 0.0, c); print_m (c, "A^H B"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_symm33.cc0000644000175000017500000000511410776013426023746 0ustar andreasandreas // BLAS level 3 // symmetric matrix (without adaptor) //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; int main() { cout << endl; size_t n; cout << "n -> "; cin >> n; cout << endl; cm_t uc (n, n); cm_t lc (n, n); rm_t ur (n, n); rm_t lr (n, n); init_symm (uc, 'u'); init_symm (lc, 'l'); init_symm (ur, 'u'); init_symm (lr, 'l'); print_m (uc, "a == uc"); cout << endl; print_m_data (uc, "uc"); cout << endl; print_m (lc, "a == lc"); cout << endl; print_m_data (lc, "lc"); cout << endl; print_m (ur, "a == ur"); cout << endl; print_m_data (ur, "ur"); cout << endl; print_m (lr, "a == lr"); cout << endl; print_m_data (lr, "lr"); cout << endl; cm_t cbl (n, n+1); rm_t rbl (n, n+1); cm_t ccl (n, n+1); rm_t rcl (n, n+1); init_m (cbl, rws1()); init_m (rbl, rws1()); print_m (cbl, "b == cb"); cout << endl; print_m (rbl, "b == rb"); cout << endl; atlas::symm (CblasLeft, CblasUpper, 1., uc, cbl, 0., ccl); print_m (ccl, "c = a b"); cout << endl; atlas::symm (CblasLeft, CblasLower, 1., lc, cbl, 0., ccl); print_m (ccl, "c = a b"); cout << endl; atlas::symm (CblasLeft, CblasUpper, 1., ur, rbl, 0., rcl); print_m (rcl, "c = a b"); cout << endl; atlas::symm (CblasLeft, CblasLower, 1., lr, rbl, 0., rcl); print_m (rcl, "c = a b"); cout << endl; cm_t cbr (n+1, n); rm_t rbr (n+1, n); cm_t ccr (n+1, n); rm_t rcr (n+1, n); init_m (cbr, cls1()); init_m (rbr, cls1()); print_m (cbr, "b == cb"); cout << endl; print_m (rbr, "b == rb"); cout << endl; atlas::symm (CblasRight, CblasUpper, 1., uc, cbr, 0., ccr); print_m (ccr, "c = b a"); cout << endl; atlas::symm (CblasRight, CblasLower, 1., lc, cbr, 0., ccr); print_m (ccr, "c = b a"); cout << endl; atlas::symm (CblasRight, CblasUpper, 1., ur, rbr, 0., rcr); print_m (rcr, "c = b a"); cout << endl; atlas::symm (CblasRight, CblasLower, 1., lr, rbr, 0., rcr); print_m (rcr, "c = b a"); cout << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_vct.cc0000644000175000017500000001102610776160766023420 0ustar andreasandreas // BLAS level 1 (vectors) //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #ifdef F_USE_STD_VECTOR #include #include #endif #include "utils.h" namespace atlas = boost::numeric::bindings::atlas; namespace ublas = boost::numeric::ublas; using std::cout; using std::endl; using std::size_t; typedef double real_t; #ifndef F_USE_STD_VECTOR typedef ublas::vector vct_t; #else typedef ublas::vector > vct_t; #endif int main() { cout << endl; vct_t v (10); init_v (v, times_plus (0.1, 0.1)); print_v (v, "v"); vct_t vy (10); atlas::set (1., vy); print_v (vy, "vy"); cout << endl; // v <- 2 v atlas::scal (2.0, v); print_v (v, "v <- 2 v"); // vy <- 0.5 v + vy atlas::axpy (0.5, v, vy); print_v (vy, "vy <- 0.5 v + vy"); // v^T vy cout << "v vy = " << atlas::dot (v, vy) << endl; cout << endl; ///////////////// // ranges // v -- new init init_v (v, times_plus (0.1, 0.1)); print_v (v, "v"); // vy -- new init init_v (vy, kpp (1)); print_v (vy, "vy"); // v[2..6] ublas::vector_range vr (v, ublas::range (2, 6)); print_v (vr, "v[2..6]"); // vy[4..8] ublas::vector_range vry (vy, ublas::range (4, 8)); print_v (vry, "vy[4..8]"); // v[2..6] <- 0.1 v[2..6] atlas::scal (0.1, vr); print_v (v, "v[2..6] <- 0.1 v[2..6]"); // vr^T vr // ublas::vector_range cvr (v, ublas::range (2, 6)); cout << "v[2..6] v[2..6] = " << atlas::dot (vr, vr) << endl; // vy[4..8] <- v[2..6] + vy[4..8] atlas::xpy (vr, vry); print_v (vy, "vy[4..8] <- v[2..6] + vy[4..8]"); cout << endl; ///////////////// // slices // v -- new init init_v (v, times_plus (0.1, 0.1)); print_v (v, "v"); // vy -- new init init_v (vy, kpp (1)); print_v (vy, "vy"); // v[1:2:4] ublas::vector_slice vs (v, ublas::slice (1, 2, 4)); print_v (vs, "v[1:2:4]"); // vy[2:2:4] ublas::vector_slice vsy (vy, ublas::slice (2, 2, 4)); print_v (vsy, "vy[2:2:4]"); // v[1:2:4] <- 10 v[1:2:4] atlas::scal (10.0, vs); print_v (v, "v[1:2:4] <- 10 v[1:2:4]"); // vs^T vs cout << "v[1:2:4] v[1:2:4] = " << atlas::dot (vs, vs) << endl; // vy[2:2:4] <- 0.01 v[1:2:4] + vy[2:2:4] atlas::axpy (0.01, vs, vsy); print_v (vy, "vy[2:2:4] <- 0.01 v[1:2:4] + vy[2:2:4]"); cout << endl; //////////////////////////////////////////// // ranges & slices // v -- new init init_v (v, times_plus (0.1, 0.1)); print_v (v, "v"); // vy <- 1.0 atlas::set (1., vy); print_v (vy, "vy <- 1.0"); // vy[2:2:4] <- 0.01 v[2..6] + vy[2:2:4] atlas::axpy (0.01, vr, vsy); print_v (vy, "vy[2:2:4] <- 0.01 v[2..6] + vy[2:2:4]"); // vy <- 1.0 atlas::set (1., vy); print_v (vy, "vy <- 1.0"); // vy[4..8] <- 0.01 v[1:2:4] + vy[4..8] atlas::axpy (0.01, vs, vry); print_v (vy, "vy[4..8] <- 0.01 v[1:2:4] + vy[4..8]"); // vr^T vs == vs^T vr cout << "v[2..6] v[1:2:4] = " << atlas::dot (vr, vs) << " == " << atlas::dot (vs, vr) << endl; // vr^T vsy == vsy^T vr cout << "v[2..6] vy[2:2:4] = " << atlas::dot (vr, vsy) << " == " << atlas::dot (vsy, vr) << endl; cout << endl; /////////////////// // slice of range // v -- new init init_v (v, times_plus (0.1, 0.1)); print_v (v, "v"); // v[1..9][1:2:3] ublas::vector_range vr1 (v, ublas::range (1, 9)); ublas::vector_slice< ublas::vector_range > vsr (vr1, ublas::slice (1, 2, 3)); print_v (vr1, "v[1..9]"); print_v (vsr, "v[1..9][1:2:3]"); // v[1..9][1:2:3] <- 0.1 v[1..9][1:2:3] atlas::scal (0.1, vsr); print_v (v, "0.1 v[1..9][1:2:3]"); // ||vsr||_2 cout << "||v[1..9][1:2:3]||_2 = " << atlas::nrm2 (vsr) << endl; cout << endl; /////////////////// // range of slice // vy <- 1.0 init_v (vy, kpp (1)); print_v (vy, "vy"); // v[0:2:5][1:4] ublas::vector_slice vsy1 (vy, ublas::slice (0, 2, 5)); ublas::vector_range< ublas::vector_slice > vrs (vsy1, ublas::range (1, 4)); print_v (vsy1, "v[0:2:5]"); print_v (vrs, "v[0:2:5][1:4]"); // v[0:2:5][1:4] <- 0.01 v[1..9][1:2:3] + v[0:2:5][1:4] atlas::axpy (0.01, vsr, vrs); print_v (vy, "0.01 v[1..9][1:2:3] + v[0:2:5][1:4]"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_potri.cc0000644000175000017500000001144410776013426023753 0ustar andreasandreas // inverting symmetric/hermitian positive definite // factor (potrf()) and invert (potri()) // #define BOOST_UBLAS_STRICT_HERMITIAN // .. doesn't work (yet?) //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; #ifndef F_ROW_MAJOR typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #else typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #endif #ifndef F_UPPER typedef ublas::symmetric_adaptor symm_t; typedef ublas::hermitian_adaptor herm_t; #else typedef ublas::symmetric_adaptor symm_t; typedef ublas::hermitian_adaptor herm_t; #endif int main() { cout << endl; cout << "real symmetric\n" << endl; size_t n = 3; m_t a (n, n); // matrix (storage) symm_t sa (a); // symmetric adaptor #ifdef F_UPPER init_symm (sa, 'u'); #else init_symm (sa, 'l'); #endif // ifdef F_UPPER // [5 4 3 2 1] // [0 5 4 3 2] // a = [0 0 5 4 3] // [0 0 0 5 4] // [0 0 0 0 n] // else // [5 0 0 0 0] // [4 5 0 0 0] // a = [3 4 5 0 0] // [2 3 4 5 0] // [1 2 3 4 5] print_m (sa, "A"); cout << endl; m_t a2 (sa); // full symmetric copy of sa: // .. sa is `lost' after potrf(); // .. only one parameter of symm() is symmetric matrix int ierr = atlas::potrf (sa); if (!ierr) { atlas::potri (sa); // ri should be (almost) identity matrix: m_t ri (n, n); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS atlas::symm (a2, sa, ri); #else atlas::symm (CblasRight, 1.0, sa, a2, 0.0, ri); #endif print_m (ri, "I = A * A^(-1)"); cout << endl; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS atlas::symm (sa, a2, ri); #else atlas::symm (CblasLeft, 1.0, sa, a2, 0.0, ri); #endif print_m (ri, "I = A^(-1) * A"); cout << endl; } cout << "\n===========================\n" << endl; cout << "complex hermitian (almost ;o)\n" << endl; // hermitian cm_t ca (3, 3); herm_t ha (ca); #ifndef F_UPPER ha (0, 0) = cmplx_t (3, 0); ha (1, 0) = cmplx_t (2, 0); ha (1, 1) = cmplx_t (3, 0); ha (2, 0) = cmplx_t (1, 0); ha (2, 1) = cmplx_t (2, 0); ha (2, 2) = cmplx_t (3, 0); #else ha (0, 0) = cmplx_t (3, 0); ha (0, 1) = cmplx_t (2, 0); ha (0, 2) = cmplx_t (1, 0); ha (1, 1) = cmplx_t (3, 0); ha (1, 2) = cmplx_t (2, 0); ha (2, 2) = cmplx_t (3, 0); #endif print_m (ha, "A"); cout << endl; cm_t ca2 (ha); // full hermitian ierr = atlas::cholesky_factor (ha); // potrf() if (ierr == 0) { atlas::cholesky_invert (ha); // potri() cm_t ic (3, 3); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS atlas::hemm (ca2, ha, ic); #else atlas::hemm (CblasRight, 1.0, ha, ca2, 0.0, ic); #endif print_m (ic, "I = A * A^(-1)"); cout << endl; } else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; #ifndef F_UPPER ha (0, 0) = cmplx_t (25, 0); ha (1, 0) = cmplx_t (-5, 5); ha (1, 1) = cmplx_t (51, 0); ha (2, 0) = cmplx_t (10, -5); ha (2, 1) = cmplx_t (4, 6); ha (2, 2) = cmplx_t (71, 0); #else ha (0, 0) = cmplx_t (25, 0); ha (0, 1) = cmplx_t (-5, -5); ha (0, 2) = cmplx_t (10, 5); ha (1, 1) = cmplx_t (51, 0); ha (1, 2) = cmplx_t (4, -6); ha (2, 2) = cmplx_t (71, 0); #endif print_m (ha, "A"); cout << endl; ca2 = ha; ierr = atlas::potrf (ha); if (ierr == 0) { atlas::potri (ha); cm_t ic (3, 3); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS atlas::hemm (ca2, ha, ic); #else atlas::hemm (CblasRight, 1.0, ha, ca2, 0.0, ic); #endif print_m (ic, "I = A * A^(-1)"); cout << endl; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS atlas::hemm (ha, ca2, ic); #else atlas::hemm (CblasLeft, 1.0, ha, ca2, 0.0, ic); #endif print_m (ic, "I = A^(-1) * A"); cout << endl; } else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/Jamfile0000644000175000017500000001046310776160766022425 0ustar andreasandreassubproject libs/numeric/bindings/atlas ; ATLAS_INCLUDE = /usr/local/lib/ATLAS/include ; ATLAS_PATH = /usr/lib ; ATLAS_LIB = lapack_atlas cblas atlas g2c ; exe init : init.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe others : others.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; # exe tnt2 # : tnt2.cc # : $(BOOST_ROOT) # $(B_ROOT) # $(ATLAS_INCLUDE) # $(ATLAS_PATH) # $(ATLAS_LIB) # ; # exe tnt3 # : tnt3.cc # : $(BOOST_ROOT) # $(B_ROOT) # $(ATLAS_INCLUDE) # $(ATLAS_PATH) # $(ATLAS_LIB) # ; exe ublas_cmatr2 : ublas_cmatr2.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_cmatr3 : ublas_cmatr3.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_cvct : ublas_cvct.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_gesv : ublas_gesv.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_gesv2 : ublas_gesv2.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_getrf_getrs : ublas_getrf_getrs.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; # exe ublas_getri # : ublas_getri.cc # : $(BOOST_ROOT) # $(B_ROOT) # $(ATLAS_INCLUDE) # $(ATLAS_PATH) # $(ATLAS_LIB) # ; exe ublas_matr1 : ublas_matr1.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_matr2 : ublas_matr2.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_matr22 : ublas_matr22.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_matr3 : ublas_matr3.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_posv : ublas_posv.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_potrf_potrs : ublas_potrf_potrs.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; # exe ublas_potri # : ublas_potri.cc # : $(BOOST_ROOT) # $(B_ROOT) # $(ATLAS_INCLUDE) # $(ATLAS_PATH) # $(ATLAS_LIB) # ; exe ublas_symm2 : ublas_symm2.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_symm3 : ublas_symm3.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; exe ublas_vct : ublas_vct.cc : $(BOOST_ROOT) $(B_ROOT) $(ATLAS_INCLUDE) $(ATLAS_PATH) $(ATLAS_LIB) ; boost-bindings/libs/numeric/bindings/atlas/tnt2.cc0000644000175000017500000000246010776013426022315 0ustar andreasandreas // BLAS level 2 // TNT arrays #include #include #include #include #include "utils.h" #include "tnt_utils.h" namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; #ifndef F_FORTRAN typedef TNT::Array1D vct_t; typedef TNT::Array2D matr_t; #else typedef TNT::Fortran_Array1D vct_t; typedef TNT::Fortran_Array2D matr_t; #endif int main() { cout << endl; vct_t vx (2); atlas::set (1., vx); print_v (vx, "vx"); vct_t vy (3); atlas::set (0., vy); print_v (vy, "vy"); cout << endl; matr_t m (3, 2); init_m (m, kpp (1)); print_m (m, "m"); cout << endl; atlas::gemv (CblasNoTrans, 1.0, m, vx, 0.0, vy); print_v (vy, "m vx"); atlas::gemv (m, vx, vy); print_v (vy, "m vx"); cout << endl; atlas::set (0, vx); atlas::set (1, vy); atlas::gemv (CblasTrans, 1.0, m, vy, 0.0, vx); print_v (vx, "m^T vy"); cout << endl; atlas::set (1, vy); atlas::gemv (CblasNoTrans, 1.0, m, vx, 1.0, vy); print_v (vy, "vy + m vx"); cout << endl; atlas::set (1, vy); atlas::gemv (CblasNoTrans, 2.0, m, vx, 0.5, vy); print_v (vy, "0.5 vy + 2.0 m vx"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/tnt_utils.h0000644000175000017500000000260610776013426023317 0ustar andreasandreas #ifndef F_TNT_UTILS_H #define F_TNT_UTILS_H #include "utils.h" template struct vct_access_traits > { typedef T& ref_t; typedef TNT::Fortran_Array1D v_t; static ref_t elem (v_t& v, size_t i) { return v (i + 1); } }; template struct vct_access_traits const> { typedef T ref_t; typedef TNT::Fortran_Array1D v_t; static ref_t elem (v_t const& v, size_t i) { return v (i + 1); } }; template struct matr_access_traits > { typedef T& ref_t; typedef TNT::Array2D m_t; static ref_t elem (m_t& m, size_t i, size_t j) { #ifndef BOOST_MSVC return m[i][j]; #else return static_cast (m)[i][j]; #endif } }; template struct matr_access_traits const> { typedef T ref_t; typedef TNT::Array2D m_t; static ref_t elem (m_t const& m, size_t i, size_t j) { return m[i][j]; } }; template struct matr_access_traits > { typedef T& ref_t; typedef TNT::Fortran_Array2D m_t; static ref_t elem (m_t& m, size_t i, size_t j) { return m (i + 1, j + 1); } }; template struct matr_access_traits const> { typedef T ref_t; typedef TNT::Fortran_Array2D m_t; static ref_t elem (m_t const& m, size_t i, size_t j) { return m (i + 1, j + 1); } }; #endif boost-bindings/libs/numeric/bindings/atlas/ublas_gesv.cc0000644000175000017500000000650010776160766023571 0ustar andreasandreas // solving A * X = B // using driver function gesv() //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; typedef std::complex cmpx; #ifndef F_ROW_MAJOR typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #else typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #endif int main() { cout << endl; cout << "real system:" << endl << endl; size_t n = 5; m_t a (n, n); // system matrix size_t nrhs = 2; m_t x (n, nrhs); // b -- right-hand side matrix: // .. see leading comments for `gesv()' in clapack.hpp #ifndef F_ROW_MAJOR m_t b (n, nrhs); #else m_t b (nrhs, n); #endif std::vector ipiv (n); // pivot vector init_symm (a); // [n n-1 n-2 ... 1] // [n-1 n n-1 ... 2] // a = [n-2 n-1 n ... 3] // [ ... ] // [1 2 ... n-1 n] m_t aa (a); // copy of a, because a is `lost' after gesv() ublas::matrix_column xc0 (x, 0), xc1 (x, 1); atlas::set (1., xc0); // x[.,0] = 1 atlas::set (2., xc1); // x[.,1] = 2 #ifndef F_ROW_MAJOR atlas::gemm (a, x, b); // b = a x, so we know the result ;o) #else // see leading comments for `gesv()' in clapack.hpp ublas::matrix_row br0 (b, 0), br1 (b, 1); atlas::gemv (a, xc0, br0); // b[0,.] = a x[.,0] atlas::gemv (a, xc1, br1); // b[1,.] = a x[.,1] => b^T = a x #endif print_m (a, "A"); cout << endl; print_m (b, "B"); cout << endl; atlas::gesv (a, ipiv, b); // solving the system, b contains x print_m (b, "X"); cout << endl; #ifndef F_ROW_MAJOR atlas::gemm (aa, b, x); // check the solution #else atlas::gemv (aa, br0, xc0); atlas::gemv (aa, br1, xc1); #endif print_m (x, "B = A X"); cout << endl; //////////////////////////////////////////////////////// cout << endl; cout << "complex system:" << endl << endl; cm_t ca (3, 3); cm_t cx (3, 1); #ifndef F_ROW_MAJOR cm_t cb (3, 1); #else cm_t cb (1, 3); #endif ca (0, 0) = cmpx (3, 0); ca (0, 1) = cmpx (4, 2); ca (0, 2) = cmpx (-7, 5); ca (1, 0) = cmpx (4, -2); ca (1, 1) = cmpx (-5, 0); ca (1, 2) = cmpx (0, -3); ca (2, 0) = cmpx (-7, -5); ca (2, 1) = cmpx (0, 3); ca (2, 2) = cmpx (2, 0); print_m (ca, "CA"); cout << endl; cm_t caa (ca); ublas::matrix_column cx0 (cx, 0); atlas::set (cmpx (1, -1), cx0); #ifndef F_ROW_MAJOR ublas::matrix_column cb0 (cb, 0); #else ublas::matrix_row cb0 (cb, 0); #endif atlas::gemv (ca, cx0, cb0); print_m (cb, "CB"); cout << endl; int ierr = atlas::gesv (ca, cb); // with `internal' pivot vector if (ierr == 0) { print_m (cb, "CX"); cout << endl; atlas::gemv (caa, cb0, cx0); print_m (cx, "CB"); } else cout << "matrix is singular" << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_symm3.cc0000644000175000017500000000554610776013426023674 0ustar andreasandreas // BLAS level 3 // symmetric matrix #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::symmetric_adaptor ucsymm_t; typedef ublas::symmetric_adaptor lcsymm_t; typedef ublas::symmetric_adaptor ursymm_t; typedef ublas::symmetric_adaptor lrsymm_t; int main() { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS cout << endl; size_t n; cout << "n -> "; cin >> n; cout << endl; cm_t uc (n, n); ucsymm_t ucs (uc); cm_t lc (n, n); lcsymm_t lcs (lc); rm_t ur (n, n); ursymm_t urs (ur); rm_t lr (n, n); lrsymm_t lrs (lr); init_symm (ucs, 'u'); init_symm (lcs, 'l'); init_symm (urs, 'u'); init_symm (lrs, 'l'); print_m (ucs, "a == ucs"); cout << endl; print_m_data (ucs, "ucs"); cout << endl; print_m (lcs, "a == lcs"); cout << endl; print_m_data (lcs, "lcs"); cout << endl; print_m (urs, "a == urs"); cout << endl; print_m_data (urs, "urs"); cout << endl; print_m (lrs, "a == lrs"); cout << endl; print_m_data (lrs, "lrs"); cout << endl; cm_t cbl (n, n+1); rm_t rbl (n, n+1); cm_t ccl (n, n+1); rm_t rcl (n, n+1); init_m (cbl, rws1()); init_m (rbl, rws1()); print_m (cbl, "b == cb"); cout << endl; print_m (rbl, "b == rb"); cout << endl; atlas::symm (ucs, cbl, ccl); print_m (ccl, "c = a b"); cout << endl; atlas::symm (lcs, cbl, ccl); print_m (ccl, "c = a b"); cout << endl; atlas::symm (urs, rbl, rcl); print_m (rcl, "c = a b"); cout << endl; atlas::symm (lrs, rbl, rcl); print_m (rcl, "c = a b"); cout << endl; cm_t cbr (n+1, n); rm_t rbr (n+1, n); cm_t ccr (n+1, n); rm_t rcr (n+1, n); init_m (cbr, cls1()); init_m (rbr, cls1()); print_m (cbr, "b == cb"); cout << endl; print_m (rbr, "b == rb"); cout << endl; atlas::symm (cbr, ucs, ccr); print_m (ccr, "c = b a"); cout << endl; atlas::symm (cbr, lcs, ccr); print_m (ccr, "c = b a"); cout << endl; atlas::symm (rbr, urs, rcr); print_m (rcr, "c = b a"); cout << endl; atlas::symm (rbr, lrs, rcr); print_m (rcr, "c = b a"); cout << endl; cout << endl; #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS cout << "requires proper traits classes :o(" << endl; #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS } boost-bindings/libs/numeric/bindings/atlas/ublas_getri.cc0000644000175000017500000000472710776013426023736 0ustar andreasandreas // inverting A // using getrf() & getri() //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; typedef std::complex cmpx; #ifndef F_ROW_MAJOR typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #else typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #endif int main() { cout << endl; cout << "real matrix:" << endl << endl; size_t n = 5; m_t a (n, n); init_symm (a); // [n n-1 n-2 ... 1] // [n-1 n n-1 ... 2] // a = [n-2 n-1 n ... 3] // [ ... ] // [1 2 ... n-1 n] print_m (a, "A"); cout << endl; m_t aa (a); // copy of a, for later use std::vector ipiv (n); // pivot vector atlas::lu_factor (a, ipiv); // alias for getrf() atlas::lu_invert (a, ipiv); // alias for getri() m_t i1 (n, n), i2 (n, n); atlas::gemm (a, aa, i1); // i1 should be (almost) identity matrix atlas::gemm (aa, a, i2); // i2 should be (almost) identity matrix print_m (i1, "I = A^(-1) * A"); cout << endl; print_m (i2, "I = A * A^(-1)"); cout << endl; cout << endl; ////////////////////////////////////////////////////// cout << "complex matrix:" << endl << endl; cm_t ca (3, 3); ca (0, 0) = cmpx (3, 0); ca (0, 1) = cmpx (4, 2); ca (0, 2) = cmpx (-7, 5); ca (1, 0) = cmpx (4, -2); ca (1, 1) = cmpx (-5, 0); ca (1, 2) = cmpx (0, -3); ca (2, 0) = cmpx (-7, -5); ca (2, 1) = cmpx (0, 3); ca (2, 2) = cmpx (2, 0); print_m (ca, "CA"); cout << endl; cm_t caa (ca); std::vector ipiv2 (3); int ierr = atlas::getrf (ca, ipiv2); if (ierr == 0) { atlas::getri (ca, ipiv2); cm_t ii (3, 3); atlas::gemm (ca, caa, ii); print_m (ii, "I = CA^(-1) * CA"); cout << endl; atlas::gemm (caa, ca, ii); print_m (ii, "I = CA * CA^(-1)"); cout << endl; } else cout << "matrix is singular" << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/others.cc0000644000175000017500000000444210776160766022746 0ustar andreasandreas // BLAS level 1 // std::vector<>, std::valarray<>, boost::array<>, C array // element type: float or double #ifdef F_FLOAT typedef float real_t; #else typedef double real_t; #endif #include #include #include #include #include #include #include #include #include #include "utils.h" namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; using std::size_t; int main() { int n = 10; cout << endl; cout << "std::vector" << endl; std::vector sv (n); init_v (sv, kpp (1)); print_v (sv, "sv"); cout << "std::valarray" << endl; std::valarray va (n); atlas::set (0.1, va); print_v (va, "va"); cout << endl; cout << "dot(): sv^t va: "; real_t d = 0; for (int i = 0; i < n; ++i) d += sv[i] * va[i]; cout << "is " << d << " == " << atlas::dot (sv, va) << " ?" << endl; cout << endl; #ifdef F_FLOAT cout << "sdsdot(): 10 + sv^T va = " << atlas::sdsdot (10, sv, va) << endl; cout << endl; #endif atlas::scal (2, sv); print_v (sv, "scal(): 2 sv"); cout << endl; std::random_shuffle (sv.begin(), sv.end()); cout << "shuffled sv: "; std::copy (sv.begin(), sv.end(), std::ostream_iterator (cout, " ")); cout << endl; int i = atlas::iamax (sv); cout << "iamax():\n index of max el = " << i << "; max el = " << sv[i] << endl; cout << endl; cout << "asum():\n ||sv||_1 = " << atlas::asum (sv) << "; ||va||_1 = " << atlas::asum (va) << endl; cout << "nrm2():\n ||sv||_2 = " << atlas::nrm2 (sv) << "; ||va||_2 = " << atlas::nrm2 (va) << endl; cout << endl; cout << "boost::array" << endl; boost::array ba; atlas::set (0.1, ba); print_v (ba, "ba"); cout << "C array" << endl; typedef double double_array[10]; double_array ca; atlas::set (1., ca); print_v (ca, "ca"); cout << endl; atlas::axpy (0.1, ba, ca); print_v (ca, "axpy(): 0.1 ba + ca"); atlas::axpby (0.1, ba, 2., ca); print_v (ca, "axpby(): 0.1 ba + 2.0 ca"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_potrf_potrs.cc0000644000175000017500000001165710776160766025217 0ustar andreasandreas // solving A * X = B // A symmetric/hermitian positive definite // factor (potrf()) and solve (potrs()) // #define BOOST_UBLAS_STRICT_HERMITIAN // .. doesn't work (yet?) //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; typedef std::complex cmplx_t; #ifndef F_ROW_MAJOR typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #else typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #endif #ifndef F_UPPER typedef ublas::symmetric_adaptor symm_t; typedef ublas::hermitian_adaptor herm_t; #else typedef ublas::symmetric_adaptor symm_t; typedef ublas::hermitian_adaptor herm_t; #endif int main() { // for more descriptive comments see ublas_posv.cc cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n = 5; m_t a (n, n); symm_t sa (a); #ifdef F_UPPER init_symm (sa, 'u'); #else init_symm (sa, 'l'); #endif print_m (sa, "sa"); cout << endl; size_t nrhs = 2; m_t x (n, nrhs); #ifndef F_ROW_MAJOR m_t b (n, nrhs); #else m_t b (nrhs, n); #endif ublas::matrix_column xc0 (x, 0), xc1 (x, 1); atlas::set (1., xc0); atlas::set (2., xc1); #ifndef F_ROW_MAJOR #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS atlas::symm (sa, x, b); #else atlas::symm (CblasLeft, 1.0, sa, x, 0.0, b); #endif #else ublas::matrix_row br0 (b, 0), br1 (b, 1); atlas::symv (sa, xc0, br0); atlas::symv (sa, xc1, br1); #endif print_m (b, "b"); cout << endl; int ierr = atlas::cholesky_factor (sa); // potrf() if (!ierr) { atlas::cholesky_substitute (sa, b); // potrs() print_m (b, "x"); } cout << endl; ///////////////////////////////////////////////////////// // hermitian cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; cm_t ca (3, 3); herm_t ha (ca); cm_t cx (3, 1); #ifndef F_ROW_MAJOR cm_t cb (3, 1); #else cm_t cb (1, 3); #endif #ifndef F_UPPER ha (0, 0) = cmplx_t (3, 0); ha (1, 0) = cmplx_t (4, -2); ha (1, 1) = cmplx_t (5, 0); ha (2, 0) = cmplx_t (-7, -5); ha (2, 1) = cmplx_t (0, 3); ha (2, 2) = cmplx_t (2, 0); #else ha (0, 0) = cmplx_t (3, 0); ha (0, 1) = cmplx_t (4, 2); ha (0, 2) = cmplx_t (-7, 5); ha (1, 1) = cmplx_t (5, 0); ha (1, 2) = cmplx_t (0, -3); ha (2, 2) = cmplx_t (2, 0); #endif print_m (ha, "ha"); cout << endl; ublas::matrix_column cx0 (cx, 0); atlas::set (cmplx_t (1, -1), cx0); print_m (cx, "cx"); cout << endl; #ifndef F_ROW_MAJOR ublas::matrix_column cb0 (cb, 0); #else ublas::matrix_row cb0 (cb, 0); #endif atlas::hemv (ha, cx0, cb0); print_m (cb, "cb"); cout << endl; ierr = atlas::potrf (ha); if (ierr == 0) { atlas::potrs (ha, cb); print_m (cb, "cx"); } else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; #ifndef F_UPPER ha (0, 0) = cmplx_t (25, 0); ha (1, 0) = cmplx_t (-5, 5); ha (1, 1) = cmplx_t (51, 0); ha (2, 0) = cmplx_t (10, -5); ha (2, 1) = cmplx_t (4, 6); ha (2, 2) = cmplx_t (71, 0); #else ha (0, 0) = cmplx_t (25, 0); ha (0, 1) = cmplx_t (-5, -5); ha (0, 2) = cmplx_t (10, 5); ha (1, 1) = cmplx_t (51, 0); ha (1, 2) = cmplx_t (4, -6); ha (2, 2) = cmplx_t (71, 0); #endif print_m (ha, "ha"); cout << endl; #ifndef F_ROW_MAJOR cm_t cb32 (3, 2); cb32 (0, 0) = cmplx_t (60, -55); cb32 (1, 0) = cmplx_t (34, 58); cb32 (2, 0) = cmplx_t (13, -152); cb32 (0, 1) = cmplx_t (70, 10); cb32 (1, 1) = cmplx_t (-51, 110); cb32 (2, 1) = cmplx_t (75, 63); #else cm_t cb32 (2, 3); cb32 (0, 0) = cmplx_t (60, -55); cb32 (0, 1) = cmplx_t (34, 58); cb32 (0, 2) = cmplx_t (13, -152); cb32 (1, 0) = cmplx_t (70, 10); cb32 (1, 1) = cmplx_t (-51, 110); cb32 (1, 2) = cmplx_t (75, 63); #endif print_m (cb32, "cb"); cout << endl; ierr = atlas::potrf (ha); if (ierr == 0) { atlas::potrs (ha, cb32); print_m (cb32, "cx"); } else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_symm3syrk.cc0000644000175000017500000000447310776013426024603 0ustar andreasandreas // BLAS level 3 // symmetric matrices, syrk #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::symmetric_adaptor ucsa_t; typedef ublas::symmetric_adaptor lcsa_t; typedef ublas::symmetric_adaptor ursa_t; typedef ublas::symmetric_adaptor lrsa_t; int main() { int n, k; cout << "n -> "; cin >> n; cout << "k -> "; cin >> k; cm_t ac (n, k); rm_t ar (n, k); init_m (ac, rws1()); init_m (ar, rws1()); print_m (ac, "ac"); cout << endl; print_m (ar, "ar"); cout << endl << endl; cm_t cmu (n, n); cm_t cml (n, n); rm_t rmu (n, n); rm_t rml (n, n); ucsa_t ucsa (cmu); lcsa_t lcsa (cml); ursa_t ursa (rmu); lrsa_t lrsa (rml); atlas::syrk (CblasNoTrans, ac, ucsa); atlas::syrk (CblasNoTrans, 1.0, ac, 0.0, lcsa); atlas::syrk (CblasNoTrans, 1.0, ar, 0.0, ursa); atlas::syrk (CblasNoTrans, ar, lrsa); print_m (ucsa, "ucsa"); cout << endl; print_m (lcsa, "lcsa"); cout << endl; print_m (ursa, "ursa"); cout << endl; print_m (lrsa, "lrsa"); cout << endl << endl; // part 2 cm_t act (k, n); rm_t art (k, n); init_m (act, cls1()); init_m (art, cls1()); print_m (act, "act"); cout << endl; print_m (art, "art"); cout << endl << endl; init_m (cmu, const_val (0)); init_m (cml, const_val (0)); init_m (rmu, const_val (0)); init_m (rml, const_val (0)); atlas::syrk (CblasUpper, CblasTrans, 1.0, act, 0.0, cmu); atlas::syrk (CblasLower, CblasTrans, 1.0, act, 0.0, cml); atlas::syrk (CblasUpper, CblasTrans, 1.0, art, 0.0, rmu); atlas::syrk (CblasLower, CblasTrans, 1.0, art, 0.0, rml); print_m (cmu, "cmu"); cout << endl; print_m (cml, "cml"); cout << endl; print_m (rmu, "rmu"); cout << endl; print_m (rml, "rml"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_matr2ger.cc0000644000175000017500000000472510776013426024345 0ustar andreasandreas // BLAS level 2 //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; typedef ublas::vector vct_t; typedef ublas::matrix rm_t; typedef ublas::matrix cm_t; int main() { cout << endl; vct_t vx (2); vct_t vy (4); // row major matrix rm_t rm (2, 4); init_m (rm, const_val (0)); print_m (rm, "row major matrix m"); cout << endl; vx(0) = 1.; vy(1) = 1.; print_v (vx, "vx"); cout << endl; print_v (vy, "vy"); cout << endl; // m += x y^T atlas::ger (vx, vy, rm); print_m (rm, "m += x y^T"); cout << endl << endl; init_m (rm, const_val (1)); print_m (rm, "m"); cout << endl; atlas::set (1., vx); atlas::set (1., vy); print_v (vx, "vx"); cout << endl; print_v (vy, "vy"); cout << endl; // m += 2 x y^T atlas::ger (2., vx, vy, rm); print_m (rm, "m += 2 x y^T"); cout << endl << endl; init_v (vx, iplus1()); init_v (vy, iplus1()); print_v (vx, "vx"); cout << endl; print_v (vy, "vy"); cout << endl; // m += x y^T atlas::ger (vx, vy, rm); print_m (rm, "m += x y^T"); cout << endl << endl; // column major matrix cm_t cm (2, 4); init_m (cm, const_val (0)); print_m (cm, "column major matrix m"); cout << endl; vx(0) = 1.; vy(1) = 1.; print_v (vx, "vx"); cout << endl; print_v (vy, "vy"); cout << endl; // m += x y^T atlas::ger (vx, vy, cm); print_m (cm, "m += x y^T"); cout << endl << endl; init_m (cm, const_val (1)); print_m (cm, "m"); cout << endl; atlas::set (1., vx); atlas::set (1., vy); print_v (vx, "vx"); cout << endl; print_v (vy, "vy"); cout << endl; // m += 2 x y^T atlas::ger (2., vx, vy, cm); print_m (cm, "m += 2 x y^T"); cout << endl << endl; init_v (vx, iplus1()); init_v (vy, iplus1()); print_v (vx, "vx"); cout << endl; print_v (vy, "vy"); cout << endl; // m += x y^T atlas::ger (vx, vy, cm); print_m (cm, "m += x y^T"); cout << endl << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_matr2_bench.cc0000644000175000017500000001425110776013426025001 0ustar andreasandreas // BLAS level 2 // benchmarks //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING //#define USE_STD_VECTOR //#define BOUNDED 100*100 //#define PRINT //#define PRINT_M //#define MODIFY #include #include #include #include #include #include #include #include #ifdef USE_STD_VECTOR #include #include #endif #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::cin; using std::endl; typedef double real_t; #ifdef USE_STD_VECTOR typedef std::vector storage_t; #else #ifndef BOUNDED typedef ublas::unbounded_array storage_t; #else typedef ublas::bounded_array storage_t; #endif #endif typedef ublas::vector vct_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::symmetric_adaptor ucsa_t; typedef ublas::symmetric_adaptor lcsa_t; typedef ublas::symmetric_adaptor ursa_t; typedef ublas::symmetric_adaptor lrsa_t; typedef ublas::symmetric_matrix< real_t, ublas::upper, ublas::column_major > ucsymm_t; typedef ublas::symmetric_matrix< real_t, ublas::lower, ublas::column_major > lcsymm_t; typedef ublas::symmetric_matrix< real_t, ublas::upper, ublas::row_major > ursymm_t; typedef ublas::symmetric_matrix< real_t, ublas::lower, ublas::row_major > lrsymm_t; #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS using ublas::prod; #endif //////////////////////////////////////////////////// // general matrix: gemv() template void bench_gemv (size_t n, size_t runs, char* msg) { cout << msg << endl; vct_t x (n); atlas::set (1., x); vct_t y (n); M a (n, n); init_symm (a); #ifdef PRINT_M print_m (a, "a"); cout << endl; #endif boost::timer (t); t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY a (0, 2) = r; a (2, 0) = r; #endif atlas::gemv (a, x, y); #ifdef PRINT print_v (y, "y"); #endif } cout << " gemv: " << t.elapsed() << endl; t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY a (0, 2) = r; a (2, 0) = r; #endif atlas::gemv (CblasTrans, 1., a, x, 0., y); #ifdef PRINT print_v (y, "y"); #endif } cout << " gemv trans: " << t.elapsed() << endl; t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY a (0, 2) = r; a (2, 0) = r; #endif y = prod (a, x); #ifdef PRINT print_v (y, "y"); #endif } cout << " = prod: " << t.elapsed() << endl; t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY a (0, 2) = r; a (2, 0) = r; #endif y.assign (prod (a, x)); #ifdef PRINT print_v (y, "y"); #endif } cout << " assign prod: " << t.elapsed() << endl; cout << endl; } ///////////////////////////////////////////////////////// // symmetric adaptor: symv() template void bench_symv (size_t n, size_t runs, char* msg) { cout << msg << endl; vct_t x (n); atlas::set (1., x); vct_t y (n); M a (n, n); SA sa (a); init_symm (sa, 'l'); #ifdef PRINT_M print_m (sa, "sa"); cout << endl; print_m (a, "a"); cout << endl; #endif boost::timer (t); t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY sa (0, 2) = r; #endif atlas::symv (sa, x, y); #ifdef PRINT print_v (y, "y"); #endif } cout << " symv: " << t.elapsed() << endl; t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY sa (0, 2) = r; #endif y = prod (sa, x); #ifdef PRINT print_v (y, "y"); #endif } cout << " = prod: " << t.elapsed() << endl; t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY sa (0, 2) = r; #endif y.assign (prod (sa, x)); #ifdef PRINT print_v (y, "y"); #endif } cout << " assign prod: " << t.elapsed() << endl; cout << endl; } ///////////////////////////////////////////////////////// // symmetric matrix: spmv() template void bench_spmv (size_t n, size_t runs, char* msg) { cout << msg << endl; vct_t x (n); atlas::set (1., x); vct_t y (n); SM sa (n, n); init_symm (sa, 'l'); #ifdef PRINT_M cout << sa << endl; cout << endl; #endif boost::timer (t); t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY sa (0, 2) = r; #endif atlas::spmv (sa, x, y); #ifdef PRINT print_v (y, "y"); #endif } cout << " spmv: " << t.elapsed() << endl; t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY sa (0, 2) = r; #endif y = prod (sa, x); #ifdef PRINT print_v (y, "y"); #endif } cout << " = prod: " << t.elapsed() << endl; t.restart(); for (size_t r = 0; r < runs; ++r) { #ifdef MODIFY sa (0, 2) = r; #endif y.assign (prod (sa, x)); #ifdef PRINT print_v (y, "y"); #endif } cout << " assign prod: " << t.elapsed() << endl; cout << endl; } ////////////////////////////////////////////////////// int main() { cout << endl; size_t n, r; cout << "n -> "; cin >> n; cout << "r -> "; cin >> r; cout << endl; bench_gemv (n, r, "row major"); bench_gemv (n, r, "column major"); bench_symv (n, r, "symmetric ad, row, upper"); bench_symv (n, r, "symmetric ad, row, lower"); bench_symv (n, r, "symmetric ad, column, upper"); bench_symv (n, r, "symmetric ad, column, lower"); bench_spmv (n, r, "symmetric, row, upper"); bench_spmv (n, r, "symmetric, row, lower"); bench_spmv (n, r, "symmetric, column, upper"); bench_spmv (n, r, "symmetric, column, lower"); } boost-bindings/libs/numeric/bindings/atlas/ublas_matr1.cc0000644000175000017500000001027610776160766023656 0ustar andreasandreas // BLAS level 1 (matrix rows and columns) //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include "utils.h" namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; namespace ublas = boost::numeric::ublas; using std::cout; using std::endl; using std::size_t; typedef ublas::vector vct_t; typedef ublas::matrix matr_t; typedef ublas::matrix_row mr_t; typedef ublas::matrix_column mc_t; typedef ublas::matrix_range mrng_t; typedef ublas::matrix_slice msl_t; typedef ublas::matrix_slice cmsl_t; int main() { cout << endl; int r = 7; int c = 8; matr_t m (r, c); init_m (m, times_plus (10, 1, 1)); print_m (m, "m"); cout << endl; vct_t v (10); atlas::set (0., v); print_v (v, "v"); cout << endl; // m[2,.] <- 0.1 m[2,.] mr_t mr2 (m, 2); atlas::scal (0.1, mr2); print_m (m, "0.1 m[2,.]"); cout << endl; // m[2,.] <-> m[4,.] mr_t mr4 (m, 4); atlas::swap (mr2, mr4); print_m (m, "m[2,.] <-> m[4,.]"); cout << endl; // m[4,.] <- m[2,.] atlas::copy (mr2, mr4); print_m (m, "m[4,.] <- m[2,.]"); cout << endl; // v[2..6] <- 10 m[5,.][1..5] mr_t mr5 (m, 5); ublas::vector_range vr (v, ublas::range (2, 6)); ublas::vector_range mr5r (mr5, ublas::range (1, 5)); atlas::axpy (10.0, mr5r, vr); print_v (v, "v[2..6] <- 10 m[5,.][1..5]"); cout << endl; // ||m[.,3]||_1, ||m[.,3]||_2 mc_t mc3 (m, 3); cout << "||m[.,3]||_1 = " << atlas::asum (mc3) << endl; cout << "||m[.,3]||_2 = " << atlas::nrm2 (mc3) << endl; cout << endl; // m[.,5] <- 0.01 m[.,3] + m[.,5] mc_t mc5 (m, 5); atlas::axpy (0.01, mc3, mc5); print_m (m, "m[.,5] <- 0.01 m[.,3] + m[.,5]"); cout << endl; // 0.1 m[.,5][1:2:3] ublas::vector_slice mc5s (mc5, ublas::slice (1, 2, 3)); atlas::scal (0.1, mc5s); print_m (m, "0.1 m[.,5][1:2:3]"); cout << endl; // 0.1 m[4,.][1:2:4][1..3] ublas::vector_slice mr4s (mr4, ublas::slice (1, 2, 4)); ublas::vector_range > mr4sr (mr4s, ublas::range (1, 3)); atlas::scal (0.1, mr4sr); print_m (m, "0.1 m[4,.][1:2:4][1..3]"); cout << endl; // new initialization init_m (m, times_plus (10, 1, 1)); #ifndef F_USE_DETAIL for (int i = 0; i < m.size1(); ++i) { mr_t mri (m, i); atlas::scal (0.1, mri); } #else // cblas level 1 function applied to matrix atlas::detail::scal (traits::matrix_storage_size (m), 0.1, traits::matrix_storage (m), 1); #endif matr_t const cm (m); print_m (cm, "new m, cm == const m"); cout << endl; // m[2..6][1..8] mrng_t mrng (m, ublas::range (2, 6), ublas::range (1, 8)); print_m (mrng, "mrng = m[2..6][1..8]"); cout << endl; // mrng[1,.] <-> mrng[2,.] ublas::matrix_row mrngr1 (mrng, 1); ublas::matrix_row mrngr2 (mrng, 2); atlas::swap (mrngr1, mrngr2); print_m (m, "mrng[1,.] <-> mrng[2,.]"); cout << endl; // mrng[2,.] <-> mrng[1,.] atlas::swap (mrngr2, mrngr1); print_m (m, "mrng[2,.] <-> mrng[1,.]"); cout << endl; // mrng[.,3] <- 0.01 mrng[.,5] + mrng[.,3] ublas::matrix_column mrngc3 (mrng, 3); ublas::matrix_column const mrngc5 (mrng, 5); atlas::axpy (0.01, mrngc5, mrngc3); print_m (m, "mrng[.,3] <- 0.01 mrng[.,5] + mrng[.,3]"); cout << endl; // cm[1:2:3][2:3:2] cmsl_t msl (cm, ublas::slice (1, 2, 3), ublas::slice (2, 3, 2)); print_m (msl, "cmsl = cm[1:2:3][2:3:2]"); cout << endl; // ||cmsl[.,0]||_1 ublas::matrix_column mslc0 (msl, 0); cout << "||cmsl[.,0]||_1 = " << atlas::asum (mslc0) << endl; cout << endl; // mrng[.,3][1..4] <= 0.0001 cmsl[.,0] + mrng[.,3][1..4] ublas::vector_range > vrmrngc3 (mrngc3, ublas::range (1, 4)); atlas::axpy (0.0001, mslc0, vrmrngc3); print_m (m, "mrng[.,3][1..4] <= 0.0001 cmsl[.,0] + mrng[.,3][1..4]"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_matr3.cc0000644000175000017500000000470210776160766023655 0ustar andreasandreas // BLAS level 3 //#define F_USE_STD_VECTOR //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #ifdef F_USE_STD_VECTOR #include #include #endif #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; #ifndef F_USE_STD_VECTOR typedef ublas::matrix m_t; #else typedef ublas::matrix > m_t; #endif int main() { cout << endl; m_t a (4, 4); init_m (a, kpp (1)); print_m (a, "a"); cout << endl; m_t b (4, 6); init_m (b, cls1()); print_m (b, "b"); cout << endl; m_t c (4, 6); // c = a b atlas::gemm (a, b, c); print_m (c, "c = a b"); cout << endl; atlas::gemm (CblasNoTrans, CblasNoTrans, 1.0, a, b, 0.0, c); print_m (c, "c = a b"); cout << endl; init_m (c, const_val (1)); print_m (c, "c"); cout << endl; // c = 2 a b + 0.5 c atlas::gemm (2.0, a, b, 0.05, c); print_m (c, "c = 2 a b + 0.05 c"); cout << endl; m_t d (6, 4); // d = b^T a^T atlas::gemm (CblasTrans, CblasTrans, 1.0, b, a, 0.0, d); print_m (d, "d = b^T a^T"); cout << endl; // c = a^T b atlas::gemm (CblasTrans, CblasNoTrans, 1.0, a, b, 0.0, c); print_m (c, "c = a^T b"); cout << endl; // d = b^T a atlas::gemm (CblasTrans, CblasNoTrans, 1.0, b, a, 0.0, d); print_m (d, "d = b^T a"); cout << endl; init_m (d, const_val (0)); ublas::matrix_range br (b, ublas::range (0, 4), ublas::range (0, 4)); ublas::matrix_range dr (d, ublas::range (1, 5), ublas::range (0, 4)); // d[1..5][0..4] = a b[0..4][0..4] atlas::gemm (a, br, dr); print_m (d, "d[1..5][0..4] = a b[0..4][0..4]"); cout << endl; // d[1..5][0..4] = b[0..4][0..4] a atlas::gemm (br, a, dr); print_m (d, "d[1..5][0..4] = b[0..4][0..4] a"); cout << endl; // d[1..5][0..4] = b[0..4][0..4] a^T atlas::gemm (CblasNoTrans, CblasTrans, 1.0, br, a, 0.0, dr); print_m (d, "d[1..5][0..4] = b[0..4][0..4] a^T"); cout << endl; // d[1..5][0..4] = a b[0..4][0..4]^T atlas::gemm (CblasNoTrans, CblasTrans, 1.0, a, br, 0.0, dr); print_m (d, "d[1..5][0..4] = a b[0..4][0..4]^T"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_cmatr2ger.cc0000644000175000017500000000454010776013426024503 0ustar andreasandreas // BLAS level 2 -- complex numbers //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #ifdef F_USE_STD_VECTOR #include #include #endif #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; #ifndef F_USE_STD_VECTOR typedef ublas::vector vct_t; typedef ublas::matrix m_t; #else typedef ublas::vector > vct_t; typedef ublas::matrix > m_t; #endif int main() { cout << endl; vct_t vx (2); vct_t vy (4); // vector size can be larger // than corresponding matrix size atlas::set (cmplx_t (1., 0.), vx); atlas::set (cmplx_t (0., 2.), vy); print_v (vx, "vx"); cout << endl; print_v (vy, "vy"); cout << endl; m_t m (2, 3); init_m (m, const_val()); print_m (m, "m"); cout << endl; // m += x y^T atlas::ger (vx, vy, m); // bindings extension print_m (m, "m += x y^T"); cout << endl << endl; init_m (m, const_val()); print_m (m, "m"); cout << endl; // m += x y^T atlas::geru (vx, vy, m); print_m (m, "m += x y^T"); cout << endl << endl; m (0, 0) = cmplx_t (0., 1.); m (0, 1) = cmplx_t (0., 2.); m (0, 2) = cmplx_t (0., 3.); m (1, 0) = cmplx_t (0., 4.); m (1, 1) = cmplx_t (0., 5.); m (1, 2) = cmplx_t (0., 6.); print_m (m, "m"); cout << endl; // m += 2 x y^T atlas::geru (cmplx_t (2., 0.), vx, vy, m); print_m (m, "m += 2 x y^T"); cout << endl << endl; m (0, 0) = cmplx_t (-1., 1.); m (0, 1) = cmplx_t (-2., 2.); m (0, 2) = cmplx_t (-3., 3.); m (1, 0) = cmplx_t (-4., 4.); m (1, 1) = cmplx_t (-5., 5.); m (1, 2) = cmplx_t (-6., 6.); print_m (m, "m"); cout << endl; // m += x y^H atlas::gerc (cmplx_t (1., 0.), vx, vy, m); // bindings extension print_m (m, "m += x y^H"); cout << endl << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_gesv2.cc0000644000175000017500000000345010776160766023654 0ustar andreasandreas // solving A * X = B // using driver function gesv() //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; #ifndef F_ROW_MAJOR typedef ublas::matrix m_t; #else typedef ublas::matrix m_t; #endif int main() { cout << endl; size_t n = 5; m_t a (n, n); // system matrix size_t nrhs = 2; m_t x (n, nrhs), bb (n, nrhs); // b -- right-hand side matrix, see below init_symm (a); // [n n-1 n-2 ... 1] // [n-1 n n-1 ... 2] // a = [n-2 n-1 n ... 3] // [ ... ] // [1 2 ... n-1 n] m_t const aa (a); // copy of a, because a is `lost' after gesv() ublas::matrix_column xc0 (x, 0), xc1 (x, 1); atlas::set (1., xc0); atlas::set (2., xc1); atlas::gemm (a, x, bb); // bb = a x, so we know the result ;o) print_m (a, "A"); cout << endl; print_m (bb, "B"); cout << endl; // see leading comments for `gesv()' in clapack.hpp #ifndef F_ROW_MAJOR m_t b (bb); #else m_t b (ublas::trans (bb)); #endif print_m (b, "B for gesv()"); cout << endl; atlas::gesv (a, b); // solving the system, b contains x #ifndef F_ROW_MAJOR print_m (b, "X"); cout << endl; atlas::gemm (aa, b, x); #else print_m (b, "X^T"); cout << endl; atlas::gemm (CblasNoTrans, CblasTrans, 1.0, aa, b, 0.0, x); #endif print_m (x, "B = A X"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_posv.cc0000644000175000017500000001436010776160766023617 0ustar andreasandreas // solving A * X = B // A symmetric/hermitian positive definite // driver function posv() // #define BOOST_UBLAS_STRICT_HERMITIAN // .. doesn't work (yet?) //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; typedef std::complex cmplx_t; #ifndef F_ROW_MAJOR typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #else typedef ublas::matrix m_t; typedef ublas::matrix cm_t; #endif #ifndef F_UPPER typedef ublas::symmetric_adaptor symm_t; typedef ublas::hermitian_adaptor herm_t; #else typedef ublas::symmetric_adaptor symm_t; typedef ublas::hermitian_adaptor herm_t; #endif int main() { cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n = 5; m_t a (n, n); // matrix (storage) symm_t sa (a); // symmetric adaptor #ifdef F_UPPER init_symm (sa, 'u'); #else init_symm (sa, 'l'); #endif // ifdef F_UPPER // [5 4 3 2 1] // [0 5 4 3 2] // a = [0 0 5 4 3] // [0 0 0 5 4] // [0 0 0 0 n] // else // [5 0 0 0 0] // [4 5 0 0 0] // a = [3 4 5 0 0] // [2 3 4 5 0] // [1 2 3 4 5] print_m (sa, "sa"); cout << endl; print_m (a, "a"); cout << endl; print_m_data (sa, "sa"); cout << endl; size_t nrhs = 2; m_t x (n, nrhs); // b -- right-hand side matrix: // .. see leading comments for `gesv()' in clapack.hpp #ifndef F_ROW_MAJOR m_t b (n, nrhs); #else m_t b (nrhs, n); #endif ublas::matrix_column xc0 (x, 0), xc1 (x, 1); atlas::set (1., xc0); // x[.,0] = 1 atlas::set (2., xc1); // x[.,1] = 2 #ifndef F_ROW_MAJOR #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS atlas::symm (sa, x, b); // b = a x, so we know the result ;o) #else atlas::symm (CblasLeft, 1.0, sa, x, 0.0, b); #endif #else // see leading comments for `gesv()' in clapack.hpp ublas::matrix_row br0 (b, 0), br1 (b, 1); atlas::symv (sa, xc0, br0); // b[0,.] = a x[.,0] atlas::symv (sa, xc1, br1); // b[1,.] = a x[.,1] => b^T = a x #endif print_m (b, "b"); cout << endl; atlas::cholesky_solve (sa, b); // same as posv() print_m (b, "x"); cout << endl; ////////////////////////////////////////////////////////// // hermitian cout << "\n===========================\n" << endl; cout << "complex hermitian (well, not really)\n" << endl; cm_t ca (3, 3); // matrix (storage) herm_t ha (ca); // hermitian adaptor cm_t cx (3, 1); #ifndef F_ROW_MAJOR cm_t cb (3, 1); #else cm_t cb (1, 3); #endif #ifdef F_UPPER init_symm (ha, 'u'); #else init_symm (ha, 'l'); #endif print_m (ha, "ha"); cout << endl; print_m (ca, "ca"); cout << endl; print_m_data (ha, "ha"); cout << endl; ublas::matrix_column cx0 (cx, 0); atlas::set (cmplx_t (1, -1), cx0); print_m (cx, "cx"); cout << endl; #ifndef F_ROW_MAJOR ublas::matrix_column cb0 (cb, 0); #else ublas::matrix_row cb0 (cb, 0); #endif atlas::hemv (ha, cx0, cb0); print_m (cb, "cb"); cout << endl; int ierr = atlas::posv (ha, cb); if (ierr == 0) print_m (cb, "cx"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; // regular (see ublas_gesv.cc), but not positive definite: #ifndef F_UPPER ha (0, 0) = cmplx_t (3, 0); ha (1, 0) = cmplx_t (4, -2); ha (1, 1) = cmplx_t (5, 0); ha (2, 0) = cmplx_t (-7, -5); ha (2, 1) = cmplx_t (0, 3); ha (2, 2) = cmplx_t (2, 0); #else ha (0, 0) = cmplx_t (3, 0); ha (0, 1) = cmplx_t (4, 2); ha (0, 2) = cmplx_t (-7, 5); ha (1, 1) = cmplx_t (5, 0); ha (1, 2) = cmplx_t (0, -3); ha (2, 2) = cmplx_t (2, 0); #endif print_m (ha, "ha"); cout << endl; print_m (ca, "ca"); cout << endl; print_m_data (ha, "ha"); cout << endl; atlas::set (cmplx_t (1, 1), cx0); print_m (cx, "cx"); cout << endl; atlas::hemv (ha, cx0, cb0); print_m (cb, "cb"); cout << endl; ierr = atlas::cholesky_solve (ha, cb); if (ierr == 0) print_m (cb, "cx"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; // positive definite: #ifndef F_UPPER ha (0, 0) = cmplx_t (25, 0); ha (1, 0) = cmplx_t (-5, 5); ha (1, 1) = cmplx_t (51, 0); ha (2, 0) = cmplx_t (10, -5); ha (2, 1) = cmplx_t (4, 6); ha (2, 2) = cmplx_t (71, 0); #else ha (0, 0) = cmplx_t (25, 0); ha (0, 1) = cmplx_t (-5, -5); ha (0, 2) = cmplx_t (10, 5); ha (1, 1) = cmplx_t (51, 0); ha (1, 2) = cmplx_t (4, -6); ha (2, 2) = cmplx_t (71, 0); #endif print_m (ha, "ha"); cout << endl; #ifndef F_ROW_MAJOR cm_t cb32 (3, 2); cb32 (0, 0) = cmplx_t (60, -55); cb32 (1, 0) = cmplx_t (34, 58); cb32 (2, 0) = cmplx_t (13, -152); cb32 (0, 1) = cmplx_t (70, 10); cb32 (1, 1) = cmplx_t (-51, 110); cb32 (2, 1) = cmplx_t (75, 63); #else cm_t cb32 (2, 3); cb32 (0, 0) = cmplx_t (60, -55); cb32 (0, 1) = cmplx_t (34, 58); cb32 (0, 2) = cmplx_t (13, -152); cb32 (1, 0) = cmplx_t (70, 10); cb32 (1, 1) = cmplx_t (-51, 110); cb32 (1, 2) = cmplx_t (75, 63); #endif print_m (cb32, "cb"); cout << endl; ierr = atlas::posv (ha, cb32); if (ierr == 0) print_m (cb32, "cx"); else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_herm3herk.cc0000644000175000017500000000551410776013426024507 0ustar andreasandreas // BLAS level 3 // hermitian matrices, herk #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::hermitian_adaptor ucha_t; typedef ublas::hermitian_adaptor lcha_t; typedef ublas::hermitian_adaptor urha_t; typedef ublas::hermitian_adaptor lrha_t; #define N 3 #define K 4 int main() { cm_t ac (N, K); rm_t ar (N, K); ac(0,0) = ar(0,0) = cmplx_t (1., 1.); ac(1,0) = ar(1,0) = cmplx_t (2., 1.); ac(2,0) = ar(2,0) = cmplx_t (3., 1.); #if (K > 1) ac(0,1) = ar(0,1) = cmplx_t (1., 1.); ac(1,1) = ar(1,1) = cmplx_t (2., 1.); ac(2,1) = ar(2,1) = cmplx_t (3., 1.); #if (K > 2) ac(0,2) = ar(0,2) = cmplx_t (1., 1.); ac(1,2) = ar(1,2) = cmplx_t (2., 1.); ac(2,2) = ar(2,2) = cmplx_t (3., 1.); #if (K > 3) ac(0,3) = ar(0,3) = cmplx_t (1., 1.); ac(1,3) = ar(1,3) = cmplx_t (2., 1.); ac(2,3) = ar(2,3) = cmplx_t (3., 1.); #endif #endif #endif print_m (ac, "ac"); cout << endl; print_m (ar, "ar"); cout << endl << endl; cm_t cmu (N, N); cm_t cml (N, N); rm_t rmu (N, N); rm_t rml (N, N); ucha_t ucha (cmu); lcha_t lcha (cml); urha_t urha (rmu); lrha_t lrha (rml); atlas::herk (CblasNoTrans, ac, ucha); atlas::herk (CblasNoTrans, 1.0, ac, 0.0, lcha); atlas::herk (CblasNoTrans, 1.0, ar, 0.0, urha); atlas::herk (CblasNoTrans, ar, lrha); print_m (ucha, "ucha"); cout << endl; print_m (lcha, "lcha"); cout << endl; print_m (urha, "urha"); cout << endl; print_m (lrha, "lrha"); cout << endl << endl; // part 2 cm_t act (ublas::herm (ac)); rm_t art (ublas::herm (ar)); print_m (act, "act"); cout << endl; print_m (art, "art"); cout << endl << endl; init_m (cmu, const_val (cmplx_t (0, 0))); init_m (cml, const_val (cmplx_t (0, 0))); init_m (rmu, const_val (cmplx_t (0, 0))); init_m (rml, const_val (cmplx_t (0, 0))); atlas::herk (CblasUpper, CblasConjTrans, 1.0, act, 0.0, cmu); atlas::herk (CblasLower, CblasConjTrans, 1.0, act, 0.0, cml); atlas::herk (CblasUpper, CblasConjTrans, 1.0, art, 0.0, rmu); atlas::herk (CblasLower, CblasConjTrans, 1.0, art, 0.0, rml); print_m (cmu, "cmu"); cout << endl; print_m (cml, "cml"); cout << endl; print_m (rmu, "rmu"); cout << endl; print_m (rml, "rml"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_cmatr2.cc0000644000175000017500000000651310776160766024021 0ustar andreasandreas // BLAS level 2 -- complex numbers //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #ifdef F_USE_STD_VECTOR #include #include #endif #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; #ifndef F_USE_STD_VECTOR typedef ublas::vector vct_t; typedef ublas::matrix m_t; #else typedef ublas::vector > vct_t; typedef ublas::matrix > m_t; #endif int main() { cout << endl; vct_t vx (2); atlas::set (cmplx_t (1., 0.), vx); print_v (vx, "vx"); vct_t vy (4); // vector size can be larger // than corresponding matrix size atlas::set (cmplx_t (0., 0.), vy); print_v (vy, "vy"); cout << endl; m_t m (3, 2); init_m (m, kpp (1)); print_m (m, "m"); cout << endl; // vy = m vx atlas::gemv (CblasNoTrans, 1.0, m, vx, 0.0, vy); print_v (vy, "m vx"); atlas::gemv (m, vx, vy); print_v (vy, "m vx"); cout << endl; m (0, 0) = cmplx_t (0., 1.); m (0, 1) = cmplx_t (0., 2.); m (1, 0) = cmplx_t (0., 3.); m (1, 1) = cmplx_t (0., 4.); m (2, 0) = cmplx_t (0., 5.); m (2, 1) = cmplx_t (0., 6.); print_m (m, "m"); cout << endl; // vy = m vx atlas::gemv (CblasNoTrans, 1.0, m, vx, 0.0, vy); print_v (vy, "m vx"); atlas::gemv (m, vx, vy); print_v (vy, "m vx"); cout << endl; m (0, 0) = cmplx_t (-1., 1.); m (0, 1) = cmplx_t (-2., 2.); m (1, 0) = cmplx_t (-3., 3.); m (1, 1) = cmplx_t (-4., 4.); m (2, 0) = cmplx_t (-5., 5.); m (2, 1) = cmplx_t (-6., 6.); print_m (m, "m"); cout << endl; // vy = m vx atlas::gemv (CblasNoTrans, 1.0, m, vx, 0.0, vy); print_v (vy, "m vx"); atlas::gemv (m, vx, vy); print_v (vy, "m vx"); cout << endl; atlas::set (cmplx_t (0., 1.), vx); print_v (vx, "vx"); // vy = m vx atlas::gemv (CblasNoTrans, 1.0, m, vx, 0.0, vy); print_v (vy, "m vx"); atlas::gemv (m, vx, vy); print_v (vy, "m vx"); cout << endl; atlas::set (cmplx_t (1., 1.), vx); print_v (vx, "vx"); // vy = m vx atlas::gemv (CblasNoTrans, 1.0, m, vx, 0.0, vy); print_v (vy, "m vx"); atlas::gemv (m, vx, vy); print_v (vy, "m vx"); cout << endl; // vx = m^H vy atlas::set (cmplx_t (-1., -1.), vy); print_v (vy, "vy"); atlas::gemv (CblasConjTrans, 1.0, m, vy, 0.0, vx); print_v (vx, "m^H vy"); cout << endl; m_t mx (2, 2); m_t my (3, 2); ublas::matrix_column mxc0 (mx, 0), mxc1 (mx, 1); ublas::matrix_column myc0 (my, 0), myc1 (my, 1); atlas::set (cmplx_t (1., 0.), mxc0); atlas::set (cmplx_t (0., 0.), mxc1); atlas::set (cmplx_t (0., 0.), myc0); atlas::set (cmplx_t (0., 0.), myc1); print_m (mx, "mx"); cout << endl; print_m (my, "my"); cout << endl; // my[.,0] = m mx[.,0] atlas::gemv (m, mxc0, myc0); print_m (my, "m mx[.,0]"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_gesv4.cc0000644000175000017500000000235110776013426023643 0ustar andreasandreas // solving A * X = B // using driver function gesv() // with ublas::vector<> as RHS //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING //#define BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK //#define BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; typedef ublas::matrix m_t; typedef ublas::vector v_t; int main() { cout << endl; size_t n = 3; m_t a (n, n); // system matrix a(0,0) = 1.; a(0,1) = 1.; a(0,2) = 1.; a(1,0) = 2.; a(1,1) = 3.; a(1,2) = 1.; a(2,0) = 1.; a(2,1) = -1.; a(2,2) = -1.; v_t b (n); // right-hand side vector b(0) = 4.; b(1) = 9.; b(2) = -2.; cout << "A: " << a << endl; cout << "B: " << b << endl; atlas::lu_solve (a, b); cout << "X: " << b << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_symm32.cc0000644000175000017500000000563310776013426023753 0ustar andreasandreas // BLAS level 3 // symmetric matrix (with adaptor) //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace traits = boost::numeric::bindings::traits; using std::cout; using std::cin; using std::endl; typedef double real_t; typedef ublas::matrix cm_t; typedef ublas::matrix rm_t; typedef ublas::symmetric_adaptor ucsymm_t; typedef ublas::symmetric_adaptor lcsymm_t; typedef ublas::symmetric_adaptor ursymm_t; typedef ublas::symmetric_adaptor lrsymm_t; int main() { cout << endl; size_t n; cout << "n -> "; cin >> n; cout << endl; cm_t uc (n, n); ucsymm_t ucs (uc); cm_t lc (n, n); lcsymm_t lcs (lc); rm_t ur (n, n); ursymm_t urs (ur); rm_t lr (n, n); lrsymm_t lrs (lr); init_symm (ucs, 'u'); init_symm (lcs, 'l'); init_symm (urs, 'u'); init_symm (lrs, 'l'); print_m (ucs, "a == ucs"); cout << endl; print_m_data (ucs, "ucs"); cout << endl; print_m (lcs, "a == lcs"); cout << endl; print_m_data (lcs, "lcs"); cout << endl; print_m (urs, "a == urs"); cout << endl; print_m_data (urs, "urs"); cout << endl; print_m (lrs, "a == lrs"); cout << endl; print_m_data (lrs, "lrs"); cout << endl; cm_t cbl (n, n+1); rm_t rbl (n, n+1); cm_t ccl (n, n+1); rm_t rcl (n, n+1); init_m (cbl, rws1()); init_m (rbl, rws1()); print_m (cbl, "b == cb"); cout << endl; print_m (rbl, "b == rb"); cout << endl; atlas::symm (CblasLeft, 1., ucs, cbl, 0., ccl); print_m (ccl, "c = a b"); cout << endl; atlas::symm (CblasLeft, 1., lcs, cbl, 0., ccl); print_m (ccl, "c = a b"); cout << endl; atlas::symm (CblasLeft, 1., urs, rbl, 0., rcl); print_m (rcl, "c = a b"); cout << endl; atlas::symm (CblasLeft, 1., lrs, rbl, 0., rcl); print_m (rcl, "c = a b"); cout << endl; cm_t cbr (n+1, n); rm_t rbr (n+1, n); cm_t ccr (n+1, n); rm_t rcr (n+1, n); init_m (cbr, cls1()); init_m (rbr, cls1()); print_m (cbr, "b == cb"); cout << endl; print_m (rbr, "b == rb"); cout << endl; atlas::symm (CblasRight, 1., ucs, cbr, 0., ccr); print_m (ccr, "c = b a"); cout << endl; atlas::symm (CblasRight, 1., lcs, cbr, 0., ccr); print_m (ccr, "c = b a"); cout << endl; atlas::symm (CblasRight, 1., urs, rbr, 0., rcr); print_m (rcr, "c = b a"); cout << endl; atlas::symm (CblasRight, 1., lrs, rbr, 0., rcr); print_m (rcr, "c = b a"); cout << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/ublas_cvct.cc0000644000175000017500000000425010776013426023552 0ustar andreasandreas // BLAS level 1 (vector) -- complex numbers #include #include #include //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include "utils.h" namespace atlas = boost::numeric::bindings::atlas; namespace ublas = boost::numeric::ublas; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::vector vct_t; #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS using ublas::inner_prod; using ublas::norm_2; using ublas::conj; #endif int main() { int n = 6; cout << endl; vct_t v (n); init_v (v, times_plus (cmplx_t (1, -1), cmplx_t (0, .1))); print_v (v, "v"); atlas::scal (2.0, v); print_v (v, "2.0 v"); atlas::scal (cmplx_t (-1, 0), v); print_v (v, "(-1, 0) v"); atlas::scal (cmplx_t (0, 1), v); print_v (v, "(0, 1) v"); atlas::set (cmplx_t (1, -1), v); print_v (v, "v"); vct_t v1 (n); atlas::set (cmplx_t (0, -1), v1); print_v (v1, "v1"); cout << endl; cout << "v^T v1 = " << atlas::dot (v, v1) << " == " << atlas::dotu (v, v1) << " == " << inner_prod (v, v1) << endl; cout << "v^T v = " << atlas::dot (v, v) << " == " << atlas::dotu (v, v) << " == " << inner_prod (v, v) << endl; cout << "v1^T v1 = " << atlas::dot (v1, v1) << " == " << atlas::dotu (v1, v1) << " == " << inner_prod (v1, v1) << endl; cout << endl; cout << "v^H v1 = " << atlas::dotc (v, v1) << " == " << inner_prod (conj (v), v1) << " == " << inner_prod (v1, conj (v)) << " != " << inner_prod (v, conj (v1)) << endl; cout << "v^H v = " << atlas::dotc (v, v) << " == " << inner_prod (conj (v), v) << " == " << inner_prod (v, conj (v)) << endl; cout << "v1^H v1 = " << atlas::dotc (v1, v1) << " == " << inner_prod (conj (v1), v1) << " == " << inner_prod (v1, conj (v1)) << endl; cout << endl; cout << "||v||_1 = " << atlas::asum (v) << endl; cout << "||v||_2 = " << atlas::nrm2 (v) << " == " << norm_2 (v) << endl; cout << endl; } boost-bindings/libs/numeric/bindings/atlas/tnt3.cc0000644000175000017500000000261310776013426022316 0ustar andreasandreas // BLAS level 3 // TNT arrays #include #include #include #include "utils.h" #include "tnt_utils.h" namespace atlas = boost::numeric::bindings::atlas; using std::cout; using std::endl; #ifndef F_FORTRAN typedef TNT::Array2D m_t; #else typedef TNT::Fortran_Array2D m_t; #endif int main() { cout << endl; m_t a (2, 2); init_m (a, kpp (1)); print_m (a, "A"); cout << endl; m_t b (2, 3); init_m (b, cls1()); print_m (b, "B"); cout << endl; m_t c (2, 3); init_m > (c); print_m (c, "C"); cout << endl; atlas::gemm (a, b, c); print_m (c, "A B"); cout << endl; atlas::gemm (CblasNoTrans, CblasNoTrans, 1.0, a, b, 0.0, c); print_m (c, "A B"); cout << endl; atlas::gemm (1.0, a, b, 0.0, c); print_m (c, "A B"); cout << endl; init_m (c, const_val (1.)); print_m (c, "C"); cout << endl; atlas::gemm (1.0, a, b, 0.05, c); print_m (c, "0.05 C + A B"); cout << endl; m_t d (3, 2); atlas::gemm (CblasTrans, CblasTrans, 1.0, b, a, 0.0, d); print_m (d, "B^T A^T"); cout << endl; atlas::gemm (CblasTrans, CblasNoTrans, 1.0, a, b, 0.0, c); print_m (c, "A^T B"); cout << endl; atlas::gemm (CblasTrans, CblasNoTrans, 1.0, b, a, 0.0, d); print_m (d, "B^T A"); cout << endl; } boost-bindings/libs/numeric/bindings/atlas/tnt_gesv.cc0000644000175000017500000000265110776013426023261 0ustar andreasandreas // solving A * X = B // using driver function gesv() //#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS //#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #ifndef F_FORTRAN # include #else # include #endif namespace atlas = boost::numeric::bindings::atlas; using std::size_t; using std::cout; using std::endl; #ifndef F_FORTRAN typedef TNT::Array2D m_t; #else typedef TNT::Fortran_Array2D m_t; #endif int main() { cout << endl; size_t n = 3, nrhs = 1; m_t a (n, n); // system matrix #ifndef F_FORTRAN a[0][0] = 1.; a[0][1] = 1.; a[0][2] = 1.; a[1][0] = 2.; a[1][1] = 3.; a[1][2] = 1.; a[2][0] = 1.; a[2][1] = -1.; a[2][2] = -1.; #else a(1,1) = 1.; a(1,2) = 1.; a(1,3) = 1.; a(2,1) = 2.; a(2,2) = 3.; a(2,3) = 1.; a(3,1) = 1.; a(3,2) = -1.; a(3,3) = -1.; #endif // see leading comments for `gesv()' in clapack.hpp #ifndef F_FORTRAN m_t b (nrhs, n); // right-hand side matrix b[0][0] = 4.; b[0][1] = 9.; b[0][2] = -2.; #else m_t b (n, nrhs); b(1,1) = 4.; b(2,1) = 9.; b(3,1) = -2.; #endif cout << "A: " << a << endl; cout << "B: " << b << endl; atlas::lu_solve (a, b); cout << "X: " << b << endl; cout << endl; } boost-bindings/libs/numeric/bindings/blas/0000755000175000017500000000000010776160766020744 5ustar andreasandreasboost-bindings/libs/numeric/bindings/blas/test/0000755000175000017500000000000010776160766021723 5ustar andreasandreasboost-bindings/libs/numeric/bindings/blas/test/blas1.cpp0000644000175000017500000003237010776013426023424 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen #include "random.hpp" #include #include #include #include #include #include #include #include #include #include #include // Randomize a vector (using functions from random.hpp) template void randomize(V& v) { for (typename V::size_type i=0; i() ; } // randomize() float abs_sum_value( float const& f ) { using namespace std ; return abs(f) ; } double abs_sum_value( double const& f ) { using namespace std ; return abs(f) ; } float abs_sum_value( std::complex< float > const& f ) { using namespace std ; return abs(f.real()) + abs(f.imag()) ; } double abs_sum_value( std::complex< double > const& f ) { using namespace std ; return abs(f.real()) + abs(f.imag()) ; } template typename boost::numeric::bindings::traits::type_traits::real_type abs_sum( V const& v) { typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; real_type sum( 0.0 ) ; for ( typename V::size_type i=0; i struct OneVector { boost::numeric::ublas::vector v_ref_ ; // Initialize : set reference vector (ublas) OneVector() : v_ref_( 10 ) { randomize(v_ref_); } template int operator()(V& v) const { using namespace boost::numeric::bindings::blas ; typedef typename V::value_type value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; // Copy vector from reference for (typename V::size_type i=0; i std::numeric_limits< real_type >::epsilon() * norm_2(v_ref_)) { std::cout << "nrm2 : " << std::abs(nrm - norm_2(v_ref_)) << " > " << std::numeric_limits< real_type >::epsilon() * norm_2(v_ref_) << std::endl ; return 255 ; } nrm = asum( v ); if ( std::abs(nrm - abs_sum(v_ref_)) > std::numeric_limits< real_type >::epsilon() * abs_sum(v_ref_)) { std::cout << "asum : " << std::abs(nrm - abs_sum(v_ref_)) << " > " << std::numeric_limits< real_type >::epsilon() * abs_sum(v_ref_) << std::endl ; return 255 ; } scal( value_type(2.0), v ); for (typename V::size_type i=0; i real_type(2.0)*std::abs(v_ref_(i))) return 255 ; return 0; } // Return the size of a vector. size_t size() const {return v_ref_.size();} }; // Operations with two vectors. template struct BaseTwoVectorOperations { typedef T value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef boost::numeric::ublas::vector ref_vector_type ; // Initialize: select the first vector and set the reference vectors (ublas) BaseTwoVectorOperations(V& v, const ref_vector_type& v1_ref, const ref_vector_type& v2_ref) : v_( v ) , v1_ref_( v1_ref ) , v2_ref_( v2_ref ) {} // Copy the 2nd reference vector into w. template void copy_vector(W& w) const { for (size_t i=0; i struct TwoVectorOperations { } ; template struct TwoVectorOperations< float, V> : BaseTwoVectorOperations { typedef typename V::value_type value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef typename BaseTwoVectorOperations::ref_vector_type ref_vector_type ; TwoVectorOperations(V& v, const ref_vector_type& v1_ref, const ref_vector_type& v2_ref) : BaseTwoVectorOperations( v, v1_ref, v2_ref ) {} // Perform the tests of blas functions and compare with reference template int operator()(W& w) const { using namespace boost::numeric::bindings::blas ; copy_vector(w); // Test blas routines value_type prod = dot( this->v_, w ); if ( std::abs(prod - inner_prod( this->v1_ref_, this->v2_ref_ )) > std::numeric_limits< real_type >::epsilon() * std::abs(prod)) return 255 ; axpy( value_type(2.0), this->v_, w ); for (size_t i=0; isize(); ++i) if ( std::abs(w[i] - (this->v2_ref_(i) + value_type(2.0)*this->v1_ref_(i))) > std::numeric_limits< real_type >::epsilon() * std::abs(w[i])) return 255 ; scal( value_type(0.0), w ) ; copy( this->v_, w ) ; for (size_t i=0; isize(); ++i) { if ( std::abs( w[i] - this->v_[i] ) != 0.0 ) return 255 ; } return 0; } }; template struct TwoVectorOperations< double, V> : BaseTwoVectorOperations { typedef typename V::value_type value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef typename BaseTwoVectorOperations::ref_vector_type ref_vector_type ; TwoVectorOperations(V& v, const ref_vector_type& v1_ref, const ref_vector_type& v2_ref) : BaseTwoVectorOperations( v, v1_ref, v2_ref ) {} // Perform the tests of blas functions and compare with reference template int operator()(W& w) const { using namespace boost::numeric::bindings::blas ; copy_vector( w ); // Test blas routines value_type prod = dot( this->v_, w ); if ( std::abs(prod - inner_prod( this->v1_ref_, this->v2_ref_ )) > std::numeric_limits< real_type >::epsilon() * std::abs(prod)) return 255 ; axpy( value_type(2.0), this->v_, w ); for (size_t i=0; isize(); ++i) if ( std::abs(w[i] - (this->v2_ref_(i) + value_type(2.0)*this->v1_ref_(i))) > std::numeric_limits< real_type >::epsilon() * std::abs(w[i])) return 255 ; copy_vector( w ) ; scal( value_type(-1.0), w ) ; ::boost::numeric::bindings::blas::copy( this->v_, w ) ; for (size_t i=0; isize(); ++i) { if ( w[i] != this->v_[i] ) return 255 ; } return 0; } }; template struct TwoVectorOperations< std::complex, V> : BaseTwoVectorOperations< std::complex, V> { typedef typename V::value_type value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef typename BaseTwoVectorOperations,V>::ref_vector_type ref_vector_type ; TwoVectorOperations(V& v, const ref_vector_type& v1_ref, const ref_vector_type& v2_ref) : BaseTwoVectorOperations< std::complex, V>( v, v1_ref, v2_ref ) {} // Perform the tests of blas functions and compare with reference template int operator()(W& w) const { using namespace boost::numeric::bindings::blas ; copy_vector( w ); // Test blas routines value_type prod = dotc( this->v_, w ); if ( std::abs(prod - inner_prod( conj(this->v1_ref_), this->v2_ref_ )) > std::numeric_limits< real_type >::epsilon() * std::abs(prod)) return 255 ; prod = dotu( this->v_, w ); if ( std::abs(prod - inner_prod( this->v1_ref_, this->v2_ref_ )) > std::numeric_limits< real_type >::epsilon() * std::abs(prod)) return 255 ; axpy( value_type(2.0), this->v_, w ); for (size_t i=0; isize(); ++i) if ( std::abs(w[i] - (this->v2_ref_(i) + value_type(2.0)*this->v1_ref_(i))) > std::numeric_limits< real_type >::epsilon() * std::abs(w[i])) return 255 ; scal( value_type(0.0), w ) ; copy( this->v_, w ) ; for (size_t i=0; isize(); ++i) { if ( std::abs( w[i] - this->v_[i] ) != 0.0 ) return 255 ; } return 0; } }; template struct TwoVectorOperations< std::complex, V> : BaseTwoVectorOperations< std::complex, V> { typedef typename V::value_type value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef typename BaseTwoVectorOperations,V>::ref_vector_type ref_vector_type ; TwoVectorOperations(V& v, const ref_vector_type& v1_ref, const ref_vector_type& v2_ref) : BaseTwoVectorOperations< std::complex, V>( v, v1_ref, v2_ref ) {} // Perform the tests of blas functions and compare with reference template int operator()(W& w) const { using namespace boost::numeric::bindings::blas ; copy_vector( w ); // Test blas routines value_type prod = dotc( this->v_, w ); if ( std::abs(prod - inner_prod( conj(this->v1_ref_), this->v2_ref_ )) > std::numeric_limits< real_type >::epsilon() * std::abs(prod)) return 255 ; prod = dotu( this->v_, w ); if ( std::abs(prod - inner_prod( this->v1_ref_, this->v2_ref_ )) > std::numeric_limits< real_type >::epsilon() * std::abs(prod)) return 255 ; axpy( value_type(2.0), this->v_, w ); for (size_t i=0; isize(); ++i) if ( std::abs(w[i] - (this->v2_ref_(i) + value_type(2.0)*this->v1_ref_(i))) > std::numeric_limits< real_type >::epsilon() * std::abs(w[i])) return 255 ; scal( value_type(0.0), w ) ; copy( this->v_, w ) ; for (size_t i=0; isize(); ++i) { if ( std::abs( w[i] - this->v_[i] ) != 0.0 ) return 255 ; } return 0; } }; // Run the tests for different types of vectors. template int different_vectors(const F& f) { // Do test for different types of vectors { std::cout << " ublas::vector\n" ; boost::numeric::ublas::vector< T > v(f.size()); if (f( v )) return 255 ; } { std::cout << " std::vector\n" ; std::vector v_ref(f.size()); if (f( v_ref )) return 255 ; } { std::cout << " ublas::vector_range\n" ; typedef boost::numeric::ublas::vector< T > vector_type ; vector_type v(f.size()*2); boost::numeric::ublas::vector_range< vector_type > vr(v, boost::numeric::ublas::range(1,1+f.size())); if (f( vr )) return 255 ; } { typedef boost::numeric::ublas::matrix< T, boost::numeric::ublas::column_major > matrix_type ; matrix_type m(f.size(),f.size()) ; std::cout << " ublas::matrix_column\n" ; boost::numeric::ublas::matrix_column< matrix_type > m_c( m, 2 ); if (f( m_c )) return 255 ; std::cout << " ublas::matrix_row\n" ; boost::numeric::ublas::matrix_row< matrix_type > m_r( m, 1 ); if (f( m_r )) return 255 ; } return 0; } // different_vectors() // This is the functor that selects the first vector of the tests that use two vectors. template struct TwoVector { TwoVector() : v1_ref_( 10 ) , v2_ref_( 10 ) {} template int operator() (V& v) const { for (size_t i=0; i >( TwoVectorOperations(v, v1_ref_, v2_ref_) ) ; } size_t size() const { return v1_ref_.size() ; } boost::numeric::ublas::vector v1_ref_ ; boost::numeric::ublas::vector v2_ref_ ; }; // TwoVector // Run the test for a specific value_type T. template int do_value_type() { // Tests for functions with one vector argument. std::cout << " one argument\n"; if (different_vectors >(OneVector ())) return 255 ; // Tests for functions with two vector arguments. std::cout << " two arguments\n"; if (different_vectors >(TwoVector())) return 255; return 0; } // do_value_type() int main() { // Run regression for Real/Complex std::cout << "float\n"; if (do_value_type() ) return 255 ; std::cout << "double\n"; if (do_value_type() ) return 255 ; std::cout << "complex\n"; if (do_value_type >() ) return 255 ; std::cout << "complex\n"; if (do_value_type >() ) return 255 ; std::cout << "Regression test successful\n" ; return 0 ; } boost-bindings/libs/numeric/bindings/blas/test/scal.cpp0000644000175000017500000000072410776013426023342 0ustar andreasandreas#include template < class value_type > void test_scal(int size) { boost::numeric::ublas::vector< value_type > vector( size ) ; // random generate content for the vector } int main() { int max_size = 1000 ; typedef std::complex< double > dcomplex ; for(int size = 1 ; size < max_size ; ++size ) test_scal< double >( size ) ; for(int size = 1 ; size < max_size ; ++size ) test_scal< dcomplex >( size ) ; return 0 ; } boost-bindings/libs/numeric/bindings/blas/test/blas2.cpp0000644000175000017500000001650310776013426023425 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen #include #include #include #include #include #include "blas.hpp" #include #include #include template < typename ValueType, typename MatrixType, typename VectorType > void test_gemv(std::ostream& os, int runs, int runs_i, int size, int size_i, char c, ValueType alpha, ValueType beta, MatrixType &a, VectorType& x, VectorType &y_native, VectorType &y_toblas) { typedef typename VectorType::value_type value_type ; boost::timer t ; if ( c == boost::numeric::bindings::traits::NO_TRANSPOSE ) for(int i = 0 ; i < runs_i ; ++i ) y_native += alpha * numerics::prod( a, x) ; else if ( c == boost::numeric::bindings::traits::TRANSPOSE ) for(int i = 0 ; i < runs_i ; ++i ) y_native += alpha * numerics::prod( trans(a), x) ; else if ( c == boost::numeric::bindings::traits::CONJUGATE ) for(int i = 0 ; i < runs_i ; ++i ) y_native += alpha * numerics::prod( herm(a), x) ; else assert( 0 ) ; report< value_type >( os, runs, runs_i, size_i, t.elapsed() ); t.restart() ; for(int i = 0 ; i < runs_i ; ++i ) boost::numeric::bindings::blas::gemv( c, alpha, a, x, beta, y_toblas ) ; report< value_type >( os, runs, runs_i, size_i, t.elapsed() ); check( y_native.begin(), y_native.end(), y_toblas.begin() ); } struct gemv_matrix_vector_vector { template < typename T > void operator()(std::ostream& os, int size, int size_i, int runs, int runs_i) { runs_i = std::max( 1, runs_i / size_i ) ; T alpha = 1 / ( size_i * 10 ), beta = 1.0 ; random_initialise( alpha ); numerics::matrix< T, numerics::column_major > a(size_i,size_i) ; random_initialise_matrix( a ) ; numerics::vector< T > x( size_i ); random_initialise_vector( x) ; numerics::vector< T > y_native( x ) ; numerics::vector< T > y_toblas( x ) ; test_gemv( os, runs, runs_i, size, size_i, boost::numeric::bindings::traits::NO_TRANSPOSE, alpha, beta, a, x, y_native, y_toblas ); } }; struct gemv_trans_matrix_vector_vector { template < typename T > void operator()(std::ostream& os, int size, int size_i, int runs, int runs_i) { runs_i = std::max( 1, runs_i / size_i ) ; T alpha = 1 / ( size_i * 10 ), beta = 1.0 ; random_initialise( alpha ); numerics::matrix< T, numerics::column_major > a(size_i,size_i) ; random_initialise_matrix( a ) ; numerics::vector< T > x( size_i ); random_initialise_vector( x) ; numerics::vector< T > y_native( x ) ; numerics::vector< T > y_toblas( x ) ; test_gemv( os, runs, runs_i, size, size_i, boost::numeric::bindings::traits::TRANSPOSE, alpha, beta, a, x, y_native, y_toblas ); } }; struct gemv_conj_matrix_vector_vector { template < typename T > void operator()(std::ostream& os, int size, int size_i, int runs, int runs_i) { runs_i = std::max( 1, runs_i / size_i ) ; T alpha = 1 / ( size_i * 10 ), beta = 1.0 ; random_initialise( alpha ); numerics::matrix< T, numerics::column_major > a(size_i,size_i) ; random_initialise_matrix( a ) ; numerics::vector< T > x( size_i ); random_initialise_vector( x) ; numerics::vector< T > y_native( x ) ; numerics::vector< T > y_toblas( x ) ; test_gemv( os, runs, runs_i, size, size_i, boost::numeric::bindings::traits::CONJUGATE, alpha, beta, a, x, y_native, y_toblas ); } }; struct gemv_matrix_range_vector_vector { template < typename T > void operator()(std::ostream& os, int size, int size_i, int runs, int runs_i) { runs_i = std::max( 1, runs_i / size_i ) ; T alpha = 1 / ( size_i * 10 ), beta = 1.0 ; random_initialise( alpha ); numerics::matrix< T, numerics::column_major > a(size_i * 2,size_i * 2) ; random_initialise_matrix( a ) ; int start = size_i / 2 ; int stop = start + size_i ; numerics::matrix_range< numerics::matrix< T, numerics::column_major > > mr( a, numerics::range( start, stop ), numerics::range( start, stop ) ) ; numerics::vector< T > x( size_i ); random_initialise_vector( x) ; numerics::vector< T > y_native( x ) ; numerics::vector< T > y_toblas( x ) ; test_gemv( os, runs, runs_i, size, size_i, boost::numeric::bindings::traits::NO_TRANSPOSE, alpha, beta, mr, x, y_native, y_toblas ); } }; int main (int argc, char *argv []) { int runs = 1 ; // 10000000 ; int stop = 10 ; // 10000 ; switch ( argc ) { case 3: stop = atoi( argv[2] ) ; case 2: runs = atoi( argv[1] ) ; case 1: default: {} } int start = 1 ; int step = 50 ; std::cerr << "\npeak float\n"; peak () ( runs ); std::cerr << "\npeak double\n"; peak () ( runs ); std::cerr << "\nstd:complex\n"; peak > () ( runs ); std::cerr << "\nstd:complex\n"; peak > () ( runs ); if (argc > 1) { int scale = atoi(argv [1]); runs *= scale ; } { { std::cerr << "gemv_matrix_vector_vector_double" << std::endl ; std::ofstream stream("gemv_matrix_vector_vector_double"); loop< double, gemv_matrix_vector_vector >( stream, start, step, stop, runs, gemv_matrix_vector_vector() ) ; } { std::cerr << "gemv_matrix_vector_vector_double_complex" << std::endl ; std::ofstream stream("gemv_matrix_vector_vector_double_complex"); loop< std::complex, gemv_matrix_vector_vector >( stream, start, step, stop, runs, gemv_matrix_vector_vector() ) ; } { std::cerr << "gemv_trans_matrix_vector_vector_double" << std::endl ; std::ofstream stream("gemv_trans_matrix_vector_vector_double"); loop< double, gemv_trans_matrix_vector_vector >( stream, start, step, stop, runs, gemv_trans_matrix_vector_vector() ) ; } { std::cerr << "gemv_trans_matrix_vector_vector_double_complex" << std::endl ; std::ofstream stream("gemv_trans_matrix_vector_vector_double_complex"); loop< std::complex, gemv_trans_matrix_vector_vector >( stream, start, step, stop, runs, gemv_trans_matrix_vector_vector() ) ; } { std::cerr << "gemv_conj_matrix_vector_vector_double_complex" << std::endl ; std::ofstream stream("gemv_conj_matrix_vector_vector_double_complex"); loop< std::complex, gemv_conj_matrix_vector_vector >( stream, start, step, stop, runs, gemv_conj_matrix_vector_vector() ) ; } { std::cerr << "gemv_matrix_range_vector_vector_double" << std::endl ; std::ofstream stream("gemv_matrix_range_vector_vector_double"); loop< double, gemv_matrix_range_vector_vector >( stream, start, step, stop, runs, gemv_matrix_range_vector_vector() ) ; } { std::cerr << "gemv_matrix_range_vector_vector_double_complex" << std::endl ; std::ofstream stream("gemv_matrix_range_vector_vector_double_complex"); loop< std::complex, gemv_matrix_range_vector_vector >( stream, start, step, stop, runs, gemv_matrix_range_vector_vector() ) ; } } return 0 ; } boost-bindings/libs/numeric/bindings/blas/test/blas3.cpp0000644000175000017500000003362010776013426023425 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen #include "random.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Randomize a matrix template void randomize(M& m) { typedef typename M::size_type size_type ; typedef typename M::value_type value_type ; size_type size1 = m.size1() ; size_type size2 = m.size2() ; for (size_type i=0; i() ; } } } // randomize() template struct RealDiagonal { template void operator() (M& m) const {} }; template struct RealDiagonal< std::complex > { template void operator() (M& m) const { for (typename M::size_type i=0; i boost::numeric::ublas::triangular_adaptor unit_upper_part(const M& m) { return boost::numeric::ublas::triangular_adaptor (m); } template boost::numeric::ublas::triangular_adaptor upper_part(const M& m) { return boost::numeric::ublas::triangular_adaptor (m); } template boost::numeric::ublas::triangular_adaptor lower_part(const M& m) { return boost::numeric::ublas::triangular_adaptor (m); } // Run over all matrix types and aply a functor to it. template int do_matrix_types(const F& f) { using namespace boost::numeric::ublas ; typedef typename F::value_type value_type ; { matrix m( f.size1(), f.size2() ); if (f(m)) return 255; } { typedef matrix matrix_type ; matrix_type m( 2*f.size1(), 2*f.size2() ); matrix_range m_r( m, range(1,1+f.size1()), range(2,2+f.size2()) ); if (f(m_r)) return 255 ; } return 0; } // do_matrix_types() // Functor to select syrk/herk calls given the two matrix_types template struct Syrk2 { typedef typename M1::value_type value_type ; typedef boost::numeric::ublas::matrix ref_matrix_type ; typedef typename boost::numeric::bindings::traits::type_traits< value_type >::real_type real_type ; typedef typename ref_matrix_type::size_type size_type ; Syrk2(const M1& a, const ref_matrix_type& a_ref) : a_( a ), a_ref_( a_ref ) , c_ref_( a_ref_.size1(), a_ref_.size1() ) { randomize( c_ref_ ); RealDiagonal() (c_ref_); // Must have real diagonal for herk. } template int operator() (M& c) const { using namespace boost::numeric::ublas ; real_type alpha = 2.0 ; real_type beta = -3.0 ; c.assign( c_ref_ ); boost::numeric::bindings::blas::syrk( 'U', 'N', value_type(alpha), a_, value_type(beta), c ) ; if ( norm_frobenius( upper_part( c - (beta*c_ref_ + alpha * prod( a_ref_, trans( a_ref_ ) ) ) ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( upper_part(c) ) ) return 255; c.assign( c_ref_ ); symmetric_adaptor c_s( c ); boost::numeric::bindings::blas::syrk( 'U', 'N', value_type(alpha), a_, value_type(beta), c_s ) ; if ( norm_frobenius( upper_part( c_s - (beta*c_ref_ + alpha * prod( a_ref_, trans( a_ref_ ) ) ) ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( upper_part(c_s) ) ) return 255; c.assign( c_ref_ ); boost::numeric::bindings::blas::herk( 'U', 'N', alpha, a_, beta, c ) ; if ( norm_frobenius( upper_part( c - (beta*c_ref_ + alpha * prod( a_ref_, herm( a_ref_ ) ) ) ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( upper_part(c) ) ) return 255; c.assign( c_ref_ ); hermitian_adaptor c_h( c ); boost::numeric::bindings::blas::herk( 'U', 'N', alpha, a_, beta, c_h ) ; if ( norm_frobenius( upper_part( c_h - (beta*c_ref_ + alpha * prod( a_ref_, herm( a_ref_ ) ) ) ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( upper_part(c_h) ) ) return 255; return 0; } size_type size1() const {return c_ref_.size1() ;} size_type size2() const {return c_ref_.size2() ;} const M1& a_ ; const ref_matrix_type& a_ref_; ref_matrix_type c_ref_; }; // Syrk2 template struct Syrk1 { typedef T value_type ; typedef boost::numeric::ublas::matrix ref_matrix_type ; typedef typename boost::numeric::bindings::traits::type_traits< value_type >::real_type real_type ; typedef typename ref_matrix_type::size_type size_type ; Syrk1() : a_ref_( 4, 7 ) { randomize( a_ref_ ); } template int operator() (M& a) const { typedef Syrk2 functor_type ; a.assign( a_ref_ ); return do_matrix_types( functor_type(a, a_ref_) ); } size_type size1() const {return a_ref_.size1();} size_type size2() const {return a_ref_.size2();} ref_matrix_type a_ref_; }; // Syrk1 // Functor to select gemm calls given the three matrix_types template struct Gemm3 { typedef typename M1::value_type value_type ; typedef boost::numeric::ublas::matrix ref_matrix_type ; typedef typename boost::numeric::bindings::traits::type_traits< value_type >::real_type real_type ; typedef typename ref_matrix_type::size_type size_type ; Gemm3(const M1& a, const M2& b, const ref_matrix_type& a_ref, const ref_matrix_type& b_ref) : a_( a ), b_( b ) , a_ref_( a_ref ), b_ref_( b_ref ), c_ref_( a_ref_.size1(), b_ref_.size2() ) { randomize( c_ref_ ); } template int operator() (M& c) const { c.assign( c_ref_ ); value_type alpha = 2.0 ; value_type beta = -3.0 ; boost::numeric::bindings::blas::gemm( 'N', 'N', alpha, a_, b_, beta, c ) ; if ( norm_frobenius( c - (beta*c_ref_ + alpha * prod( a_ref_, b_ref_ ) ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( c ) ) return 255; return 0; } size_type size1() const {return c_ref_.size1() ;} size_type size2() const {return c_ref_.size2() ;} const M1& a_ ; const M2& b_ ; const ref_matrix_type& a_ref_, b_ref_; ref_matrix_type c_ref_; }; // Gemm3 template struct Gemm2 { typedef typename M1::value_type value_type ; typedef boost::numeric::ublas::matrix ref_matrix_type ; typedef typename boost::numeric::bindings::traits::type_traits< value_type >::real_type real_type ; typedef typename ref_matrix_type::size_type size_type ; Gemm2(const M1& a, const ref_matrix_type& a_ref) : a_( a ) , a_ref_( a_ref ) , b_ref_( a_ref.size2(), 7 ) { randomize( b_ref_ ); } template int operator() (M& b) const { typedef Gemm3 functor_type ; b.assign( b_ref_ ); return do_matrix_types( functor_type(a_, b, a_ref_, b_ref_) ); } size_type size1() const {return b_ref_.size1();} size_type size2() const {return b_ref_.size2();} const M1& a_ ; const ref_matrix_type& a_ref_; ref_matrix_type b_ref_; }; // Gemm2 template struct Gemm1 { typedef T value_type ; typedef boost::numeric::ublas::matrix ref_matrix_type ; typedef typename boost::numeric::bindings::traits::type_traits< value_type >::real_type real_type ; typedef typename ref_matrix_type::size_type size_type ; Gemm1() : a_ref_( 4, 7 ) { randomize( a_ref_ ); } template int operator() (M& a) const { typedef Gemm2 functor_type ; a.assign( a_ref_ ); return do_matrix_types( functor_type(a, a_ref_) ); } size_type size1() const {return a_ref_.size1();} size_type size2() const {return a_ref_.size2();} ref_matrix_type a_ref_; }; // Gemm1 // Functor to select syrk/herk calls given the two matrix_types template struct Trsm2 { typedef typename M1::value_type value_type ; typedef boost::numeric::ublas::matrix ref_matrix_type ; typedef typename boost::numeric::bindings::traits::type_traits< value_type >::real_type real_type ; typedef typename ref_matrix_type::size_type size_type ; Trsm2(M1& c, const ref_matrix_type& b_ref, const ref_matrix_type& c_ref ) : c_( c ), c_ref_( c_ref ), b_ref_( b_ref ) , a_ref_( b_ref_.size1(), c_ref_.size2() ) { randomize( a_ref_ ) ; } template int operator() (M& a) const { using namespace boost::numeric::ublas ; real_type alpha = 2.0 ; a.assign( a_ref_ ); boost::numeric::bindings::blas::trsm( 'L', 'U', 'N', 'N', value_type(alpha), b_ref_, a ) ; if ( norm_frobenius( alpha * a_ref_ - prod( upper_part(b_ref_), a ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( upper_part(b_ref_) ) * norm_frobenius( a) ) return 255; a.assign( a_ref_ ); boost::numeric::bindings::blas::trsm( 'R', 'U', 'N', 'N', value_type(alpha), c_, a ) ; if ( norm_frobenius( alpha * a_ref_ - prod( a, upper_part(c_) ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( upper_part(c_) ) * norm_frobenius( a ) ) return 255; a.assign( a_ref_ ); boost::numeric::bindings::blas::trsm( 'R', 'L', 'N', 'N', value_type(alpha), c_, a ) ; if ( norm_frobenius( alpha * a_ref_ - prod( a, lower_part(c_) ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( lower_part(c_) ) * norm_frobenius( a ) ) return 255; a.assign( a_ref_ ); boost::numeric::bindings::blas::trsm( 'L', 'U', 'T', 'N', value_type(alpha), b_ref_, a ) ; if ( norm_frobenius( alpha * a_ref_ - prod( trans(upper_part(b_ref_)), a ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( upper_part(b_ref_) ) * norm_frobenius( a) ) return 255; a.assign( a_ref_ ); boost::numeric::bindings::blas::trsm( 'L', 'U', 'N', 'U', value_type(alpha), b_ref_, a ) ; if ( norm_frobenius( alpha * a_ref_ - prod( unit_upper_part(b_ref_), a ) ) > std::numeric_limits< real_type >::epsilon() * norm_frobenius( unit_upper_part(b_ref_) ) * norm_frobenius( a) ) return 255; return 0; } size_type size1() const {return a_ref_.size1() ;} size_type size2() const {return a_ref_.size2() ;} const M1& c_ ; const ref_matrix_type& c_ref_; const ref_matrix_type& b_ref_; ref_matrix_type a_ref_; } ; // Trsm2 template struct Trsm1 { typedef T value_type ; typedef boost::numeric::ublas::matrix ref_matrix_type ; typedef typename boost::numeric::bindings::traits::type_traits< value_type >::real_type real_type ; typedef typename ref_matrix_type::size_type size_type ; Trsm1() : b_( 4, 4 ) , c_( 7, 7 ) { randomize( b_ ); randomize( c_ ); for ( std::size_t i=0; i int operator() (M& c) const { typedef Trsm2 functor_type ; return do_matrix_types( functor_type(c, b_, c_) ); } size_type size1() const {return c_.size1();} size_type size2() const {return c_.size2();} ref_matrix_type b_; ref_matrix_type c_; } ; // Trsm1 template int do_value_type() { // Gemm test if (do_matrix_types( Gemm1() )) return 255 ; // Syrk and herk test if (do_matrix_types( Syrk1() )) return 255 ; // Trsm test if (do_matrix_types( Trsm1() )) return 255 ; return 0 ; } // do_value_type() int main() { // Test for various value_types if (do_value_type()) return 255 ; if (do_value_type()) return 255 ; if (do_value_type >()) return 255 ; if (do_value_type >()) return 255 ; std::cout << "Regression test succeeded\n" ; return 0 ; } boost-bindings/libs/numeric/bindings/blas/test/random.hpp0000644000175000017500000000166610776013426023713 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen #include #include #include template T random_value() { assert( false ); return 0; } template <> float random_value() {return float(std::rand()) / float(RAND_MAX) - 0.5;} template <> double random_value() {return double(std::rand()) / double(RAND_MAX) - 0.5;} template <> std::complex random_value< std::complex >() {return std::complex(random_value(), random_value() );} template <> std::complex random_value< std::complex >() {return std::complex(random_value(), random_value() );} boost-bindings/libs/numeric/bindings/blas/test/Jamfile0000644000175000017500000000107110776160766023214 0ustar andreasandreassubproject libs/numeric/bindings/blas/test ; BLAS_PATH ?= /usr/lib ; BLAS_LIB ?= blas g2c ; exe scal : scal.cpp : $(BOOST_ROOT) $(BOOST) $(BLAS_PATH) $(BLAS_LIB) ; exe blas1 : blas1.cpp : $(BOOST_ROOT) $(BOOST) $(BLAS_PATH) $(BLAS_LIB) ; exe blas3 : blas3.cpp : $(BOOST_ROOT) $(BOOST) $(BLAS_PATH) $(BLAS_LIB) ; boost-bindings/libs/numeric/bindings/blas/doc/0000755000175000017500000000000010776013426021477 5ustar andreasandreasboost-bindings/libs/numeric/bindings/blas/doc/index.html0000644000175000017500000000775510776013426023512 0ustar andreasandreas Boost.Numeric.Bindings.Blas

C++ Boost

Boost.Numeric.Bindings.Blas

Content

  1. Introduction
  2. Mapping onto standard BLAS functions
    1. Fortran symbols
    2. C signatures
    3. Overloads
    4. High level API

1. Introduction

For calculating y += a * x where y and x are vectors of doubles and a a scalar, the BLAS daxpy function can be used. On many systems optimised BLAS libraries are available which provide optimal performance. The BLAS bindings can be used to call these functions on uBLAS vectors, std::vector's and many other C++ classes modelling vectors.

2. Mapping onto standard BLAS functions

The bindings consist of a number of different layers to provide maximal flexibility. For instance, the bindings can be used from within C. From within C++ overloaded functions are available and on a next level, increments, leading-dimensions etc will be extracted from the matrix and vector classes.

2.1. Fortran symbols

Many BLAS implementations are written in Fortran. Therefor, when calling these functions from C or C++, the way these symbols are written in the object file (by the Fortran compiler) need to be matched. Many compilers for instance add an extra understore to the function name or store function names always in capitals.

To match the function names as stored in the BLAS library, a macro FORTRAN_ID can be used on the function name. This macro will, dependent on the toolset, change the function-name to match the corresponding function in the BLAS library.

See blas_names.h

2.2. C signatures

At the second level, C signatures are provided which map directly onto the BLAS functions. The mapping from Fortran to C types is as follows:
Fortran typeMapped to C type
REALfloat
DOUBLEdouble
COMPLEXfcomplex_t
COMPLEX*16dcomplex_t
Due to the lack of a complex datatype in C, fcomplex_t and dcomplex_t are defined in traits/type.h. These are respectively typedefs to float and double but pointers to fcomplex_ or dcomplex_t are supposed to point to two consecutive floating points in memory that represent the real and imaginary value.

Note that all arguments are passed by reference to match the calling conventions used by Fortran compilers. Note also that these signatures are const-correct although const-ness is not mentioned in the BLAS standard. If not const-correct however, using the bindings would require to cast many consts away.

See blas.h

2.3. Overloads

The C layer of bindings provide different functions for every operation with different datatypes. To provide generics, at this level overloaded functions are available that can be called for all supported datatypes.

See blas_overloads.hpp

2.4. High level API

The flexibility of the BLAS functions also have a price. BLAS functions allow vectors to have increments different from one or only manipulate parts of matrices (taking into account the leading dimension of the matrix). This requires however all functions to have many arguments. But many of the information that needs to be passes on to BLAS is already contained in C++ matrix libraries. Therefor high level bindings are provided which require you to only specify the containers and the operation you want to perform on them.

See blas1.hpp, blas2.hpp and blas3.hpp boost-bindings/libs/numeric/bindings/blas/Jamfile0000644000175000017500000000012510776160766022234 0ustar andreasandreassubproject libs/numeric/bindings/blas ; subinclude libs/numeric/bindings/blas/test ; boost-bindings/libs/numeric/bindings/doc/0000755000175000017500000000000010776013426020556 5ustar andreasandreasboost-bindings/libs/numeric/bindings/doc/c++boost.gif0000644000175000017500000002116310776013426022667 0ustar andreasandreasGIF89aV÷!)BZk)1J9Rcs!J!{)c!9!!)!!9!)J!)R!)„!1k!9­!JÖ!Rç!cç)1)!1)!Œ))!))1))B))s)){))Œ)1R)9”)9¥)B½)BÆ)JÆ)ZÖ)cï1)c11J1BÆ1RÆ1RÖ1Z¥1ZÖ1Zç1cÖ1cç1k÷9!991991R91{99”9B”9B­9Jk9R¥9c÷9{÷9Œ÷B1cB1{BBJBBZBBkBB„BJ½BR{BRœBZ”BZÆBZÖBc­BcïBkÖBkÞBk÷JBsJJkJJ”JRÞJZœJZ½JZÆJcÞJ{÷JŒ÷RB{RJZRJkRRkRRœRR­RZÞRc”Rc¥Rc­RkÆRkÖRkÞRkçR{ÖR{ïR„÷RŒçRŒ÷Rœ÷ZJcZRµZZZZZ„Zk­Z{ÞZ­ÿcRkcZ¥cckcc{cc”ckŒckœckµckÎcsÞc{Îc{ïc„ÞcŒ÷cœ÷c­÷c½÷kcŒkkœkk­kkµkssks”ksÆk{¥k{µk{Þk„ÎkŒÎkŒÞkŒçk”÷k¥ïkÆÿkÖÿss¥ssÎsœ÷s­÷sµ÷sÎ÷{sŒ{{{{{{{{µ{„Œ{„œ{Œµ{ŒÆ{ŒÞ{œÖ{µÿ„{„„ŒÖ„Œç„œç„¥÷„µ÷„µ÷„ÎÿŒ{œŒŒ„ŒŒŒŒŒœŒŒµŒŒÆŒ”ΌœÖŒ¥ÖŒ¥çŒµï”Œœ”œœ”œ­”œ½”¥ç”¥ï”¥÷”µÞ”µï”½ç”½÷”½÷”ÎÿœœÎœ­Ö¥œ­¥œ½¥¥Æ¥¥Î¥¥Þ¥­½¥µÞ¥µï¥½ï­¥­­¥½­µ½­µÎ­µÖ­µç­ÆÞ­Æï­Îï­Î÷­Ö÷­ç÷½½Î½½Î½½Þ½½ç½½ï½½÷½ÆƽÎÞ½Îï½Î÷ƵÖÆç÷ÎÎÞÎÎïÎÞÞÎÞïÎÞ÷Öï÷Ö÷÷ÞÞçÞÞ÷ççççç÷ïç÷ï÷÷÷÷÷!ùÿ,Vþÿ H° Áƒ*\È°¡Ã‡#JœH±¢Å‹3jÜȱ£Ç CŠI²¤É“(Sª\ɲ¥Ë—0cÊœI³¦Í›8sêÜɳ§ÏŸ@ƒ J´¨Ñ£H“*]Ê´©Ó§P£JJ5ª?yÚHõy4j˜¹~ýªŠk°_®€Ú §Â’ô×Ð]ºïÄ{·oÞ¿ÿø’%ëOX[µ'^ÀH;¼û k7°ßÀÿÀf«¹3ç°ûöýã÷93]Í“s¾K™2àʘûŒ& 0 ÷âæ`B†¼8ìØ ‡Ë^*„íì¥! `@ußJô;^õßÔ•ýþ‰öÇ/pyò£E÷ãGþüvyûüå‹¿/ß?}ôî×»yÿУxùȧÏhê“ {ü0XÞzªý³OiàQv™qË©äÏ À { r„u$ÐÛh³e,’gWX¤mfÚ?ù8Øyò“O?5ú£ ]¤É#O?ò8=>Öã#’úÔC¤<þÉãÏÚÅ;D:iµí¸ÓÏ;óôãÎ<þœcÎ>ßúù•9Ú¶#?ó¸3¥¶ó89”ó€«=ONiäŽ[âèc°÷Ü8芰ŠêFF¸…'oºÀêÜZ´àÂ@:ÒÅž5F p[ç xä}ô‹ä<Úä2bGL‰y`ýé-’èp³O7ílû?îØs6ÝìóŽ:þ¤3n7éô³Ž;ûÝO:7·t:5Ïó˜Ôý°C/¸öÔ³ý»¤\Ü`{2²y0G̪۹샋¬Èùo gY?|8·þ´“Z&ê§ý<’ËZÖYÁà]¡í3({¡õ3ᘎ;®8?÷4ø%þTNù— ‚uãÁ2Ø=“Å76iâ¹x¸‹£žWª`goÀ¸ElJ>oÛ†ÛtWî£}üHùÈq'f —öüó,ØþxmÏ#§>ÀÍÛ%Ï6ùXã >︃Ï8ãì£Ë0ü\Î=ÝCO5ßÜþ>Ø\Ã1ÄäóMûè\s:ÙäÓ7üèFûÂ4k¨HíàÇ:Úqu4Íùh—³€e{ð£‚ýøÑNך,vqKíÖvŠ«Ô¦UëàÎ4(N„ ßöbÑìÅ.|Àä4[Y†~þü(Æ8ü>}€/ˆ·ÈG1¡eñÃ×ØÇ1°‘h#ÆÐE>tQ }X±¿ Æ> ñ‹~\£ýÇ7ò1ŒnÜcàà‡ÓX4§Íl÷ø?¸µG|Ù£[¼—Ć̸În lˆiµ›WÉãd­"À0„ìã!X‹‰Øq*»ôÇoþè.ªS+PÍ'L”SŽò‘zèˆJú`e‘&Õ?abå•ÔJcéãù0Vé¡8 ó— ª\>î¡}Ðc=¿ì3ÁÒLRŠSJ¤D±\HÈN'*Ñ/ Ñ'Ë´£!Ø¡u®E*Ðìn쨃X¡þþ£G.„¡q8#´hÆ=”¡Œ|,ãôØE*ä ^Ô㯰‡*|Q_¼"ªˆÅ<¸¢]°â¡¬ÈÇ.b¡DdÔC¤˜Ç/Œ¡j@C×xé7²QoxƒÛˆF>ƱŽ|„CùXÇ;îñŽwø¬†œ“˜$:js!Ü\@#2LàªPrs<⫨ƒvv £`eG~üÄm<‚bÅ…ô¬pV°>‚Ð`?”Ñ { cóP3ì‘ >È£±‡%VaU¬b«P…"²*\€]uÀˆ€"p  ¬à=*ŽvÐãòP—ÕæåŽÿ´£ÿ¡‡ºŽ4i ©R«G=ÂD!Ñ£ôÈš<êa]R˜Â.’<tÁ W°FªäG—P÷¹M•*¹Ê57×Ö0 DÃHÛbžcÞê(Æ:K°K÷HÏ:ˆQL*haPÈŸE;fñ‰m€a æÃ框H¸ƒ‚pG$¡JÂXF‡ü0AâDþ=Tqy‚±«¸„=`¡ŠwÄ"¢ÆXEEáŽ_Qy88ø‚:¤ …nH! èp‚º±-¤^ æ(Þ‡aï@ ïHCÞÑ<¸c†hG!‚ L´ƒ—8þ*ÐQ S´ce…,æÁ cÌã,]F7êþÓ{€ã}쇢úàûȸì1»îÉ6w&Š¸†5è·B±ƒØá$`Ž[²};l‡˜9í0 Pž``™ öÐ  ðŸ€ï€rе€ÜÐoÀ p ݇Р€Ô°[ NÜàNNPzR°çÐ[àHÐÝ6R0èÐR„jàÅÖƒ@¼ge—` Šõ íÀÐÇðXÀð ó Zò` ¿0ñ“Õp>EÕUí <ò1õP1²"O…v ÷}6Ï7|ÐIvA '´Àa/ò)]R9ô@ §p"0þSÖräð3Eµ‹x4êÐ ô Ö° Å`SÞ€Ô  ÛÐ àÛÀ3ä àÐ ˆÿóÛ€Šàé sê [¯hê55:Wt„è`Èb¹˜_ýUøe_LøÄŸ*.Ö†1jç%`·q'ÐNþÀvãN` v!©0 øÀhŽø0€ 3 0¡pkˆ@r€â¢ÐKÐß ‰À ^ÐÝCð 0PÖ>  0ðÝ[à 0Û J‡ÐÝ $ Nðá/(R R°ʶ¦7àÀƒ€x@þ í@‘`–°è` — «ð ó@Yòð ‰… «• áÀFÛ°¯èà.õ¢<9r £Mn8 ô€ Î''’†B| +îÜ€ûÀ=:³çÈvã7ºqEF¡€ä0ë Îð `ýˆè0] oàÝàSà ÜP+p OàŽ ÝpO@dðÝ ð RêPNÀ™R šÐÖà k€ƒ à`ià”@ì`•p|`e›Õ©…±À ôà «ÐÀFbq„@Þb/ö<çA•ÑØ\¨· + ÃCÙèi Òþ0À £rÀ’9æ8Múð}°Cd0=á°ž÷£Fà€ Ë0SÔ æó ဠÅ` Óð Öð ã07 Ôð ×ð Ý€ è` Ýp Ý`Ý` Ä ÷cSß°èà þ†Æ©ûæPtº%BóJ3B£.EÇ‹Üò-ñB%ùP$óa9rgSvgw'¹á*òP ãjC*¢2<Õ± Ð ¨å “9j‰æ7ëàp ˆÐàCÐ ^ Ð   3 Í r° C ÄÐC0BÄàߘO@ (€×P§Þ n #ð S`Ü@T þ0ß`3à 5p‘làÝ°Nà §wš„pšÉ&jÐ“í° „À“NèXí áP§p UtE×€ö þ€uý€uÿà5 !ƒ!*öœ®âUµ1sÓCÛ(*l÷ª'“ 0å(€v”vl'ÜÐqX"ª`]* » ´ð š@¿   ^¿@áÐhêBÐ Bp×0&À ‰Þ€(q0Ò°1ð `Ýp'Ð Œ 1° ™6ðéð3ðZð§ÙЦæ iðmv`c` á@•Ð ª° ï ¾`£ ¦õþ ù@ Õ°4ÿV.ñâ"26:­¶0l3 ÿN;D$ÀuJ ²æÀ Ä0 ò9÷P9ö ŸCô 5æ@ Œðf v á-½ ²ð ØõY Ñð Ô€ ß É Ö0 ×0·ßPŠÖ@ Ñp Þ`Ÿß@ Ôð} ú?‚K4ºu?蟈ê sPÓ(¼¸ š(‰èæ0aóÐ%aò9fÎèŒgƒ«!l!' 'VP Ü`p>@¹…´ì€¸;¬ÈväèP\í 9€‡ Ð0 ñnàÈ€¥ß0C CàÆ ^þp PÐ@0 6ð аCÔ`Ap @Ý°Ð 4à®3×°à 3Pi¨™j ™“ºlÜl`GÔZ lÀ ½p`Ð –à ùð ¿ÀaÔÐð ûð +“ðR/:îÁ'TaCñk<ÐpB‹ú0@Rºˆ»hÉå0 ËZ” ó€Uð¡ ¿p ñBp jZ êZ CÐ B€ ]¿𠇀Û p¨5Ð QÀ×pN 0×Ð  Ý01à +"É™[ð N ïiÐ þËÖ{`Ð`W"aùà •PY½Ð ú³³E ý` ýÀ‹³ÊBÂk‚*þpב£l¡rB$ÀТ;)˜*–SŽÍãŸÓJô0_Úë`$ú ¿ ÏP Ä Ò° Ð@ º  \ø ¿À ¿@ Åð sK[ Ð0 Äð Ò¬ËÔ  Å ¶Ð@ j ÞÎÞ ‰×`ÍùI Å° Ôà Üð?½@ 1 éð`5Lõ1*èÑfs0$\FðɤÖ* P´Ôa+Âvà $º»å ó0¯`߀ö`9àtîÐ ˆ`   ö0 R¼ B0¿˜¦€þ¥“à^   Р )`Ðp6@ 7°¬7  00¦°3ð *n<è+@ *@¯‘©à‚РœPÐbQ w0 “å úÐ ¿°a´?Ôàá€$;%¡si,ò¤k%ðɺk @|Ý€´-¬ç¸¥íà‘ ¸ü:`ê ¡ð­ ¿€¼‘É<aЫ¯Cð Ó+Dòõz’ð @Ôp]° QðÚÈ€_ö@æ` R`  ÏP€ò» ª'@Ö.Ü° [  ­' ZÀ»€© ‰þ­ å ÏÀÕP î“Ö”&.fx!Ü1ü à½a¬&rKÀ y1(•“Ð7"ž™“5×ât¿ô,îGÒ=ïp ¿ Ñ@0 1 ÈÐ ßÀ Ÿ° é ÛÀ¦ÀEoÛ ¯0 Å@±E¦ð .õ a» Rv$› »` ß‘¡™ûõKâÁ2×Ï(ö±­ÄÖ` Ü@: ÄcÙºvÛ0ɺ ó0 ƒ  .í@ið¢óø ­€ø€P€å:³0Ÿ@ã!`  ¿ëÚ±` /ºªÐý ¦ AþÓà©À¯à ì “üþ°ãޢʣ$Þ¶º³F‘ qãÝJÁvîР˺élßáæ ˜àWôF€hl8ˆð •÷h€¾0½ŸpŸÄú¬@²ð¿/ eð÷à—Àó Ž  ,è¾ Éï0DÄ° ÿÀ4¯z†É³Lš,éËÑI|*”/ž¤Ð`G$B`]BBE…ËâÀSË𠯀ó³~É ¬à Á   ªà ± “` ýÝp ¡DöKËd&_ò"-"„‘|¡Ï~³ÐdA¶+Ø‘V‹Pþ™@ ö€©€`ðóð VN­ }÷ûn¬ C@„ 〠ˆuú0¹NÆðw°J`0è°_ú  ¦ð“ªÐÇ0DûdFÞàß4”¶¹æ÷ídÞk/>þi "ߺ«?¸¤÷ æ°åÈ€>VàF°±‰ä0ï0ø¯nóqa 㺠q€³à~@ Q Q`ÄñO@aW€ï`ó°^¦€ºà{ð Ž0 û` ª°ãÀDà þpÁþ€¡¯ªèSK#9ò 4*f¤Âº?ò9þòõþbñ`k,·ˆï°ೞ¬ð øÞÁaú—ð Œ;@^~{P†A LP qçfpóÀg%‘f ©»P A`Qß<~÷öíË×O¡?~þüõó÷ï_D‰-^ĘQãFŽ=~ÄH1cC‰MžÄç0%¿_èÞkÇgѼO˜ÞÝ{'Œ‘vŸZ‘ûôi¢Oá@eúUdE|yX ñ’Lc•ï)B£Q eE4ÉØoÌ {óP¢Kã32‘ä925ïÕ¸~¨Jéû_µkþ¾¥ó—ÎÝ¿yóþÕË÷O¿ý;œ¸TòdÊ’Ef¤—ï¤É”þVzþö -_¼eðM²÷‰’=~»Ì‰ùò®¨y‰@½C„h]¢Z¿‚-µÇ*ŽœXr¼ ÓÈ#ŽÆr¢Îh¤–¡kFW4{¡ š={ÝpÙêöDÉ.ÅÆ8zÛˆ¹fùébùË´jþ®} xÞàyeõéû‡Ÿ~‹è²ÊD0AÚì$ˆ^b¨s䑧ÂÜ!¨ ÁYçpÞYr‡œoN|&•¥üA' BX¹Ä’n4Ê" º9#è’F#;® G#wÆ@c’@:A%•]ŠÑå™òžI‡žyò¹GŸ|®ÜG@ÇzðAÈ*¢È@Ç$sE‹.ó§ÍðÁ§Ÿ{^êìzzþWdy–{ìYdŽtöÅžP@'¨p>É#œrÊQEÊš!D9ªÑ N¬â¬Œžy‚ÒŒbðCŽº €NNðá%| /#jt¨BžKÆѧ>òYÅ{^y†hž±Ï¥nKGÂêQ,1~ƒh"1Ë„¶L†Jó¡vœÝŒŸ”Þ¼çstáEžJdé0žnÀ˜£YDI'Y åp@9DQ1&q¤²T¼¹Œî¨…9EžËš¤ÊH GvèÈRñÁ‡nPP¢˜µ¾Èžqf¡§ŽEúy…•~Téõ—jø¹¯Ÿ¿üQÇØÂþÉ@+Ûg¢£Å9ÚÏ„L¤ž×þ„‡zö‘S ꡇy¸³§{Þyúéz n§›%5’§'3ê&4¶Æ( (4ZæŒ1 »bŠ„¤UŽøIÅ—j AÅâMŸ‘‡}(ìG„²\v!/MŠ,gÿ(Ì/O’¨{ªUÉ!bp1Çlî &•{ÒydžIVÁGYî êPZ!½œ{Œ(bZ4²Ç ‚1Ò'Ž8fÌ E4Ç‹¬6=´˜ä‰työ¢WR‰X­Mï`¦>êÈÇ”Uöye•{xe©¾j¾éÇÀÔ1ldÿ Ù“G¼ýÌRñë‘_¥|†!¦d¹eî‡.èñ `ØC’Eþañ {€îVpD2d»CÜa#q8„74ˆOh$p˜tà)ŒhAN(ƒ)rà/Žè"bn»È3š±Œ˜Ø¦xE>Œá‹}Xôa‘KÐyÌÃE„€ø ~ÔìKîƒ"HÖ·¸}„é1(Ñbø!tècOúH‰= š”àãlºÇñáŽv|©G,¨BLwñšF¾¡ŠHh„c°†FTQe|#ª˜ò82]¤Ân¡:ºQÄ~\)YÚ‡B´¤ˆ4¤gQå˜ ä¥&N‘"ø ÇúìA zH#üP4æŒËCö!E=Ø´KÏ첌FüþAŽ2§,¼H Æ–‘kH¡7ó0„_ô€¿àÁ&ˆGfÄdÛEº!0ðc«à$NÁîýXŨO7оtü£eÿXZ²T³f…ÒŸÙL—HÂ0uÆ!аF>¼Ž{|ãè¸Æåv¡‹4‚Ãë¥/ñ]þÂlG13Ò4dZÄä€3D*NX &#NàÕ3ÌAot££h„a2ÀÐ"Ó°B¶ÇŠ}ìÂþ(†1æC Tƒ©Ôè†?Ìœ áÓXù@V># vU˜-Iåw|ÐÃŒi,H…ªT=¥öp‡'5ºËx€£›©Ç$Vzþ‘I¨Ñ«FÚQŒ»V“Ð`FRñ‹š]¤ŒÈWFŠ!‰ÂJdß°Ç=ÒIˆŽp…ójh)Ó³Î:Ä“Œs8øÑ 5uèëX‡=¨Q _]£ÇÀÉ/èÑ2Îæ2±‘wÔ#±™„8`'U܈È©*Ĥ;Ôg¤ï¨ì?¨± { óþG8À+Þl¨)êøÇ;Üáy¼ãR‚™f®D3ÑÖ—Z)m)Ò³{ÄíàÇ;Þ`5yCôøÆM΋î œéí=>GÂnDàxcF$0ŒÔ½xV7 ¤€ãŒ¹?Ñ‚›]„Ù-#¼È&þÐÔØ3ÁÇDÔ Ç-+}A±}C&lí—qj¶”¼7y¤ iìî[FFº‚ãŽéGT…IŒ_d÷ fÐÈ/’ñ èŠÓ W®È`q­Ä ‰ÁaÃiiobŸõ\™‡H¤´\ëéÁîô·»…n…Òñ|¸ÑâÐl=êÁÛ¿¥ =D”Ýg ·Ä—&qâ~Ñb‹˜ÃÊÆŠ³9ê pPC#ú 1äñ&ŽÈ{ÆõGvVd‡ìCþˆ™Côáî›5…á‡9è×@ 'o²ÆƒÉxu`z2èÑv$Ó rÔÍÑ7º!>ÉÌí˜3Fä¹>jþ)×ïÖ5µnÆISžä´GkòDÞää7™±»*‘ð·? pÔCÙ)k«F 6¤o‡5T ’aU-ÈñF*ŸoŽO¦ÏéÇФY†4ä?þ¨Cä¡Ì›Ø{*¹ã+´ÃwsC>ã1äìk1$¨»ÃA$ÄB4ÄCDÄDTÄEdÄFtÄG„ÄH”ÄI¤ÄJ´ÄKÄÄLÔÄMäÄN,“€;boost-bindings/libs/numeric/bindings/doc/index.html0000644000175000017500000001024710776013426022557 0ustar andreasandreas Boost.Numeric.Bindings

C++ Boost

Boost.Numeric.Bindings

Index

Synopsis

The Bindings Library contains bindings to popular non-boost (numeric) libraries, usually written in Fortran or C. These non-boost libraries generally use data structures in their API for which there might be boostified equivalents or other popular non-boost equivalents. The Bindings Library offers a generic thin layer API on top of the original API of the external library. This generic API accepts a whole range of data structures from different origins and usually hides or reduces the complexity of the original API.

For instance, ATLAS, a C library implementing BLAS (and few LAPACK routines), represents matrices by means of a pointer and the dimensions. Now boost also contains matrix classes (uBLAS) and there are also other matrix libraries in widespread use. Therefore the Bindings library features a generic interface for ATLAS which provides the possibility to call e.g. the matrix-multiplication routine of ATLAS using matrices defined in uBLAS, TNT, etc.: 

  #include <boost/numeric/bindings/traits/ublas_matrix.hpp>
  #include <boost/numeric/bindings/traits/tnt.hpp>
  #include <boost/numeric/bindings/atlas/cblas3.hpp> 

  namespace ublas = boost::numeric::ublas; 
  namespace atlas = boost::numeric::bindings::atlas;

  int main() {
    ublas::matrix<double> A1 (2,2), B1 (2,3), C1 (2,3);
    // initialisation... 
    // C1 <- A1 * B1 :
    atlas::gemm (A1, B1, C1); 

    ublas::matrix<double, ublas::column_major> A2 (2,3), B2 (2,2), C2 (3,2);
    // ... 
    // C2 <- A2^T * B2^T : 
    atlas::gemm (CblasTrans, CblasTrans, 1.0, A2, B2, 0.0, C2);

    TNT::Array2D<double> A3 (2,2), B3 (2,3), C3 (2, 3); 
    // ...
    // C3 <- A3^T * B3 :
    atlas::gemm (CblasTrans, CblasNoTrans, 1.0, A3, B3, 0.0, C3);

    TNT::Fortran_Array2D A4 (2,2), B4 (2,3), C4 (2, 3);
    // ... 
    // C4 <- 2.0 * A4 * B4 + C4 :
    atlas::gemm (2.0, A4, B4, 1.0, C4); 
  }
In short, gemm() is BLAS/ATLAS matrix multiplication function. ATLAS bindings provide three convenient overloads: 
  C <- a * op (A) * op (B) + b * C
  C <- a * A * B + b * C 
  C <- A * B
where a, b are scalars, A, B, C are (rectangular) matrices and op (A) == A || AT || AH. Function gemm() is BLAS level 3 routine and therefore atlas/cblas3.hpp should be included (all headers are in subdirectories of boost/numeric/bindings). To use bindings with ublas::matrix<> one should include traits/ublas_matrix.hpp (note that there is no need to include boost/numeric/ublas/matrix.hpp separately) and to use them with TNT arrays traits/tnt.hpp should be included; to learn more about traits classes see chapter Traits.

Contents

Traits
Amos bindings
ATLAS bindings
BLAS bindings
LAPACK bindings
UMFPACK bindings
boost-bindings/libs/numeric/bindings/lapack/0000755000175000017500000000000010776160766021256 5ustar andreasandreasboost-bindings/libs/numeric/bindings/lapack/test/0000755000175000017500000000000010776160766022235 5ustar andreasandreasboost-bindings/libs/numeric/bindings/lapack/test/vc6/0000755000175000017500000000000010776013426022721 5ustar andreasandreasboost-bindings/libs/numeric/bindings/lapack/test/vc6/ublas_posv.cc0000644000175000017500000001450010776013426025405 0ustar andreasandreas // solving A * X = B // A symmetric/hermitian positive definite // driver function posv() #define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #ifdef INCLUDE_LAPACK #include #else #include #endif #include #include #include #include "utils2.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef float real; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_adaptor symml_t; typedef ublas::hermitian_adaptor herml_t; typedef ublas::symmetric_adaptor symmu_t; typedef ublas::hermitian_adaptor hermu_t; using ublas::prod; int main() { cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n = 5; size_t nrhs = 2; m_t al (n, n), au (n, n); // matrices (storage) symml_t sal (al); // symmetric adaptor symmu_t sau (au); // symmetric adaptor m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm (sal, 'l'); // [5 0 0 0 0] // [4 5 0 0 0] // al = [3 4 5 0 0] // [2 3 4 5 0] // [1 2 3 4 5] init_symm (sau, 'u'); // [5 4 3 2 1] // [0 5 4 3 2] // au = [0 0 5 4 3] // [0 0 0 5 4] // [0 0 0 0 5] print_m (sal, "sal"); cout << endl; print_m (al, "al"); cout << endl; print_m (sau, "sau"); cout << endl; print_m (au, "au"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; m_t al1 (al), au1 (au); // for part 2 m_t bl1 (bl), bu1 (bu); lapack::posv (sal, bl); print_m (bl, "xl"); cout << endl; lapack::posv (sau, bu); print_m (bu, "xu"); cout << endl; // part 2 lapack::posv ('L', al1, bl1); print_m (al1, "al1 factored"); cout << endl; print_m (bl1, "xl1"); cout << endl; lapack::posv ('U', au1, bu1); print_m (au1, "au1 factored"); cout << endl; print_m (bu1, "xu"); cout << endl; ////////////////////////////////////////////////////////// // hermitian cout << "\n==========================================\n" << endl; cout << "complex hermitian (well, not really ;o)\n" << endl; cm_t cal (3, 3), cau (3, 3); // matrices (storage) herml_t hal (cal); // hermitian adaptor hermu_t hau (cau); // hermitian adaptor cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS init_symm (hal, 'l'); init_symm (hau, 'u'); print_m (hal, "hal"); cout << endl; print_m (cal, "cal"); cout << endl; print_m (hau, "hau"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (hal, cx); cbu = prod (hau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::posv (hal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; ierr = lapack::posv (hau, cbu); if (ierr == 0) print_m (cbu, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; // regular (see ublas_gesv.cc), but not positive definite: hal (0, 0) = cmplx_t (3, 0); hal (1, 0) = cmplx_t (4, -2); hal (1, 1) = cmplx_t (5, 0); hal (2, 0) = cmplx_t (-7, -5); hal (2, 1) = cmplx_t (0, 3); hal (2, 2) = cmplx_t (2, 0); hau (0, 0) = cmplx_t (3, 0); hau (0, 1) = cmplx_t (4, 2); hau (0, 2) = cmplx_t (-7, 5); hau (1, 1) = cmplx_t (5, 0); hau (1, 2) = cmplx_t (0, -3); hau (2, 2) = cmplx_t (2, 0); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, 1); print_m (cx, "cx"); cout << endl; cbl = prod (hal, cx); cbu = prod (hau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; ierr = lapack::posv (hal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; ierr = lapack::posv (hau, cbu); if (ierr == 0) print_m (cbu, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; // positive definite: hal (0, 0) = cmplx_t (25, 0); hal (1, 0) = cmplx_t (-5, 5); hal (1, 1) = cmplx_t (51, 0); hal (2, 0) = cmplx_t (10, -5); hal (2, 1) = cmplx_t (4, 6); hal (2, 2) = cmplx_t (71, 0); hau (0, 0) = cmplx_t (25, 0); hau (0, 1) = cmplx_t (-5, -5); hau (0, 2) = cmplx_t (10, 5); hau (1, 1) = cmplx_t (51, 0); hau (1, 2) = cmplx_t (4, -6); hau (2, 2) = cmplx_t (71, 0); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; cm_t cbl2 (3, 2); cbl2 (0, 0) = cmplx_t (60, -55); cbl2 (1, 0) = cmplx_t (34, 58); cbl2 (2, 0) = cmplx_t (13, -152); cbl2 (0, 1) = cmplx_t (70, 10); cbl2 (1, 1) = cmplx_t (-51, 110); cbl2 (2, 1) = cmplx_t (75, 63); cm_t cbu2 (cbl2); print_m (cbl2, "cbl"); cout << endl; ierr = lapack::posv ('L', cal, cbl2); if (ierr == 0) print_m (cbl2, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; ierr = lapack::posv ('U', cau, cbu2); if (ierr == 0) print_m (cbu2, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/vc6/ublas_hetrf_hetrs.cc0000644000175000017500000000656510776013426026747 0ustar andreasandreas // solving A * X = B // A hermitian // hetrf() & hetrs() #define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include "utils2.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::hermitian_adaptor cherml_t; typedef ublas::hermitian_adaptor chermu_t; int main() { cm_t cal (3, 3), cau (3, 3); // matrices (storage) cherml_t hcal (cal); // hermitian adaptor chermu_t hcau (cau); // hermitian adaptor cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS hcal (0, 0) = cmplx_t (3, 0); hcal (1, 0) = cmplx_t (4, -2); hcal (1, 1) = cmplx_t (5, 0); hcal (2, 0) = cmplx_t (-7, -5); hcal (2, 1) = cmplx_t (0, 3); hcal (2, 2) = cmplx_t (2, 0); hcau (0, 0) = cmplx_t (3, 0); hcau (0, 1) = cmplx_t (4, 2); hcau (0, 2) = cmplx_t (-7, 5); hcau (1, 1) = cmplx_t (5, 0); hcau (1, 2) = cmplx_t (0, -3); hcau (2, 2) = cmplx_t (2, 0); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = ublas::prod (hcal, cx); cbu = ublas::prod (hcau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; cm_t cal2 (hcal), cau2 (hcau); // for part 2 cm_t cbl2 (cbl), cbu2 (cbu); std::vector ipiv (3); int ierr = lapack::hetrf (hcal, ipiv); if (ierr == 0) { lapack::hetrs (hcal, ipiv, cbl); print_m (cbl, "cxl"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; std::vector cwork (3*64); // 3*64 -- optimal size ierr = lapack::hetrf (hcau, ipiv, cwork); if (ierr == 0) { lapack::hetrs (hcau, ipiv, cbu); print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; // part 2 ublas::swap (row (cal2, 0), row (cal2, 2)); ublas::swap (column (cal2, 0), column (cal2, 2)); ublas::swap (row (cau2, 1), row (cau2, 2)); ublas::swap (column (cau2, 1), column (cau2, 2)); print_m (cal2, "cal2"); cout << endl; print_m (cau2, "cau2"); cout << endl; cbl2 = ublas::prod (cal2, cx); cbu2 = ublas::prod (cau2, cx); print_m (cbl2, "cbl2"); cout << endl; print_m (cbu2, "cbu2"); cout << endl; ierr = lapack::hetrf ('L', cal2, ipiv); if (ierr == 0) { lapack::hetrs ('L', cal2, ipiv, cbl2); print_m (cbl2, "cxl2"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; ierr = lapack::hetrf ('U', cau2, ipiv, cwork); if (ierr == 0) { lapack::hetrs ('U', cau2, ipiv, cbu2); print_v (ipiv, "ipiv"); cout << endl; print_m (cbu2, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/vc6/utils2.h0000644000175000017500000000617310776013426024323 0ustar andreasandreas #ifndef F_UTILS_H #define F_UTILS_H #include #include #include /////////////////////////////// // vectors // initialization: struct ident { size_t operator() (size_t i) const { return i; } }; struct iplus1 { size_t operator() (size_t i) const { return i + 1; } }; template struct const_val { T val; const_val (T v = T()) : val (v) {} T operator() (size_t) const { return val; } T operator() (size_t, size_t) const { return val; } }; struct kpp { size_t val; kpp (size_t v = 0) : val (v) {} size_t operator() (size_t) { size_t tmp = val; ++val; return tmp; } size_t operator() (size_t, size_t) { size_t tmp = val; ++val; return tmp; } }; template struct times_plus { T s, a, b; times_plus (T ss, T aa = T(), T bb = T()) : s (ss), a (aa), b (bb) {} T operator() (size_t i) const { return s * (T) i + a; } T operator() (size_t i, size_t j) const { return s * ((T) i + a) + (T) j + b; } }; template void init_v (V& v, F f = F()) { size_t sz = boost::numeric::bindings::traits::vector_size (v); for (std::size_t i = 0; i < sz; ++i) v [i] = f (i); } // printing: template void print_v (V const& v, char const* ch = 0) { if (ch) std::cout << ch << ": "; size_t sz = boost::numeric::bindings::traits::vector_size (v); for (std::size_t i = 0; i < sz; ++i) std::cout << v [i] << " "; std::cout << std::endl; } ///////////////////////////////////// // matrices // initialization: struct rws { size_t operator() (size_t i, size_t) const { return i; } }; struct rws1 { size_t operator() (size_t i, size_t) const { return i + 1; } }; struct cls { size_t operator() (size_t, size_t j) const { return j; } }; struct cls1 { size_t operator() (size_t, size_t j) const { return j + 1; } }; template void init_m (M& m, F f = F()) { size_t sz1 = boost::numeric::bindings::traits::matrix_size1 (m); size_t sz2 = boost::numeric::bindings::traits::matrix_size2 (m); for (std::size_t i = 0; i < sz1; ++i) for (std::size_t j = 0; j < sz2; ++j) m (i, j) = f (i, j); } template void init_symm (M& m, char uplo = 'f') { size_t n = boost::numeric::bindings::traits::matrix_size1 (m); for (size_t i = 0; i < n; ++i) { m (i, i) = n; for (size_t j = i + 1; j < n; ++j) { if (uplo == 'u' || uplo == 'U') m (i, j) = n - (j - i); else if (uplo == 'l' || uplo == 'L') m (j, i) = n - (j - i); else m (i, j) = m (j, i) = n - (j - i); } } } // printing: template void print_m (M const& m, char const* ch = 0) { if (ch) std::cout << ch << ":\n"; size_t sz1 = boost::numeric::bindings::traits::matrix_size1 (m); size_t sz2 = boost::numeric::bindings::traits::matrix_size2 (m); for (std::size_t i = 0 ; i < sz1 ; ++i) { for (std::size_t j = 0 ; j < sz2 ; ++j) std::cout << m (i, j) << " "; std::cout << std::endl; } // std::cout << std::endl; } #endif boost-bindings/libs/numeric/bindings/lapack/test/vc6/ublas_gesv.cc0000644000175000017500000000444610776013426025372 0ustar andreasandreas // solving A * X = B // using driver function gesv() #define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include "utils2.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef std::complex cmpx; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; int main() { cout << endl; cout << "real system:" << endl << endl; size_t n = 5; m_t a (n, n); // system matrix size_t nrhs = 2; m_t x (n, nrhs), b (n, nrhs); // b -- right-hand side matrix std::vector ipiv (n); // pivot vector init_symm (a); // [n n-1 n-2 ... 1] // [n-1 n n-1 ... 2] // a = [n-2 n-1 n ... 3] // [ ... ] // [1 2 ... n-1 n] m_t aa (a); // copy of a, because a is `lost' after gesv() for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } b = ublas::prod (a, x); print_m (a, "A"); cout << endl; print_m (b, "B"); cout << endl; lapack::gesv (a, ipiv, b); // solving the system, b contains x print_m (b, "X"); cout << endl; x = ublas::prod (aa, b); print_m (x, "B = A X"); cout << endl; //////////////////////////////////////////////////////// cout << endl; cout << "complex system:" << endl << endl; cm_t ca (3, 3), cb (3, 1), cx (3, 1); std::vector ipiv2 (3); ca (0, 0) = cmpx (3, 0); ca (0, 1) = cmpx (4, 2); ca (0, 2) = cmpx (-7, 5); ca (1, 0) = cmpx (4, -2); ca (1, 1) = cmpx (-5, 0); ca (1, 2) = cmpx (0, -3); ca (2, 0) = cmpx (-7, -5); ca (2, 1) = cmpx (0, 3); ca (2, 2) = cmpx (2, 0); print_m (ca, "CA"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmpx (1, -1); cb = ublas::prod (ca, cx); print_m (cb, "CB"); cout << endl; int ierr = lapack::gesv (ca, ipiv2, cb); if (ierr == 0) print_m (cb, "CX"); else cout << "matrix is singular" << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/vc6/ublas_sysv.cc0000644000175000017500000001010010776013426025412 0ustar andreasandreas // solving A * X = B // A symmetric // driver function sysv() #define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #define BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include #include #include #include #include #include #include #include "utils2.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_adaptor symml_t; typedef ublas::symmetric_adaptor symmu_t; typedef ublas::symmetric_adaptor csymml_t; typedef ublas::symmetric_adaptor csymmu_t; template void init_symm2 (M& m) { for (int i = 0; i < m.size1(); ++i) for (int j = i; j < m.size1(); ++j) m (i, j) = m (j, i) = 1 + j - i; } int main() { cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n; cout << "n -> "; cin >> n; if (n < 5) n = 5; cout << "min n = 5" << endl << endl; size_t nrhs = 2; m_t al (n, n), au (n, n); // matrices (storage) symml_t sal (al); // symmetric adaptor symmu_t sau (au); // symmetric adaptor m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm2 (al); ublas::swap (row (al, 1), row (al, 4)); ublas::swap (column (al, 1), column (al, 4)); print_m (al, "al"); cout << endl; init_symm2 (au); ublas::swap (row (au, 2), row (au, 3)); ublas::swap (column (au, 2), column (au, 3)); print_m (au, "au"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = ublas::prod (sal, x); bu = ublas::prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; m_t al1 (al), au1 (au); // for part 2 m_t bl1 (bl), bu1 (bu); lapack::sysv (sal, bl); print_m (bl, "xl"); cout << endl; lapack::sysv (sau, bu); print_m (bu, "xu"); cout << endl; // part 2 std::vector ipiv (n); std::vector work (1); int err = lapack::sysv ('L', al1, ipiv, bl1, work); print_m (al1, "al1 factored"); cout << endl; print_v (ipiv, "ipiv"); cout << endl; print_m (bl1, "xl1"); cout << endl; err = lapack::sysv ('U', au1, ipiv, bu1, work); print_m (au1, "au1 factored"); cout << endl; print_v (ipiv, "ipiv"); cout << endl; print_m (bu1, "xu1"); cout << endl; cout << endl; ////////////////////////////////////////////////////////// cout << "\n==========================================\n" << endl; cout << "complex symmetric\n" << endl; cm_t cal (n, n), cau (n, n); // matrices (storage) csymml_t scal (cal); // hermitian adaptor csymmu_t scau (cau); // hermitian adaptor cm_t cx (n, 1); cm_t cbl (n, 1), cbu (n, 1); // RHS init_symm2 (cal); init_symm2 (cau); cal *= cmplx_t (1, 1); cau *= cmplx_t (1, -0.5); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = ublas::prod (scal, cx); cbu = ublas::prod (scau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::sysv (scal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; std::vector cwork (n); ierr = lapack::sysv (scau, ipiv, cbu, cwork); if (ierr == 0) { print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesdd3.cc0000644000175000017500000000634510776160766025113 0ustar andreasandreas //#define BOOST_NUMERIC_BINDINGS_LAPACK_2 #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef ublas::matrix m_t; typedef ublas::vector v_t; int main() { cout << endl; size_t m = 3, n = 4; size_t minmn = m < n ? m : n; m_t a (m, n); a(0,0) = 2.; a(0,1) = 2.; a(0,2) = 2.; a(0,3) = 2.; a(1,0) = 1.7; a(1,1) = 0.1; a(1,2) = -1.7; a(1,3) = -0.1; a(2,0) = 0.6; a(2,1) = 1.8; a(2,2) = -0.6; a(2,3) = -1.8; m_t a2 (a); // for part 2 m_t a3 (a); // for parts 3 & 4 print_m (a, "A"); cout << endl; m_t sm (m, n); ublas::matrix_vector_range smr (sm, ublas::range (0, minmn), ublas::range (0, minmn)); v_t s (minmn); m_t u (m, m); m_t vt (n, n); size_t lw; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesdd_work ('O', 'N', a); cout << "opt N lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'A', a); cout << "opt A lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'S', a); cout << "opt S lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'O', a); cout << "opt O lw: " << lw << endl; #endif lw = lapack::gesdd_work ('M', 'A', a); cout << "min lw: " << lw << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesdd_work ('O', 'A', a); #endif std::vector w (lw); size_t liw = lapack::gesdd_iwork (a); cout << "liw: " << liw << endl << endl; std::vector iw (liw); lapack::gesdd ('A', a, s, u, vt, w, iw); print_v (s, "s"); cout << endl; smr = s; print_m (sm, "S"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; a = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a, "A == U S V^T"); cout << endl; // part 2 cout << endl << "part 2" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lapack::gesdd ('A', a2, s, u, vt); #else lapack::gesdd ('M', 'A', a2, s, u, vt); #endif print_v (s, "s"); cout << endl; smr = s; print_m (sm, "S"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; a2 = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a2, "A == U S V^T"); cout << endl; // part 3 -- another check sm = ublas::prod (ublas::trans (u), m_t (ublas::prod (a3, ublas::trans (vt)))); print_m (sm, "S == U^T A V"); cout << endl; // part 4 -- singular values only cout << endl << "part 4" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 cout << "opt lw: " << lapack::gesdd_work ('O', 'N', a3) << endl << endl; lapack::gesdd ('N', a3, s, u, vt); #else cout << "min lw: " << lapack::gesdd_work ('M', 'N', a3) << endl << endl; lapack::gesdd ('M', 'N', a3, s, u, vt); #endif print_v (s, "singular values only"); cout << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_sytrf_sytrs.cc0000644000175000017500000001252210776160766026347 0ustar andreasandreas // solving A * X = B // A symmetric // sytrf() & sytrs() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_adaptor symml_t; typedef ublas::symmetric_adaptor symmu_t; typedef ublas::symmetric_adaptor csymml_t; typedef ublas::symmetric_adaptor csymmu_t; template void init_symm2 (M& m) { for (int i = 0; i < m.size1(); ++i) for (int j = i; j < m.size1(); ++j) m (i, j) = m (j, i) = 1 + j - i; } int main() { cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n; cout << "n -> "; cin >> n; if (n < 5) n = 5; cout << "min n = 5" << endl << endl; size_t nrhs = 2; m_t al (n, n), au (n, n); // matrices (storage) symml_t sal (al); // symmetric adaptor symmu_t sau (au); // symmetric adaptor m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm2 (al); swap (row (al, 1), row (al, 4)); swap (column (al, 1), column (al, 4)); print_m (al, "al"); cout << endl; init_symm2 (au); swap (row (au, 2), row (au, 3)); swap (column (au, 2), column (au, 3)); print_m (au, "au"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; m_t al1 (al), au1 (au); // for part 2 m_t bl1 (bl), bu1 (bu); std::vector ipiv (n); int err = lapack::sytrf (sal, ipiv); if (err == 0) { lapack::sytrs (sal, ipiv, bl); print_m (bl, "xl"); } cout << endl; err = lapack::sytrf (sau, ipiv); if (err == 0) { lapack::sytrs (sau, ipiv, bu); print_m (bu, "xu"); } else cout << "?" << endl; cout << endl; // part 2 cout << endl << "part 2" << endl << endl; int lw = lapack::sytrf_block ('O', 'L', al1); cout << "nb = " << lw << endl; lw *= n; cout << "lw = " << lw << " == " << lapack::sytrf_work ('O', 'L', al1) << endl; cout << "mw = " << lapack::sytrf_work ('M', 'L', al1) << endl; std::vector work (lw); int mb = lapack::sytrf_block ('M', 'L', al1); cout << "mb = " << mb << endl << endl; err = lapack::sytrf ('L', al1, ipiv, work); if (err == 0) { lapack::sytrs ('L', al1, ipiv, bl1); print_m (al1, "al1 factored"); cout << endl; print_v (ipiv, "ipiv"); cout << endl; print_m (bl1, "xl1"); } else cout << "?" << endl; cout << endl; lw = lapack::sytrf_block ('O', 'U', au1); cout << "nb = " << lw << endl; lw *= n; cout << "lw = " << lw << " == " << lapack::sytrf_work ('O', 'U', au1) << endl; cout << "mw = " << lapack::sytrf_work ('M', 'U', au1) << endl; if (lw != work.size()) work.resize (lw); mb = lapack::sytrf_block ('M', 'U', au1); cout << "mb = " << mb << endl << endl; err = lapack::sytrf ('U', au1, ipiv, work); if (err == 0) { lapack::sytrs ('U', au1, ipiv, bu1); print_m (au1, "au1 factored"); cout << endl; print_v (ipiv, "ipiv"); cout << endl; print_m (bu1, "xu1"); } else cout << "?" << endl; cout << endl; cout << endl; ////////////////////////////////////////////////////////// cout << "\n==========================================\n" << endl; cout << "complex symmetric\n" << endl; cm_t cal (n, n), cau (n, n); // matrices (storage) csymml_t scal (cal); // symmetric adaptor csymmu_t scau (cau); // symmetric adaptor cm_t cx (n, 1); cm_t cbl (n, 1), cbu (n, 1); // RHS init_symm2 (cal); init_symm2 (cau); cal *= cmplx_t (1, 1); cau *= cmplx_t (1, -0.5); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (scal, cx); cbu = prod (scau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::sytrf (scal, ipiv); if (ierr == 0) { lapack::sytrs (scal, ipiv, cbl); print_m (cbl, "cxl"); } else cout << "?" << endl; cout << endl; lw = lapack::sytrf_block ('O', scau); cout << "nb = " << lw << endl; lw *= n; cout << "lw = " << lw << " == " << lapack::sytrf_work ('O', scau) << endl; cout << "mw = " << lapack::sytrf_work ('M', scau) << endl; std::vector cwork (lw); mb = lapack::sytrf_block ('M', scau); cout << "mb = " << mb << endl << endl; ierr = lapack::sytrf (scau, ipiv, cwork); if (ierr == 0) { lapack::sytrs (scau, ipiv, cbu); print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "?" << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_getrf_getrs.cc0000644000175000017500000000442310776160766026250 0ustar andreasandreas // solving A * X = B // in two steps -- factor (getrf()) and solve (getrs()) #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace traits = boost::numeric::bindings::traits; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef std::complex cmpx; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; int main() { cout << endl; size_t n; cout << "n -> "; cin >> n; if (n < 5) { n = 5; cout << "min n = 5" << endl; } cout << endl; m_t a (n, n); // system matrix size_t nrhs = 2; m_t x (n, nrhs), b (n, nrhs); // b -- right-hand side matrix init_symm (a); // [n n-1 n-2 ... 1] // [n-1 n n-1 ... 2] // a = [n-2 n-1 n ... 3] // [ ... ] // [1 2 ... n-1 n] for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } b = prod (a, x); m_t a2 (a); // for part 2 m_t b2 (b); print_m (a, "A"); cout << endl; print_m (b, "B"); cout << endl; ublas::matrix_row ar1 (a, 1), ar3 (a, 3); ublas::matrix_row br1 (b, 1), br3 (b, 3); swap (ar1, ar3); // swap rows to force pivoting swap (br1, br3); print_m (a, "A"); // print `new' system cout << endl; print_m (b, "B"); cout << endl; std::vector ipiv (n); // pivot vector lapack::getrf (a, ipiv); // factor a lapack::getrs (a, ipiv, b); // solve from factorization print_m (b, "X"); cout << endl; print_v (ipiv, "pivots"); cout << endl; ublas::matrix_column a2c1 (a2, 1), a2c4 (a2, 4); ublas::matrix_row b2r1 (b2, 1), b2r4 (b2, 4); swap (a2c1, a2c4); // swap columns swap (b2r1, b2r4); print_m (a2, "A"); // print `new' system cout << endl; print_m (b2, "B"); cout << endl; lapack::getrf (a2, ipiv); // factor a lapack::getrs ('T', a2, ipiv, b2); // solve print_m (b2, "X"); cout << endl; print_v (ipiv, "pivots"); cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/utils.h0000644000175000017500000001203110776160766023543 0ustar andreasandreas #ifndef F_UTILS_H #define F_UTILS_H #include #include #include /////////////////////////////// // vectors // element access: template struct vct_access_traits { typedef typename boost::numeric::bindings::traits::vector_traits::value_type val_t; typedef val_t& ref_t; static ref_t elem (V& v, size_t i) { return v[i]; } }; template struct vct_access_traits { typedef typename boost::numeric::bindings::traits::vector_traits::value_type val_t; typedef val_t ref_t; static ref_t elem (V const& v, size_t i) { return v[i]; } }; template inline typename vct_access_traits::ref_t elem_v (V& v, size_t i) { return vct_access_traits::elem (v, i); } // initialization: struct ident { size_t operator() (size_t i) const { return i; } }; struct iplus1 { size_t operator() (size_t i) const { return i + 1; } }; template struct const_val { T val; const_val (T v = T()) : val (v) {} T operator() (size_t) const { return val; } T operator() (size_t, size_t) const { return val; } }; struct kpp { size_t val; kpp (size_t v = 0) : val (v) {} size_t operator() (size_t) { size_t tmp = val; ++val; return tmp; } size_t operator() (size_t, size_t) { size_t tmp = val; ++val; return tmp; } }; template struct times_plus { T s, a, b; times_plus (T ss, T aa = T(), T bb = T()) : s (ss), a (aa), b (bb) {} T operator() (size_t i) const { return s * (T) i + a; } T operator() (size_t i, size_t j) const { return s * ((T) i + a) + (T) j + b; } }; template void init_v (V& v, F f = F()) { size_t sz = boost::numeric::bindings::traits::vector_traits::size (v); for (std::size_t i = 0; i < sz; ++i) elem_v (v, i) = f (i); } // printing: template void print_v (V const& v, char const* ch = 0) { if (ch) std::cout << ch << ": "; size_t sz = boost::numeric::bindings::traits::vector_traits::size (v); for (std::size_t i = 0; i < sz; ++i) std::cout << elem_v (v, i) << " "; std::cout << std::endl; } ///////////////////////////////////// // matrices // element access: template struct matr_access_traits { typedef typename boost::numeric::bindings::traits::matrix_traits::value_type val_t; typedef val_t& ref_t; static ref_t elem (M& m, size_t i, size_t j) { return m (i, j); } }; template struct matr_access_traits { typedef typename boost::numeric::bindings::traits::matrix_traits::value_type val_t; typedef val_t ref_t; static ref_t elem (M const& m, size_t i, size_t j) { return m (i, j); } }; template inline typename matr_access_traits::ref_t elem_m (M& m, size_t i, size_t j) { return matr_access_traits::elem (m, i, j); } // initialization: struct rws { size_t operator() (size_t i, size_t) const { return i; } }; struct rws1 { size_t operator() (size_t i, size_t) const { return i + 1; } }; struct cls { size_t operator() (size_t, size_t j) const { return j; } }; struct cls1 { size_t operator() (size_t, size_t j) const { return j + 1; } }; template void init_m (M& m, F f = F()) { size_t sz1 = boost::numeric::bindings::traits::matrix_traits::size1 (m); size_t sz2 = boost::numeric::bindings::traits::matrix_traits::size2 (m); for (std::size_t i = 0; i < sz1; ++i) for (std::size_t j = 0; j < sz2; ++j) elem_m (m, i, j) = f (i, j); } template void init_symm (M& m, char uplo = 'f') { size_t n = boost::numeric::bindings::traits::matrix_traits::size1 (m); for (size_t i = 0; i < n; ++i) { elem_m (m, i, i) = n; for (size_t j = i + 1; j < n; ++j) { if (uplo == 'u' || uplo == 'U') elem_m (m, i, j) = n - (j - i); else if (uplo == 'l' || uplo == 'L') elem_m (m, j, i) = n - (j - i); else elem_m (m, i, j) = elem_m (m, j, i) = n - (j - i); } } } // printing: template void print_m (M const& m, char const* ch = 0) { if (ch) std::cout << ch << ":\n"; size_t sz1 = boost::numeric::bindings::traits::matrix_traits::size1 (m); size_t sz2 = boost::numeric::bindings::traits::matrix_traits::size2 (m); for (std::size_t i = 0 ; i < sz1 ; ++i) { for (std::size_t j = 0 ; j < sz2 ; ++j) std::cout << elem_m (m, i, j) << " "; std::cout << std::endl; } // std::cout << std::endl; } template void print_m_data (M const& m, char const* ch = 0) { if (ch) std::cout << ch << " data:\n"; size_t sz = boost::numeric::bindings::traits::matrix_traits ::storage_size (m); typename boost::numeric::bindings::traits::matrix_traits::pointer st = boost::numeric::bindings::traits::matrix_traits::storage (m); for (std::size_t i = 0 ; i < sz ; ++i, ++st) std::cout << *st << " "; std::cout << std::endl; } #endif boost-bindings/libs/numeric/bindings/lapack/test/ublas_hetrf_hetrs.cc0000644000175000017500000000643210776160766026254 0ustar andreasandreas // solving A * X = B // A hermitian // hetrf() & hetrs() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::hermitian_adaptor cherml_t; typedef ublas::hermitian_adaptor chermu_t; int main() { cm_t cal (3, 3), cau (3, 3); // matrices (storage) cherml_t hcal (cal); // hermitian adaptor chermu_t hcau (cau); // hermitian adaptor cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS hcal (0, 0) = cmplx_t (3, 0); hcal (1, 0) = cmplx_t (4, -2); hcal (1, 1) = cmplx_t (5, 0); hcal (2, 0) = cmplx_t (-7, -5); hcal (2, 1) = cmplx_t (0, 3); hcal (2, 2) = cmplx_t (2, 0); hcau (0, 0) = cmplx_t (3, 0); hcau (0, 1) = cmplx_t (4, 2); hcau (0, 2) = cmplx_t (-7, 5); hcau (1, 1) = cmplx_t (5, 0); hcau (1, 2) = cmplx_t (0, -3); hcau (2, 2) = cmplx_t (2, 0); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (hcal, cx); cbu = prod (hcau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; cm_t cal2 (hcal), cau2 (hcau); // for part 2 cm_t cbl2 (cbl), cbu2 (cbu); std::vector ipiv (3); int ierr = lapack::hetrf (hcal, ipiv); if (ierr == 0) { lapack::hetrs (hcal, ipiv, cbl); print_m (cbl, "cxl"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; std::vector cwork (3*64); // 3*64 -- optimal size ierr = lapack::hetrf (hcau, ipiv, cwork); if (ierr == 0) { lapack::hetrs (hcau, ipiv, cbu); print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; // part 2 swap (row (cal2, 0), row (cal2, 2)); swap (column (cal2, 0), column (cal2, 2)); swap (row (cau2, 1), row (cau2, 2)); swap (column (cau2, 1), column (cau2, 2)); print_m (cal2, "cal2"); cout << endl; print_m (cau2, "cau2"); cout << endl; cbl2 = prod (cal2, cx); cbu2 = prod (cau2, cx); print_m (cbl2, "cbl2"); cout << endl; print_m (cbu2, "cbu2"); cout << endl; ierr = lapack::hetrf ('L', cal2, ipiv); if (ierr == 0) { lapack::hetrs ('L', cal2, ipiv, cbl2); print_m (cbl2, "cxl2"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; ierr = lapack::hetrf ('U', cau2, ipiv, cwork); if (ierr == 0) { lapack::hetrs ('U', cau2, ipiv, cbu2); print_v (ipiv, "ipiv"); cout << endl; print_m (cbu2, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_hpsv.cc0000644000175000017500000000423110776013426024700 0ustar andreasandreas // solving A * X = B // A hermitian in packed storage // driver function hesv() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::hermitian_matrix cherml_t; typedef ublas::hermitian_matrix chermu_t; int main() { cherml_t hcal (3, 3); // hermitian matrix chermu_t hcau (3, 3); // hermitian matrix cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS hcal (0, 0) = cmplx_t (3, 0); hcal (1, 0) = cmplx_t (4, -2); hcal (1, 1) = cmplx_t (5, 0); hcal (2, 0) = cmplx_t (-7, -5); hcal (2, 1) = cmplx_t (0, 3); hcal (2, 2) = cmplx_t (2, 0); hcau (0, 0) = cmplx_t (3, 0); hcau (0, 1) = cmplx_t (4, 2); hcau (0, 2) = cmplx_t (-7, 5); hcau (1, 1) = cmplx_t (5, 0); hcau (1, 2) = cmplx_t (0, -3); hcau (2, 2) = cmplx_t (2, 0); print_m (hcal, "hcal"); cout << endl; print_m (hcau, "hcau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (hcal, cx); cbu = prod (hcau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::hpsv (hcal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; std::vector ipiv (3); ierr = lapack::hpsv (hcau, ipiv, cbu); if (ierr == 0) { print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gees.cpp0000644000175000017500000000730410776013426025044 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen // #include "../../blas/test/random.hpp" #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; // Randomize a matrix template void randomize(M& m) { typedef typename M::size_type size_type ; typedef typename M::value_type value_type ; size_type size1 = m.size1() ; size_type size2 = m.size2() ; for (size_type i=0; i() ; } } } // randomize() template int do_memory_type(int n, W workspace) { typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef std::complex< real_type > complex_type ; typedef ublas::matrix matrix_type ; typedef ublas::vector vector_type ; // Set matrix matrix_type a( n, n ); matrix_type z( n, n ); vector_type e1( n ); vector_type e2( n ); randomize( a ); matrix_type a2( a ); // Compute Schur decomposition. lapack::gees( a, e1, z, workspace ) ; // Check Schur factorization if (norm_frobenius( prod( a2, z ) - prod( z, a ) ) >= 10.0* norm_frobenius( a2 ) * std::numeric_limits< real_type >::epsilon() ) return 255 ; lapack::gees( a2, e2, workspace ) ; if (norm_2( e1 - e2 ) > norm_2( e1 ) * std::numeric_limits< real_type >::epsilon()) return 255 ; if (norm_frobenius( a2 - a ) >= 10.0* norm_frobenius( a2 ) * std::numeric_limits< real_type >::epsilon() ) return 255 ; return 0 ; } // do_value_type() template struct Workspace { typedef ublas::vector array_type ; typedef lapack::detail::workspace1< array_type > type ; Workspace(size_t n) : work_( 3*n ) {} type operator() () { return type( work_ ); } array_type work_ ; }; template struct Workspace< std::complex > { typedef ublas::vector real_array_type ; typedef ublas::vector< std::complex > complex_array_type ; typedef lapack::detail::workspace2< complex_array_type,real_array_type > type ; Workspace(size_t n) : work_( 2*n ) , rwork_( n ) {} type operator() () { return type( work_, rwork_ ); } complex_array_type work_ ; real_array_type rwork_ ; }; template int do_value_type() { const int n = 8 ; if (do_memory_type( n, lapack::optimal_workspace() ) ) return 255 ; if (do_memory_type( n, lapack::minimal_workspace() ) ) return 255 ; Workspace work( n ); do_memory_type::type >( n, work() ); return 0; } // do_value_type() int main() { // Run tests for different value_types if (do_value_type()) return 255; if (do_value_type()) return 255; if (do_value_type< std::complex >()) return 255; if (do_value_type< std::complex >()) return 255; std::cout << "Regression test succeeded\n" ; return 0; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesdd.cc0000644000175000017500000000566210776013426025017 0ustar andreasandreas //#define BOOST_NUMERIC_BINDINGS_LAPACK_2 #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef ublas::matrix m_t; typedef ublas::vector v_t; int main() { cout << endl; size_t m = 3, n = 2; size_t minmn = m < n ? m : n; m_t a (m, n); a(0,0) = 1.; a(0,1) = 1.; a(1,0) = 0.; a(1,1) = 1.; a(2,0) = 1.; a(2,1) = 0.; m_t a2 (a); // for part 2 m_t a3 (a); // for part 2 print_m (a, "A"); cout << endl; v_t s (minmn); m_t u (m, m); m_t vt (n, n); size_t lw; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesdd_work ('O', 'N', a); cout << "opt N lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'A', a); cout << "opt A lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'S', a); cout << "opt S lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'O', a); cout << "opt O lw: " << lw << endl; #endif lw = lapack::gesdd_work ('M', 'A', a); cout << "min lw: " << lw << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesdd_work ('O', 'A', a); #endif std::vector w (lw); size_t liw = lapack::gesdd_iwork (a); cout << "liw: " << liw << endl << endl; std::vector iw (liw); lapack::gesdd ('A', a, s, u, vt, w, iw); print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; m_t sm (m, n); for (size_t i = 0; i < s.size(); ++i) sm (i,i) = s (i); print_m (sm, "S"); cout << endl; a = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a, "A == U S V^T"); cout << endl; // part 2 cout << endl << "part 2" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lapack::gesdd ('A', a2, s, u, vt); #else lapack::gesdd ('M', 'A', a2, s, u, vt); #endif print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; for (size_t i = 0; i < s.size(); ++i) sm (i,i) = s (i); print_m (sm, "S"); cout << endl; a2 = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a2, "A == U S V^T"); cout << endl; // part 3 cout << endl << "part 3" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 cout << "opt lw: " << lapack::gesdd_work ('O', 'N', a3) << endl << endl; lapack::gesdd (a3, s); #else cout << "min lw: " << lapack::gesdd_work ('M', 'N', a3) << endl << endl; lapack::gesdd ('M', 'N', a3, s, u, vt); #endif print_v (s, "singular values only"); cout << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_ppsv.cc0000644000175000017500000001335010776013426024712 0ustar andreasandreas // solving A * X = B // A symmetric/hermitian positive definite in packed format // driver function posv() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_matrix symml_t; typedef ublas::hermitian_matrix herml_t; typedef ublas::symmetric_matrix symmu_t; typedef ublas::hermitian_matrix hermu_t; int main() { cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n = 5; size_t nrhs = 2; symml_t sal (n, n); // symmetric matrix symmu_t sau (n, n); // symmetric matrix m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm (sal, 'l'); // [5 0 0 0 0] // [4 5 0 0 0] // al = [3 4 5 0 0] // [2 3 4 5 0] // [1 2 3 4 5] init_symm (sau, 'u'); // [5 4 3 2 1] // [0 5 4 3 2] // au = [0 0 5 4 3] // [0 0 0 5 4] // [0 0 0 0 5] print_m (sal, "sal"); cout << endl; print_m_data (sal, "sal"); cout << endl; print_m (sau, "sau"); cout << endl; print_m_data (sau, "sau"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; lapack::ppsv (sal, bl); print_m (bl, "xl"); cout << endl; lapack::ppsv (sau, bu); print_m (bu, "xu"); cout << endl; ////////////////////////////////////////////////////////// // hermitian cout << "\n==========================================\n" << endl; cout << "complex hermitian (well, not really ;o)\n" << endl; herml_t hal (3, 3); // hermitian matrix hermu_t hau (3, 3); // hermitian matrix cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS init_symm (hal, 'l'); init_symm (hau, 'u'); print_m (hal, "hal"); cout << endl; print_m (hau, "hau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (hal, cx); cbu = prod (hau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::ppsv (hal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; ierr = lapack::ppsv (hau, cbu); if (ierr == 0) print_m (cbu, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; // regular (see ublas_gesv.cc), but not positive definite: hal (0, 0) = cmplx_t (3, 0); hal (1, 0) = cmplx_t (4, -2); hal (1, 1) = cmplx_t (5, 0); hal (2, 0) = cmplx_t (-7, -5); hal (2, 1) = cmplx_t (0, 3); hal (2, 2) = cmplx_t (2, 0); hau (0, 0) = cmplx_t (3, 0); hau (0, 1) = cmplx_t (4, 2); hau (0, 2) = cmplx_t (-7, 5); hau (1, 1) = cmplx_t (5, 0); hau (1, 2) = cmplx_t (0, -3); hau (2, 2) = cmplx_t (2, 0); print_m (hal, "hal"); cout << endl; print_m (hau, "hau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, 1); print_m (cx, "cx"); cout << endl; cbl = prod (hal, cx); cbu = prod (hau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; ierr = lapack::ppsv (hal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; ierr = lapack::ppsv (hau, cbu); if (ierr == 0) print_m (cbu, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; // positive definite: hal (0, 0) = cmplx_t (25, 0); hal (1, 0) = cmplx_t (-5, 5); hal (1, 1) = cmplx_t (51, 0); hal (2, 0) = cmplx_t (10, -5); hal (2, 1) = cmplx_t (4, 6); hal (2, 2) = cmplx_t (71, 0); hau (0, 0) = cmplx_t (25, 0); hau (0, 1) = cmplx_t (-5, -5); hau (0, 2) = cmplx_t (10, 5); hau (1, 1) = cmplx_t (51, 0); hau (1, 2) = cmplx_t (4, -6); hau (2, 2) = cmplx_t (71, 0); print_m (hal, "hal"); cout << endl; print_m (hau, "hau"); cout << endl; cm_t cbl2 (3, 2); cbl2 (0, 0) = cmplx_t (60, -55); cbl2 (1, 0) = cmplx_t (34, 58); cbl2 (2, 0) = cmplx_t (13, -152); cbl2 (0, 1) = cmplx_t (70, 10); cbl2 (1, 1) = cmplx_t (-51, 110); cbl2 (2, 1) = cmplx_t (75, 63); cm_t cbu2 (cbl2); print_m (cbl2, "cbl"); cout << endl; ierr = lapack::ppsv (hal, cbl2); if (ierr == 0) print_m (cbl2, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; ierr = lapack::ppsv (hau, cbu2); if (ierr == 0) print_m (cbu2, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_spsv.cc0000644000175000017500000000732710776013426024724 0ustar andreasandreas // solving A * X = B // A symmetric in packed format // driver function sysv() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_matrix symml_t; typedef ublas::symmetric_matrix csymml_t; typedef ublas::symmetric_matrix symmu_t; typedef ublas::symmetric_matrix csymmu_t; template void init_symm2 (M& m) { for (int i = 0; i < m.size1(); ++i) for (int j = i; j < m.size1(); ++j) m (i, j) = m (j, i) = 1 + j - i; } int main() { cout << endl; cout << "real symmetric\n" << endl; size_t n; cout << "n -> "; cin >> n; if (n < 5) n = 5; cout << "min n = 5" << endl << endl; size_t nrhs = 2; symml_t sal (n, n); // symmetric matrix symmu_t sau (n, n); // symmetric matrix m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm2 (sal); print_m (sal, "sal"); cout << endl; init_symm2 (sau); print_m (sau, "sau"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; symml_t sal1 (sal); // for part 2 symmu_t sau1 (sau); m_t bl1 (bl), bu1 (bu); lapack::spsv (sal, bl); print_m (bl, "xl"); cout << endl; lapack::spsv (sau, bu); print_m (bu, "xu"); cout << endl; // part 2 std::vector ipiv (n); int err = lapack::spsv (sal1, ipiv, bl1); print_m (sal1, "sal1 factored"); cout << endl; print_v (ipiv, "ipiv"); cout << endl; print_m (bl1, "xl1"); cout << endl; err = lapack::spsv (sau1, ipiv, bu1); print_m (sau1, "sau1 factored"); cout << endl; print_v (ipiv, "ipiv"); cout << endl; print_m (bu1, "xu1"); cout << endl; cout << endl; ////////////////////////////////////////////////////////// cout << "\n==========================================\n" << endl; cout << "complex symmetric\n" << endl; csymml_t scal (n, n); // symmetric matrix csymmu_t scau (n, n); // symmetric matrix cm_t cx (n, 1); cm_t cbl (n, 1), cbu (n, 1); // RHS init_symm2 (scal); init_symm2 (scau); scal *= cmplx_t (1, 1); scau *= cmplx_t (1, -0.5); print_m (scal, "scal"); cout << endl; print_m (scau, "scau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (scal, cx); cbu = prod (scau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::spsv (scal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; ierr = lapack::spsv (scau, ipiv, cbu); if (ierr == 0) { print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesvd3.cc0000644000175000017500000000645010776160766025132 0ustar andreasandreas //#define BOOST_NUMERIC_BINDINGS_LAPACK_2 #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef ublas::matrix m_t; typedef ublas::vector v_t; int main() { cout << endl; size_t m = 3, n = 4; size_t minmn = m < n ? m : n; m_t a (m, n); a(0,0) = 2.; a(0,1) = 2.; a(0,2) = 2.; a(0,3) = 2.; a(1,0) = 1.7; a(1,1) = 0.1; a(1,2) = -1.7; a(1,3) = -0.1; a(2,0) = 0.6; a(2,1) = 1.8; a(2,2) = -0.6; a(2,3) = -1.8; m_t a2 (a); // for part 2 m_t a3 (a); // for parts 3 & 4 print_m (a, "A"); cout << endl; m_t sm (m, n); ublas::matrix_vector_range smr (sm, ublas::range (0, minmn), ublas::range (0, minmn)); v_t s (minmn); m_t u (m, m); m_t vt (n, n); size_t lw; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesvd_work ('O', 'N', 'N', a); cout << "opt NN lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'A', 'A', a); cout << "opt AA lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'S', 'S', a); cout << "opt SS lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'O', 'N', a); cout << "opt ON lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'N', 'O', a); cout << "opt NO lw: " << lw << endl; #endif lw = lapack::gesvd_work ('M', 'A', 'A', a); cout << "min lw: " << lw << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesvd_work ('O', 'A', 'A', a); #endif std::vector w (lw); lapack::gesvd ('A', 'A', a, s, u, vt, w); print_v (s, "s"); cout << endl; smr = s; print_m (sm, "S"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; a = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a, "A == U S V^T"); cout << endl; // part 2 cout << endl << "part 2" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lapack::gesvd ('A', 'A', a2, s, u, vt); #else lapack::gesvd ('M', 'A', 'A', a2, s, u, vt); #endif print_v (s, "s"); cout << endl; smr = s; print_m (sm, "S"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; a2 = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a2, "A == U S V^T"); cout << endl; // part 3 -- another check sm = ublas::prod (ublas::trans (u), m_t (ublas::prod (a3, ublas::trans (vt)))); print_m (sm, "S == U^T A V"); cout << endl << endl; // part 4 // singular values only cout << endl << "part 4" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 cout << "opt lw: " << lapack::gesvd_work ('O', 'N', 'N', a3) << endl << endl; lapack::gesvd ('N', 'N', a3, s, u, vt); #else cout << "min lw: " << lapack::gesvd_work ('M', 'N', 'N', a3) << endl << endl; lapack::gesvd ('M', 'N', 'N', a3, s, u, vt); #endif print_v (s, "singular values only"); cout << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/Jamfile0000644000175000017500000000272410776160766023534 0ustar andreasandreassubproject libs/numeric/bindings/lapack/test ; LAPACK_PATH = /usr/lib ; LAPACK_LIB = lapack ; BLAS_PATH = /usr/lib ; BLAS_LIB = blas g2c ; exe lapack : lapack.cpp : $(BOOST_ROOT) $(B_ROOT) $(LAPACK_PATH) $(LAPACK_LIB) ; exe ublas_gees : ublas_gees.cpp : $(BOOST_ROOT) $(B_ROOT) $(LAPACK_PATH) $(BLAS_PATH) $(LAPACK_LIB) $(BLAS_LIB) ; exe ublas_geqrf : ublas_geqrf.cpp : $(BOOST_ROOT) $(B_ROOT) $(LAPACK_PATH) $(BLAS_PATH) $(LAPACK_LIB) $(BLAS_LIB) ; exe ublas_hbev : ublas_hbev.cpp : $(BOOST_ROOT) $(B_ROOT) $(LAPACK_PATH) $(BLAS_PATH) $(LAPACK_LIB) $(BLAS_LIB) ; exe ublas_heev : ublas_heev.cpp : $(BOOST_ROOT) $(B_ROOT) $(LAPACK_PATH) $(BLAS_PATH) $(LAPACK_LIB) $(BLAS_LIB) ; exe ublas_syev : ublas_syev.cpp : $(BOOST_ROOT) $(B_ROOT) $(LAPACK_PATH) $(BLAS_PATH) $(LAPACK_LIB) $(BLAS_LIB) ; boost-bindings/libs/numeric/bindings/lapack/test/ublas_geqrf.cpp0000644000175000017500000000646310776013426025232 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen // #include "../../blas/test/random.hpp" #include #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; // Randomize a matrix template void randomize(M& m) { typedef typename M::size_type size_type ; typedef typename M::value_type value_type ; size_type size1 = m.size1() ; size_type size2 = m.size2() ; for (size_type i=0; i() ; } } } // randomize() template struct transpose { static const char value ; }; template const char transpose::value = 'T'; template struct transpose< std::complex > { static const char value ; }; template const char transpose< std::complex >::value = 'C'; template ublas::triangular_adaptor upper_part(const M& m) { return ublas::triangular_adaptor( m ); } template int do_memory_type(int n, W workspace) { typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef std::complex< real_type > complex_type ; typedef ublas::matrix matrix_type ; typedef ublas::vector vector_type ; // Set matrix matrix_type a( n, n ); vector_type tau( n ); randomize( a ); matrix_type a2( a ); // Compute QR factorization. lapack::geqrf( a, tau, workspace ) ; // Apply the orthogonal transformations to a2 lapack::ormqr( 'L', transpose::value, a, tau, a2, workspace ); // The upper triangular parts of a and a2 must be equal. if (norm_frobenius( upper_part( a - a2 ) ) > std::numeric_limits::epsilon() * 10.0 * norm_frobenius( upper_part( a ) ) ) return 255 ; return 0 ; } // do_value_type() template int do_value_type() { const int n = 8 ; if (do_memory_type( n, lapack::optimal_workspace() ) ) return 255 ; if (do_memory_type( n, lapack::minimal_workspace() ) ) return 255 ; ublas::vector work( n ); do_memory_type > >( n, lapack::workspace(work) ); return 0; } // do_value_type() int main() { // Run tests for different value_types if (do_value_type()) return 255; if (do_value_type()) return 255; if (do_value_type< std::complex >()) return 255; if (do_value_type< std::complex >()) return 255; std::cout << "Regression test succeeded\n" ; return 0; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_hptrf_hptrs.cc0000644000175000017500000000442510776013426026270 0ustar andreasandreas // solving A * X = B // A hermitian in packed storage // hetrf() & hetrs() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::hermitian_matrix cherml_t; typedef ublas::hermitian_matrix chermu_t; int main() { cherml_t hcal (3, 3); // hermitian matrix chermu_t hcau (3, 3); // hermitian matrix cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS hcal (0, 0) = cmplx_t (3, 0); hcal (1, 0) = cmplx_t (4, -2); hcal (1, 1) = cmplx_t (5, 0); hcal (2, 0) = cmplx_t (-7, -5); hcal (2, 1) = cmplx_t (0, 3); hcal (2, 2) = cmplx_t (2, 0); hcau (0, 0) = cmplx_t (3, 0); hcau (0, 1) = cmplx_t (4, 2); hcau (0, 2) = cmplx_t (-7, 5); hcau (1, 1) = cmplx_t (5, 0); hcau (1, 2) = cmplx_t (0, -3); hcau (2, 2) = cmplx_t (2, 0); print_m (hcal, "hcal"); cout << endl; print_m (hcau, "hcau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (hcal, cx); cbu = prod (hcau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; std::vector ipiv (3); int ierr = lapack::hptrf (hcal, ipiv); if (ierr == 0) { lapack::hptrs (hcal, ipiv, cbl); print_v (ipiv, "ipiv"); cout << endl; print_m (cbl, "cxl"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; ierr = lapack::hptrf (hcau, ipiv); if (ierr == 0) { lapack::hptrs (hcau, ipiv, cbu); print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesv.cc0000644000175000017500000000431210776013426024664 0ustar andreasandreas // solving A * X = B // using driver function gesv() #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef std::complex cmpx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; int main() { cout << endl; cout << "real system:" << endl << endl; size_t n = 5; m_t a (n, n); // system matrix size_t nrhs = 2; m_t x (n, nrhs), b (n, nrhs); // b -- right-hand side matrix std::vector ipiv (n); // pivot vector init_symm (a); // [n n-1 n-2 ... 1] // [n-1 n n-1 ... 2] // a = [n-2 n-1 n ... 3] // [ ... ] // [1 2 ... n-1 n] m_t aa (a); // copy of a, because a is `lost' after gesv() for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } b = prod (a, x); print_m (a, "A"); cout << endl; print_m (b, "B"); cout << endl; lapack::gesv (a, ipiv, b); // solving the system, b contains x print_m (b, "X"); cout << endl; x = prod (aa, b); print_m (x, "B = A X"); cout << endl; //////////////////////////////////////////////////////// cout << endl; cout << "complex system:" << endl << endl; cm_t ca (3, 3), cb (3, 1), cx (3, 1); std::vector ipiv2 (3); ca (0, 0) = cmpx_t (3, 0); ca (0, 1) = cmpx_t (4, 2); ca (0, 2) = cmpx_t (-7, 5); ca (1, 0) = cmpx_t (4, -2); ca (1, 1) = cmpx_t (-5, 0); ca (1, 2) = cmpx_t (0, -3); ca (2, 0) = cmpx_t (-7, -5); ca (2, 1) = cmpx_t (0, 3); ca (2, 2) = cmpx_t (2, 0); print_m (ca, "CA"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmpx_t (1, -1); cb = prod (ca, cx); print_m (cb, "CB"); cout << endl; int ierr = lapack::gesv (ca, ipiv2, cb); if (ierr == 0) print_m (cb, "CX"); else cout << "matrix is singular" << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_hesv.cc0000644000175000017500000000624410776013426024673 0ustar andreasandreas // solving A * X = B // A hermitian // driver function hesv() #include #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix cm_t; typedef ublas::hermitian_adaptor cherml_t; typedef ublas::hermitian_adaptor chermu_t; int main() { cm_t cal (3, 3), cau (3, 3); // matrices (storage) cherml_t hcal (cal); // hermitian adaptor chermu_t hcau (cau); // hermitian adaptor cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS hcal (0, 0) = cmplx_t (3, 0); hcal (1, 0) = cmplx_t (4, -2); hcal (1, 1) = cmplx_t (5, 0); hcal (2, 0) = cmplx_t (-7, -5); hcal (2, 1) = cmplx_t (0, 3); hcal (2, 2) = cmplx_t (2, 0); hcau (0, 0) = cmplx_t (3, 0); hcau (0, 1) = cmplx_t (4, 2); hcau (0, 2) = cmplx_t (-7, 5); hcau (1, 1) = cmplx_t (5, 0); hcau (1, 2) = cmplx_t (0, -3); hcau (2, 2) = cmplx_t (2, 0); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (hcal, cx); cbu = prod (hcau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; cm_t cal2 (hcal), cau2 (hcau); // for part 2 cm_t cbl2 (cbl), cbu2 (cbu); int ierr = lapack::hesv (hcal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; std::vector ipiv (3); std::vector cwork (3*64); // 3*64 -- optimal size ierr = lapack::hesv (hcau, ipiv, cbu, cwork); if (ierr == 0) { print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; // part 2 swap (row (cal2, 0), row (cal2, 2)); swap (column (cal2, 0), column (cal2, 2)); swap (row (cau2, 1), row (cau2, 2)); swap (column (cau2, 1), column (cau2, 2)); print_m (cal2, "cal2"); cout << endl; print_m (cau2, "cau2"); cout << endl; cbl2 = prod (cal2, cx); cbu2 = prod (cau2, cx); print_m (cbl2, "cbl2"); cout << endl; print_m (cbu2, "cbu2"); cout << endl; ierr = lapack::hesv ('L', cal2, cbl2); if (ierr == 0) print_m (cbl2, "cxl2"); else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; ierr = lapack::hesv ('U', cau2, ipiv, cbu2, cwork); if (ierr == 0) { print_v (ipiv, "ipiv"); cout << endl; print_m (cbu2, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesdd2.cc0000644000175000017500000000633610776013426025100 0ustar andreasandreas //#define BOOST_NUMERIC_BINDINGS_LAPACK_2 #include #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::vector v_t; typedef ublas::matrix rm_t; typedef ublas::vector rv_t; int main() { cout << endl; size_t m = 1, n = 3; size_t minmn = m < n ? m : n; m_t a (m, n); a(0,0) = cmplx_t (2, -1); a(0,1) = cmplx_t (1, 1); a(0,2) = cmplx_t (-2, 0); m_t a2 (a); // for part 2 m_t a3 (a); // for part 3 print_m (a, "A"); cout << endl; rv_t s (minmn); // singular values are real m_t u (m, m); m_t vt (n, n); size_t lw; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesdd_work ('O', 'N', a); cout << "opt N lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'A', a); cout << "opt A lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'S', a); cout << "opt S lw: " << lw << endl; lw = lapack::gesdd_work ('O', 'O', a); cout << "opt O lw: " << lw << endl; #endif lw = lapack::gesdd_work ('M', 'A', a); cout << "min lw: " << lw << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesdd_work ('O', 'A', a); #endif std::vector w (lw); size_t lrw = lapack::gesdd_rwork ('A', a); cout << "lrw: " << lrw << endl << endl; std::vector rw (lrw); size_t liw = lapack::gesdd_iwork (a); cout << "liw: " << liw << endl << endl; std::vector iw (liw); lapack::gesdd ('A', a, s, u, vt, w, rw, iw); print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; rm_t sm (m, n); for (size_t i = 0; i < s.size(); ++i) sm (i,i) = s (i); print_m (sm, "S"); cout << endl; a = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a, "A == U S V^T"); cout << endl; // part 2 cout << endl << "part 2" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lapack::gesdd ('A', a2, s, u, vt); #else lapack::gesdd ('M', 'A', a2, s, u, vt); #endif print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; for (size_t i = 0; i < s.size(); ++i) sm (i,i) = s (i); print_m (sm, "S"); cout << endl; a2 = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a2, "A == U S V^T"); cout << endl; // part 3 cout << endl << "part 3" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 cout << "opt lw: " << lapack::gesdd_work ('O', 'N', a3) << endl << endl; lapack::gesdd (a3, s); #else cout << "min lw: " << lapack::gesdd_work ('M', 'N', a3) << endl << endl; lapack::gesdd ('M', 'N', a3, s, u, vt); #endif print_v (s, "singular value only"); cout << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesvd.cc0000644000175000017500000000574110776013426025037 0ustar andreasandreas //#define BOOST_NUMERIC_BINDINGS_LAPACK_2 #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef ublas::matrix m_t; typedef ublas::vector v_t; int main() { cout << endl; size_t m = 3, n = 2; size_t minmn = m < n ? m : n; m_t a (m, n); a(0,0) = 1.; a(0,1) = 1.; a(1,0) = 0.; a(1,1) = 1.; a(2,0) = 1.; a(2,1) = 0.; m_t a2 (a); // for part 2 m_t a3 (a); // for part 3 print_m (a, "A"); cout << endl; v_t s (minmn); m_t u (m, m); m_t vt (n, n); size_t lw; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesvd_work ('O', 'N', 'N', a); cout << "opt NN lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'A', 'A', a); cout << "opt AA lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'S', 'S', a); cout << "opt SS lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'O', 'N', a); cout << "opt ON lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'N', 'O', a); cout << "opt NO lw: " << lw << endl; #endif lw = lapack::gesvd_work ('M', 'A', 'A', a); cout << "min lw: " << lw << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesvd_work ('O', 'A', 'A', a); #endif std::vector w (lw); lapack::gesvd ('A', 'A', a, s, u, vt, w); print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; m_t sm (m, n); for (size_t i = 0; i < s.size(); ++i) sm (i,i) = s (i); print_m (sm, "S"); cout << endl; a = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a, "A == U S V^T"); cout << endl; // part 2 cout << endl << "part 2" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lapack::gesvd ('A', 'A', a2, s, u, vt); #else lapack::gesvd ('M', 'A', 'A', a2, s, u, vt); #endif print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; for (size_t i = 0; i < s.size(); ++i) sm (i,i) = s (i); print_m (sm, "S"); cout << endl; a2 = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a2, "A == U S V^T"); cout << endl; // part 3 cout << endl << "part 3" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 cout << "opt lw: " << lapack::gesvd_work ('O', 'N', 'N', a3) << endl << endl; lapack::gesvd (a3, s); #else cout << "min lw: " << lapack::gesvd_work ('M', 'N', 'N', a3) << endl << endl; lapack::gesvd ('M', 'N', 'N', a3, s, u, vt); #endif print_v (s, "singular values only"); cout << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesdd4.cc0000644000175000017500000000373410776160766025113 0ustar andreasandreas // requires LAPACK v. 3.0 #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef ublas::matrix m_t; typedef ublas::vector v_t; int main() { cout << endl; size_t m = 3, n = 4; size_t minmn = m < n ? m : n; m_t a (m, n); a(0,0) = 2.; a(0,1) = 2.; a(0,2) = 2.; a(0,3) = 2.; a(1,0) = 1.7; a(1,1) = 0.1; a(1,2) = -1.7; a(1,3) = -0.1; a(2,0) = 0.6; a(2,1) = 1.8; a(2,2) = -0.6; a(2,3) = -1.8; m_t a2 (a); // for parts 2 & 3 print_m (a, "A"); cout << endl; v_t s (minmn); m_t u (m, minmn); m_t vt (minmn, n); lapack::gesdd (a, s, u, vt); print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl << endl; // part 2 // singular values and singular vectors satisfy A v_i == s_i u_i for (int i = 0; i < minmn; ++i) { cout << "A v_" << i << " == s_" << i << " u_" << i << endl; v_t avi = ublas::prod (a2, ublas::row (vt, i)); print_v (avi); v_t siui = s[i] * ublas::column (u, i); print_v (siui); cout << endl; } cout << endl; // singular values and singular vectors satisfy A^T u_i == s_i v_i for (int i = 0; i < minmn; ++i) { cout << "A^T u_" << i << " == s_" << i << " v_" << i << endl; v_t atui = ublas::prod (trans (a2), ublas::column (u, i)); print_v (atui); v_t sivi = s[i] * ublas::row (vt, i); print_v (sivi); cout << endl; } cout << endl; // part 3 lapack::gesdd (a2, s); print_v (s, "singular values only"); cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_potrf_potrs.cc0000644000175000017500000000720310776013426026303 0ustar andreasandreas // solving A * X = B // A symmetric/hermitian positive definite // factor (potrf()) and solve (potrs()) #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef float real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_adaptor symml_t; typedef ublas::hermitian_adaptor herml_t; typedef ublas::symmetric_adaptor symmu_t; typedef ublas::hermitian_adaptor hermu_t; int main() { // for more descriptive comments see ublas_posv.cc cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n = 5; size_t nrhs = 2; m_t al (n, n), au (n, n); // matrices (storage) symml_t sal (al); // symmetric adaptor symmu_t sau (au); // symmetric adaptor m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm (sal, 'l'); init_symm (sau, 'u'); print_m (sal, "sal"); cout << endl; print_m (al, "al"); cout << endl; print_m (sau, "sau"); cout << endl; print_m (au, "au"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; int ierr = lapack::potrf (sal); if (!ierr) { lapack::potrs (sal, bl); print_m (bl, "xl"); } cout << endl; ierr = lapack::potrf ('U', au); if (!ierr) { lapack::potrs ('U', au, bu); print_m (bu, "xu"); } cout << endl; ////////////////////////////////////////////////////////// // hermitian cout << "\n==========================================\n" << endl; cout << "complex hermitian\n" << endl; cm_t cal (3, 3), cau (3, 3); // matrices (storage) herml_t hal (cal); // hermitian adaptor hermu_t hau (cau); // hermitian adaptor cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS hal (0, 0) = cmplx_t (25, 0); hal (1, 0) = cmplx_t (-5, 5); hal (1, 1) = cmplx_t (51, 0); hal (2, 0) = cmplx_t (10, -5); hal (2, 1) = cmplx_t (4, 6); hal (2, 2) = cmplx_t (71, 0); hau (0, 0) = cmplx_t (25, 0); hau (0, 1) = cmplx_t (-5, -5); hau (0, 2) = cmplx_t (10, 5); hau (1, 1) = cmplx_t (51, 0); hau (1, 2) = cmplx_t (4, -6); hau (2, 2) = cmplx_t (71, 0); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; cm_t cbl2 (3, 2); cbl2 (0, 0) = cmplx_t (60, -55); cbl2 (1, 0) = cmplx_t (34, 58); cbl2 (2, 0) = cmplx_t (13, -152); cbl2 (0, 1) = cmplx_t (70, 10); cbl2 (1, 1) = cmplx_t (-51, 110); cbl2 (2, 1) = cmplx_t (75, 63); cm_t cbu2 (cbl2); print_m (cbl2, "cbl"); cout << endl; ierr = lapack::potrf ('L', cal); if (ierr == 0) { lapack::potrs ('L', cal, cbl2); print_m (cbl2, "cxl"); } else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; ierr = lapack::potrf (hau); if (ierr == 0) { ierr = lapack::potrs (hau, cbu2); print_m (cbu2, "cxu"); } else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_hbev.cpp0000644000175000017500000001350010776160766025052 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen // #include "../../blas/test/random.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; // Fill a matrix template void fill(M& m) { typedef typename M::size_type size_type ; typedef typename M::value_type value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; int size = m.size2() ; int band = m.upper() ; for (int i=0; i(); m(i,i) = random_value(); } } // randomize() template int lower() { return 0; } template <> int lower() { return 2; } template int upper() { return 0; } template <> int upper() { return 2; } template int check_residual(H const& h, E const& e, Z const& z) { typedef typename H::value_type value_type ; typedef typename E::value_type real_type ; // Check eigen decomposition int n = h.size1(); ublas::matrix error( n, n ); error.clear(); // Copy band matrix in error error.assign( h ); assert( norm_frobenius( error - herm( error ) ) == 0.0 ) ; for (int i=0; i= n* norm_2( e ) * std::numeric_limits< real_type >::epsilon() ) ; } // check_residual() template int do_memory_uplo(int n, W& workspace ) { typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef ublas::banded_matrix banded_type ; typedef ublas::matrix matrix_type ; typedef ublas::vector vector_type ; // Set matrix banded_type a( n, n, lower(), upper() ); a.clear(); // Make upper triangular band matrix matrix_type z( n, n ); vector_type e1( n ); vector_type e2( n ); fill( a ); banded_type a2( a ); ublas::hermitian_adaptor h( a ), h2( a2 ); // Compute Schur decomposition. lapack::hbev( h, e1, z, workspace ) ; if (check_residual( h2, e1, z )) return 255 ; lapack::hbev( h2, e2, workspace ) ; if (norm_2( e1 - e2 ) > n * norm_2( e1 ) * std::numeric_limits< real_type >::epsilon()) return 255 ; // Test for a matrix range fill( a ); a2.assign( a ); typedef ublas::matrix_range< banded_type > banded_range ; ublas::range r(1,n-1) ; banded_range a_r( a, r, r ); ublas::hermitian_adaptor< banded_range, UPLO> h_r( a_r ); ublas::vector_range< vector_type> e_r( e1, r ); ublas::matrix_range< matrix_type> z_r( z, r, r ); lapack::hbev( h_r, e_r, z_r, workspace ); if (check_residual( h2(r,r), e_r, z_r )) return 255 ; return 0 ; } // do_memory_uplo() template int do_memory_type(int n, W workspace) { std::cout << " upper\n" ; if (do_memory_uplo(n, workspace)) return 255 ; std::cout << " lower\n" ; if (do_memory_uplo(n, workspace)) return 255 ; return 0 ; } template struct Workspace { typedef ublas::vector array_type ; typedef lapack::detail::workspace1< array_type > type ; Workspace(size_t n) : work_( 3*n-2 ) {} type operator() () { return type( work_ ); } array_type work_ ; }; template struct Workspace< std::complex > { typedef ublas::vector real_array_type ; typedef ublas::vector< std::complex > complex_array_type ; typedef lapack::detail::workspace2< complex_array_type,real_array_type > type ; Workspace(size_t n) : work_( n ) , rwork_( 3*n-2 ) {} type operator() () { return type( work_, rwork_ ); } complex_array_type work_ ; real_array_type rwork_ ; }; template int do_value_type() { const int n = 8 ; std::cout << " optimal workspace\n"; if (do_memory_type( n, lapack::optimal_workspace() ) ) return 255 ; std::cout << " minimal workspace\n"; if (do_memory_type( n, lapack::minimal_workspace() ) ) return 255 ; std::cout << " workspace array\n"; Workspace work( n ); do_memory_type::type >( n, work() ); return 0; } // do_value_type() int main() { // Run tests for different value_types std::cout << "float\n" ; if (do_value_type()) return 255; std::cout << "double\n" ; if (do_value_type()) return 255; std::cout << "complex\n" ; if (do_value_type< std::complex >()) return 255; std::cout << "complex\n" ; if (do_value_type< std::complex >()) return 255; std::cout << "Regression test succeeded\n" ; return 0; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_syev.cpp0000755000175000017500000001040710776160766025122 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen // #include "../../blas/test/random.hpp" #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; // Fill a matrix template void fill(M& m) { typedef typename M::size_type size_type ; typedef typename M::value_type value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; int size = m.size2() ; for (int i=0; i(); m(i,j) = m(j,i); } m(i,i) = random_value(); } } // randomize() template int check_residual(H const& h, E const& e, Z const& z) { typedef typename H::value_type value_type ; typedef typename E::value_type real_type ; // Check eigen decomposition int n = h.size1(); ublas::matrix error( n, n ); error.clear(); // Copy band matrix in error error.assign( h ); assert( norm_frobenius( error - trans( error ) ) == 0.0 ) ; for (int i=0; i= n* norm_2( e ) * std::numeric_limits< real_type >::epsilon() ) ; } // check_residual() template int do_memory_uplo(int n, W& workspace ) { typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef ublas::matrix matrix_type ; typedef ublas::vector vector_type ; // Set matrix matrix_type a( n, n ); a.clear(); vector_type e1( n ); vector_type e2( n ); fill( a ); matrix_type a2( a ); // Compute eigen decomposition. lapack::syev( 'V', UPLO, a, e1, workspace ) ; if (check_residual( a2, e1, a )) return 255 ; lapack::syev( 'N', UPLO, a2, e2, workspace ) ; if (norm_2( e1 - e2 ) > n * norm_2( e1 ) * std::numeric_limits< real_type >::epsilon()) return 255 ; // Test for a matrix range fill( a ); a2.assign( a ); typedef ublas::matrix_range< matrix_type > matrix_range ; ublas::range r(1,n-1) ; matrix_range a_r( a, r, r ); ublas::vector_range< vector_type> e_r( e1, r ); lapack::syev('V', UPLO, a_r, e_r, workspace ); if (check_residual( a2(r,r), e_r, a_r )) return 255 ; return 0 ; } // do_memory_uplo() template int do_memory_type(int n, W workspace) { std::cout << " upper\n" ; if (do_memory_uplo(n, workspace)) return 255 ; std::cout << " lower\n" ; if (do_memory_uplo(n, workspace)) return 255 ; return 0 ; } template struct Workspace { typedef ublas::vector array_type ; typedef lapack::detail::workspace1< array_type > type ; Workspace(size_t n) : work_( 3*n-1 ) {} type operator() () { return type( work_ ); } array_type work_ ; }; template int do_value_type() { const int n = 8 ; std::cout << " optimal workspace\n"; if (do_memory_type( n, lapack::optimal_workspace() ) ) return 255 ; std::cout << " minimal workspace\n"; if (do_memory_type( n, lapack::minimal_workspace() ) ) return 255 ; std::cout << " workspace array\n"; Workspace work( n ); do_memory_type::type >( n, work() ); return 0; } // do_value_type() int main() { // Run tests for different value_types std::cout << "float\n" ; if (do_value_type()) return 255; std::cout << "double\n" ; if (do_value_type()) return 255; std::cout << "Regression test succeeded\n" ; return 0; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_pptrf_pptrs.cc0000644000175000017500000000706010776013426026306 0ustar andreasandreas // solving A * X = B // A symmetric/hermitian positive definite in packed format // factor (potrf()) and solve (potrs()) #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef float real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_matrix symml_t; typedef ublas::hermitian_matrix herml_t; typedef ublas::symmetric_matrix symmu_t; typedef ublas::hermitian_matrix hermu_t; int main() { // for more descriptive comments see ublas_ppsv.cc cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n = 5; size_t nrhs = 2; symml_t sal (5, 5); // symmetric matrix symmu_t sau (5, 5); // symmetric matrix m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm (sal, 'l'); init_symm (sau, 'u'); print_m (sal, "sal"); cout << endl; print_m (sau, "sau"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; int ierr = lapack::pptrf (sal); if (!ierr) { lapack::pptrs (sal, bl); print_m (bl, "xl"); } cout << endl; ierr = lapack::pptrf (sau); if (!ierr) { lapack::pptrs (sau, bu); print_m (bu, "xu"); } cout << endl; ////////////////////////////////////////////////////////// // hermitian cout << "\n==========================================\n" << endl; cout << "complex hermitian\n" << endl; herml_t hal (3, 3); // hermitian matrix hermu_t hau (3, 3); // hermitian matrix cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS hal (0, 0) = cmplx_t (25, 0); hal (1, 0) = cmplx_t (-5, 5); hal (1, 1) = cmplx_t (51, 0); hal (2, 0) = cmplx_t (10, -5); hal (2, 1) = cmplx_t (4, 6); hal (2, 2) = cmplx_t (71, 0); hau (0, 0) = cmplx_t (25, 0); hau (0, 1) = cmplx_t (-5, -5); hau (0, 2) = cmplx_t (10, 5); hau (1, 1) = cmplx_t (51, 0); hau (1, 2) = cmplx_t (4, -6); hau (2, 2) = cmplx_t (71, 0); print_m (hal, "hal"); cout << endl; print_m (hau, "hau"); cout << endl; cm_t cbl2 (3, 2); cbl2 (0, 0) = cmplx_t (60, -55); cbl2 (1, 0) = cmplx_t (34, 58); cbl2 (2, 0) = cmplx_t (13, -152); cbl2 (0, 1) = cmplx_t (70, 10); cbl2 (1, 1) = cmplx_t (-51, 110); cbl2 (2, 1) = cmplx_t (75, 63); cm_t cbu2 (cbl2); print_m (cbl2, "cbl"); cout << endl; ierr = lapack::pptrf (hal); if (ierr == 0) { lapack::pptrs (hal, cbl2); print_m (cbl2, "cxl"); } else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; ierr = lapack::pptrf (hau); if (ierr == 0) { ierr = lapack::pptrs (hau, cbu2); print_m (cbu2, "cxu"); } else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_heev.cpp0000755000175000017500000001116410776160766025064 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen // #include "../../blas/test/random.hpp" #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; // Fill a matrix template void fill(M& m) { typedef typename M::size_type size_type ; typedef typename M::value_type value_type ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; int size = m.size2() ; for (int i=0; i(); m(i,j) = conj( m(j,i ) ) ; } m(i,i) = random_value(); } } // randomize() template int check_residual(H const& h, E const& e, Z const& z) { typedef typename H::value_type value_type ; typedef typename E::value_type real_type ; // Check eigen decomposition int n = h.size1(); ublas::matrix error( n, n ); error.clear(); // Copy band matrix in error error.assign( h ); assert( norm_frobenius( error - herm( error ) ) == 0.0 ) ; for (int i=0; i= n* norm_2( e ) * std::numeric_limits< real_type >::epsilon() ) ; } // check_residual() template int do_memory_uplo(int n, W& workspace ) { typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef ublas::matrix matrix_type ; typedef ublas::vector vector_type ; // Set matrix matrix_type a( n, n ); a.clear(); vector_type e1( n ); vector_type e2( n ); fill( a ); matrix_type a2( a ); // Compute Schur decomposition. lapack::heev( 'V', UPLO, a, e1, workspace ) ; if (check_residual( a2, e1, a )) return 255 ; lapack::heev( 'N', UPLO, a2, e2, workspace ) ; if (norm_2( e1 - e2 ) > n * norm_2( e1 ) * std::numeric_limits< real_type >::epsilon()) return 255 ; // Test for a matrix range fill( a ); a2.assign( a ); typedef ublas::matrix_range< matrix_type > matrix_range ; ublas::range r(1,n-1) ; matrix_range a_r( a, r, r ); ublas::vector_range< vector_type> e_r( e1, r ); lapack::heev( 'V', UPLO, a_r, e_r, workspace ); if (check_residual( a2(r,r), e_r, a_r )) return 255 ; return 0 ; } // do_memory_uplo() template int do_memory_type(int n, W workspace) { std::cout << " upper\n" ; if (do_memory_uplo(n, workspace)) return 255 ; std::cout << " lower\n" ; if (do_memory_uplo(n, workspace)) return 255 ; return 0 ; } template struct Workspace { typedef typename ublas::type_traits::real_type real_type ; typedef ublas::vector< real_type > real_array_type ; typedef ublas::vector< T > complex_array_type ; typedef lapack::detail::workspace2< complex_array_type,real_array_type > type ; Workspace(size_t n) : work_( 2*n-1 ) , rwork_( 3*n-2 ) {} type operator() () { return type( work_, rwork_ ); } complex_array_type work_ ; real_array_type rwork_ ; }; template int do_value_type() { const int n = 8 ; std::cout << " optimal workspace\n"; if (do_memory_type( n, lapack::optimal_workspace() ) ) return 255 ; std::cout << " minimal workspace\n"; if (do_memory_type( n, lapack::minimal_workspace() ) ) return 255 ; std::cout << " workspace array\n"; Workspace work( n ); do_memory_type::type >( n, work() ); return 0; } // do_value_type() int main() { // Run tests for different value_types std::cout << "complex\n" ; if (do_value_type< std::complex >()) return 255; std::cout << "complex\n" ; if (do_value_type< std::complex >()) return 255; std::cout << "Regression test succeeded\n" ; return 0; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesv2.cc0000644000175000017500000000243710776160766024766 0ustar andreasandreas // solving A * X = B // using driver function gesv() #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef ublas::matrix m_t; int main() { cout << endl; size_t n = 5; m_t a (n, n); // system matrix size_t nrhs = 2; m_t x (n, nrhs), b (n, nrhs); // b -- right-hand side matrix init_symm (a); // [n n-1 n-2 ... 1] // [n-1 n n-1 ... 2] // a = [n-2 n-1 n ... 3] // [ ... ] // [1 2 ... n-1 n] m_t aa (a); // copy of a, because a is `lost' after gesv() ublas::matrix_column xc0 (x, 0), xc1 (x, 1); for (int i = 0; i < xc0.size(); ++i) { xc0 (i) = 1.; xc1 (i) = 2.; } b = prod (a, x); print_m (a, "A"); cout << endl; print_m (b, "B"); cout << endl; lapack::gesv (a, b); // solving the system, b contains x print_m (b, "X"); cout << endl; x = prod (aa, b); print_m (x, "B = A X"); cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_posv.cc0000644000175000017500000001433010776160766024722 0ustar andreasandreas // solving A * X = B // A symmetric/hermitian positive definite // driver function posv() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef float real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_adaptor symml_t; typedef ublas::hermitian_adaptor herml_t; typedef ublas::symmetric_adaptor symmu_t; typedef ublas::hermitian_adaptor hermu_t; int main() { cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n = 5; size_t nrhs = 2; m_t al (n, n), au (n, n); // matrices (storage) symml_t sal (al); // symmetric adaptor symmu_t sau (au); // symmetric adaptor m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm (sal, 'l'); // [5 0 0 0 0] // [4 5 0 0 0] // al = [3 4 5 0 0] // [2 3 4 5 0] // [1 2 3 4 5] init_symm (sau, 'u'); // [5 4 3 2 1] // [0 5 4 3 2] // au = [0 0 5 4 3] // [0 0 0 5 4] // [0 0 0 0 5] print_m (sal, "sal"); cout << endl; print_m (al, "al"); cout << endl; print_m_data (sal, "sal"); cout << endl; print_m (sau, "sau"); cout << endl; print_m (au, "au"); cout << endl; print_m_data (sau, "sau"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; m_t al1 (al), au1 (au); // for part 2 m_t bl1 (bl), bu1 (bu); lapack::posv (sal, bl); print_m (bl, "xl"); cout << endl; lapack::posv (sau, bu); print_m (bu, "xu"); cout << endl; // part 2 lapack::posv ('L', al1, bl1); print_m (al1, "al1 factored"); cout << endl; print_m (bl1, "xl1"); cout << endl; lapack::posv ('U', au1, bu1); print_m (au1, "au1 factored"); cout << endl; print_m (bu1, "xu"); cout << endl; ////////////////////////////////////////////////////////// // hermitian cout << "\n==========================================\n" << endl; cout << "complex hermitian (well, not really ;o)\n" << endl; cm_t cal (3, 3), cau (3, 3); // matrices (storage) herml_t hal (cal); // hermitian adaptor hermu_t hau (cau); // hermitian adaptor cm_t cx (3, 1); cm_t cbl (3, 1), cbu (3, 1); // RHS init_symm (hal, 'l'); init_symm (hau, 'u'); print_m (hal, "hal"); cout << endl; print_m (cal, "cal"); cout << endl; print_m (hau, "hau"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (hal, cx); cbu = prod (hau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::posv (hal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; ierr = lapack::posv (hau, cbu); if (ierr == 0) print_m (cbu, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; // regular (see ublas_gesv.cc), but not positive definite: hal (0, 0) = cmplx_t (3, 0); hal (1, 0) = cmplx_t (4, -2); hal (1, 1) = cmplx_t (5, 0); hal (2, 0) = cmplx_t (-7, -5); hal (2, 1) = cmplx_t (0, 3); hal (2, 2) = cmplx_t (2, 0); hau (0, 0) = cmplx_t (3, 0); hau (0, 1) = cmplx_t (4, 2); hau (0, 2) = cmplx_t (-7, 5); hau (1, 1) = cmplx_t (5, 0); hau (1, 2) = cmplx_t (0, -3); hau (2, 2) = cmplx_t (2, 0); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, 1); print_m (cx, "cx"); cout << endl; cbl = prod (hal, cx); cbu = prod (hau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; ierr = lapack::posv (hal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; ierr = lapack::posv (hau, cbu); if (ierr == 0) print_m (cbu, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl; cout << endl; cout << "\n===========================\n" << endl; cout << "complex hermitian\n" << endl; // positive definite: hal (0, 0) = cmplx_t (25, 0); hal (1, 0) = cmplx_t (-5, 5); hal (1, 1) = cmplx_t (51, 0); hal (2, 0) = cmplx_t (10, -5); hal (2, 1) = cmplx_t (4, 6); hal (2, 2) = cmplx_t (71, 0); hau (0, 0) = cmplx_t (25, 0); hau (0, 1) = cmplx_t (-5, -5); hau (0, 2) = cmplx_t (10, 5); hau (1, 1) = cmplx_t (51, 0); hau (1, 2) = cmplx_t (4, -6); hau (2, 2) = cmplx_t (71, 0); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; cm_t cbl2 (3, 2); cbl2 (0, 0) = cmplx_t (60, -55); cbl2 (1, 0) = cmplx_t (34, 58); cbl2 (2, 0) = cmplx_t (13, -152); cbl2 (0, 1) = cmplx_t (70, 10); cbl2 (1, 1) = cmplx_t (-51, 110); cbl2 (2, 1) = cmplx_t (75, 63); cm_t cbu2 (cbl2); print_m (cbl2, "cbl"); cout << endl; ierr = lapack::posv ('L', cal, cbl2); if (ierr == 0) print_m (cbl2, "cxl"); else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; ierr = lapack::posv ('U', cau, cbu2); if (ierr == 0) print_m (cbu2, "cxu"); else cout << "matrix is not positive definite: ierr = " << ierr << endl << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_sptrf_sptrs.cc0000644000175000017500000000654410776013426026322 0ustar andreasandreas // solving A * X = B // A symmetric in packed format // sytrf() & sytrs() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_matrix symml_t; typedef ublas::symmetric_matrix csymml_t; typedef ublas::symmetric_matrix symmu_t; typedef ublas::symmetric_matrix csymmu_t; template void init_symm2 (M& m) { for (int i = 0; i < m.size1(); ++i) for (int j = i; j < m.size1(); ++j) m (i, j) = m (j, i) = 1 + j - i; } int main() { cout << endl; cout << "real symmetric\n" << endl; size_t n; cout << "n -> "; cin >> n; if (n < 5) n = 5; cout << "min n = 5" << endl << endl; size_t nrhs = 2; symml_t sal (n, n); // symmetric matrix symmu_t sau (n, n); // symmetric matrix m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm2 (sal); print_m (sal, "sal"); cout << endl; init_symm2 (sau); print_m (sau, "sau"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; std::vector ipiv (n); int err = lapack::sptrf (sal, ipiv); if (err == 0) { lapack::sptrs (sal, ipiv, bl); print_m (bl, "xl"); } cout << endl; err = lapack::sptrf (sau, ipiv); if (err == 0) { lapack::sptrs (sau, ipiv, bu); print_m (bu, "xu"); } else cout << "?" << endl; cout << endl; ////////////////////////////////////////////////////////// cout << "\n==========================================\n" << endl; cout << "complex symmetric\n" << endl; csymml_t scal (n, n); // symmetric matrix csymmu_t scau (n, n); // symmetric matrix cm_t cx (n, 1); cm_t cbl (n, 1), cbu (n, 1); // RHS init_symm2 (scal); init_symm2 (scau); scal *= cmplx_t (0.1, 0.25); scau *= cmplx_t (-1, -0.5); print_m (scal, "scal"); cout << endl; print_m (scau, "scau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (scal, cx); cbu = prod (scau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::sptrf (scal, ipiv); if (ierr == 0) { lapack::sptrs (scal, ipiv, cbl); print_m (cbl, "cxl"); } else cout << "?" << endl; cout << endl; ierr = lapack::sptrf (scau, ipiv); if (ierr == 0) { lapack::sptrs (scau, ipiv, cbu); print_m (cbu, "cxu"); } else cout << "?" << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesvd2.cc0000644000175000017500000000642010776160766025126 0ustar andreasandreas //#define BOOST_NUMERIC_BINDINGS_LAPACK_2 #include #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::vector v_t; typedef ublas::matrix rm_t; typedef ublas::vector rv_t; int main() { cout << endl; size_t m = 1, n = 3; size_t minmn = m < n ? m : n; m_t a (m, n); a(0,0) = cmplx_t (2, -1); a(0,1) = cmplx_t (1, 1); a(0,2) = cmplx_t (-2, 0); m_t a2 (a); // for part 2 m_t a3 (a); // for part 3 print_m (a, "A"); cout << endl; rv_t s (minmn); // singular values are real m_t u (m, m); m_t vt (n, n); size_t lw; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesvd_work ('O', 'N', 'N', a); cout << "opt NN lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'A', 'A', a); cout << "opt AA lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'S', 'S', a); cout << "opt SS lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'O', 'N', a); cout << "opt ON lw: " << lw << endl; lw = lapack::gesvd_work ('O', 'N', 'O', a); cout << "opt NO lw: " << lw << endl; #endif lw = lapack::gesvd_work ('M', 'A', 'A', a); cout << "min lw: " << lw << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lw = lapack::gesvd_work ('O', 'A', 'A', a); #endif std::vector w (lw); size_t lrw = lapack::gesvd_rwork (a); cout << "lrw: " << lrw << endl << endl; std::vector rw (lrw); lapack::gesvd ('A', 'A', a, s, u, vt, w, rw); print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; rm_t sm (m, n); for (size_t i = 0; i < s.size(); ++i) sm (i,i) = s (i); print_m (sm, "S"); cout << endl; a = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a, "A == U S V^T"); cout << endl; // part 2 cout << endl << "part 2" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 lapack::gesvd ('A', 'A', a2, s, u, vt); #else lapack::gesvd ('M', 'A', 'A', a2, s, u, vt); #endif print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl; for (size_t i = 0; i < s.size(); ++i) sm (i,i) = s (i); print_m (sm, "S"); cout << endl; a2 = ublas::prod (u, m_t (ublas::prod (sm, vt))); print_m (a2, "A == U S V^T"); cout << endl; // part 3 cout << endl << "part 3" << endl << endl; #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 cout << "opt lw: " << lapack::gesvd_work ('O', 'N', 'N', a3) << endl << endl; lapack::gesvd (a3, s); #else cout << "min lw: " << lapack::gesvd_work ('M', 'N', 'N', a3) << endl << endl; lapack::gesvd ('M', 'N', 'N', a3, s, u, vt); #endif print_v (s, "singular values only"); cout << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_steqr.cpp0000644000175000017500000000376610776013426025267 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen // #include "../../blas/test/random.hpp" #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; template int do_value_type() { const int n = 10 ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef std::complex< real_type > complex_type ; typedef ublas::matrix matrix_type ; typedef ublas::vector vector_type ; // Set matrix matrix_type z( n, n ); vector_type d( n ), e ( n - 1 ) ; std::fill( d.begin(), d.end(), 2.0 ) ; std::fill( e.begin(), e.end(), -1.0 ) ; // Compute eigendecomposition. lapack::steqr( 'I', d, e, z ) ; for ( int i=0; i 10 * std::numeric_limits::epsilon() ) return 1 ; if (i>0) { sum = 0.0 ; for (int j=0; j 10 * std::numeric_limits::epsilon() ) return 1 ; } } return 0 ; } // do_value_type() int main() { // Run tests for different value_types if (do_value_type()) return 255; if (do_value_type()) return 255; std::cout << "Regression test succeeded\n" ; return 0; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gesvd4.cc0000644000175000017500000000367710776160766025143 0ustar andreasandreas #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cout; using std::endl; typedef double real_t; typedef ublas::matrix m_t; typedef ublas::vector v_t; int main() { cout << endl; size_t m = 3, n = 4; size_t minmn = m < n ? m : n; m_t a (m, n); a(0,0) = 2.; a(0,1) = 2.; a(0,2) = 2.; a(0,3) = 2.; a(1,0) = 1.7; a(1,1) = 0.1; a(1,2) = -1.7; a(1,3) = -0.1; a(2,0) = 0.6; a(2,1) = 1.8; a(2,2) = -0.6; a(2,3) = -1.8; m_t a2 (a); // for parts 2 & 3 print_m (a, "A"); cout << endl; v_t s (minmn); m_t u (m, minmn); m_t vt (minmn, n); lapack::gesvd (a, s, u, vt); print_v (s, "s"); cout << endl; print_m (u, "U"); cout << endl; print_m (vt, "V^T"); cout << endl << endl; // part 2 // singular values and singular vectors satisfy A v_i == s_i u_i for (int i = 0; i < minmn; ++i) { cout << "A v_" << i << " == s_" << i << " u_" << i << endl; v_t avi = ublas::prod (a2, ublas::row (vt, i)); print_v (avi); v_t siui = s[i] * ublas::column (u, i); print_v (siui); cout << endl; } cout << endl; // singular values and singular vectors satisfy A^T u_i == s_i v_i for (int i = 0; i < minmn; ++i) { cout << "A^T u_" << i << " == s_" << i << " v_" << i << endl; v_t atui = ublas::prod (trans (a2), ublas::column (u, i)); print_v (atui); v_t sivi = s[i] * ublas::row (vt, i); print_v (sivi); cout << endl; } cout << endl; // part 3 lapack::gesvd (a2, s); print_v (s, "singular values only"); cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_sytrd.cpp0000644000175000017500000000367010776013426025270 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen, Karl Meerbergen // #include "../../blas/test/random.hpp" #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; template int do_value_type() { const int n = 10 ; typedef typename boost::numeric::bindings::traits::type_traits::real_type real_type ; typedef std::complex< real_type > complex_type ; typedef ublas::matrix matrix_type ; typedef ublas::vector vector_type ; // Set matrix matrix_type a( n, n ); vector_type d( n ), e ( n - 1 ), tau( n - 1 ) ; for (int i=0; i 10 * std::numeric_limits::epsilon() ) return 1 ; } for ( int i=0; i 10 * std::numeric_limits::epsilon() ) return 1 ; } return 0 ; } // do_value_type() int main() { // Run tests for different value_types if (do_value_type()) return 255; if (do_value_type()) return 255; std::cout << "Regression test succeeded\n" ; return 0; } boost-bindings/libs/numeric/bindings/lapack/test/lapack.cpp0000644000175000017500000000254110776013426024164 0ustar andreasandreas#include "../../blas/test/blas.hpp" #include #include #include template < typename matrix_type > void test_getrf_getrs(matrix_type& lu, matrix_type& x) { typedef typename matrix_type::value_type value_type ; numerics::matrix< value_type > a( lu ) ; // tmp to verify result numerics::matrix< value_type > b( x ) ; // tmp to verify result std::vector< int > ipiv( x.size1() ) ; boost::numeric::bindings::lapack::getrf( lu, ipiv ) ; boost::numeric::bindings::lapack::getrs( 'N', lu, ipiv, x ) ; std::cout << prod(a,x) - b << std::endl ; } template < typename value_type, typename orientation, int size > void test_getrf_getrs_matrix() { numerics::matrix< value_type, orientation > a(size,size) ; random_initialise_matrix( a ) ; numerics::matrix< value_type, orientation > b(size,1) ; random_initialise_matrix( b ) ; test_getrf_getrs( a, b ) ; } int main() { const int size = 5 ; test_getrf_getrs_matrix< double, numerics::column_major, size >() ; test_getrf_getrs_matrix< std::complex< double >, numerics::column_major, size >() ; test_getrf_getrs_matrix< double, numerics::row_major, size >() ; test_getrf_getrs_matrix< std::complex< double >, numerics::row_major, size >() ; return 0 ; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_sysv.cc0000644000175000017500000000765410776160766024752 0ustar andreasandreas // solving A * X = B // A symmetric // driver function sysv() #include #include #include #include #include #include #include #include "utils.h" namespace ublas = boost::numeric::ublas; namespace lapack = boost::numeric::bindings::lapack; using std::size_t; using std::cin; using std::cout; using std::endl; typedef double real_t; typedef std::complex cmplx_t; typedef ublas::matrix m_t; typedef ublas::matrix cm_t; typedef ublas::symmetric_adaptor symml_t; typedef ublas::symmetric_adaptor symmu_t; typedef ublas::symmetric_adaptor csymml_t; typedef ublas::symmetric_adaptor csymmu_t; template void init_symm2 (M& m) { for (int i = 0; i < m.size1(); ++i) for (int j = i; j < m.size1(); ++j) m (i, j) = m (j, i) = 1 + j - i; } int main() { cout << endl; // symmetric cout << "real symmetric\n" << endl; size_t n; cout << "n -> "; cin >> n; if (n < 5) n = 5; cout << "min n = 5" << endl << endl; size_t nrhs = 2; m_t al (n, n), au (n, n); // matrices (storage) symml_t sal (al); // symmetric adaptor symmu_t sau (au); // symmetric adaptor m_t x (n, nrhs); m_t bl (n, nrhs), bu (n, nrhs); // RHS matrices init_symm2 (al); swap (row (al, 1), row (al, 4)); swap (column (al, 1), column (al, 4)); print_m (al, "al"); cout << endl; init_symm2 (au); swap (row (au, 2), row (au, 3)); swap (column (au, 2), column (au, 3)); print_m (au, "au"); cout << endl; for (int i = 0; i < x.size1(); ++i) { x (i, 0) = 1.; x (i, 1) = 2.; } bl = prod (sal, x); bu = prod (sau, x); print_m (bl, "bl"); cout << endl; print_m (bu, "bu"); cout << endl; m_t al1 (al), au1 (au); // for part 2 m_t bl1 (bl), bu1 (bu); lapack::sysv (sal, bl); print_m (bl, "xl"); cout << endl; lapack::sysv (sau, bu); print_m (bu, "xu"); cout << endl; // part 2 std::vector ipiv (n); std::vector work (1); int err = lapack::sysv ('L', al1, ipiv, bl1, work); print_m (al1, "al1 factored"); cout << endl; print_v (ipiv, "ipiv"); cout << endl; print_m (bl1, "xl1"); cout << endl; err = lapack::sysv ('U', au1, ipiv, bu1, work); print_m (au1, "au1 factored"); cout << endl; print_v (ipiv, "ipiv"); cout << endl; print_m (bu1, "xu1"); cout << endl; cout << endl; ////////////////////////////////////////////////////////// cout << "\n==========================================\n" << endl; cout << "complex symmetric\n" << endl; cm_t cal (n, n), cau (n, n); // matrices (storage) csymml_t scal (cal); // symmetric adaptor csymmu_t scau (cau); // symmetric adaptor cm_t cx (n, 1); cm_t cbl (n, 1), cbu (n, 1); // RHS init_symm2 (cal); init_symm2 (cau); cal *= cmplx_t (1, 1); cau *= cmplx_t (1, -0.5); print_m (cal, "cal"); cout << endl; print_m (cau, "cau"); cout << endl; for (int i = 0; i < cx.size1(); ++i) cx (i, 0) = cmplx_t (1, -1); print_m (cx, "cx"); cout << endl; cbl = prod (scal, cx); cbu = prod (scau, cx); print_m (cbl, "cbl"); cout << endl; print_m (cbu, "cbu"); cout << endl; int ierr = lapack::sysv (scal, cbl); if (ierr == 0) print_m (cbl, "cxl"); else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; std::vector cwork (n); ierr = lapack::sysv (scau, ipiv, cbu, cwork); if (ierr == 0) { print_v (ipiv, "ipiv"); cout << endl; print_m (cbu, "cxu"); } else cout << "matrix is not regular: ierr = " << ierr << endl; cout << endl; } boost-bindings/libs/numeric/bindings/lapack/test/convenience.h0000644000175000017500000001302610664547222024674 0ustar andreasandreas#ifndef CONVENIENCE_H #define CONVENIENCE_H #include #include #include #include #include #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace traits = boost::numeric::bindings::traits; // single precision typedefs typedef float freal_t; typedef ublas::matrix fmat_t; typedef ublas::vector fvec_t; // double precision typedefs typedef double dreal_t; typedef ublas::matrix dmat_t; typedef ublas::vector dvec_t; // single precision complex typedefs typedef std::complex fcmplx_t; typedef ublas::matrix fcmat_t; typedef ublas::vector fcvec_t; // double precision complex typedefs typedef std::complex dcmplx_t; typedef ublas::matrix dcmat_t; typedef ublas::vector dcvec_t; // matrix/vector test sizes const int row_size = 3; const int col_size = 3; const int row_range = 2; const int col_range = 2; ////////////////////////////////////////////////////////////////// // // Helper functions and structs to aid with testing // ///////////////////////////////////////////////////////////////// template void matrix_print(StreamType& oss, const std::string& name, const MatType& mat) { const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); oss << name << std::endl; for (int i=0; i < m; ++i) { for (int j=0; j < n; ++j) { oss << mat(i,j) << std::setw(10); } oss << std::setw(0) << std::endl; } } template void vector_print(StreamType& oss, const std::string& name, const VecType& vec) { const int m = traits::vector_size(vec); oss << name << std::endl; for (int i=0; i < m; ++i) { oss << vec(i) << std::endl; } } // structs to create matrices for testing template struct MatrixGenerator {}; template <> struct MatrixGenerator { typedef fmat_t Result; inline Result operator() (size_t m, size_t n) { Result mat(row_size, col_size); mat(0,0) = 8.; mat(0,1) = 1.; mat(0,2) = 6.; mat(1,0) = 3.; mat(1,1) = 5.; mat(1,2) = 7.; mat(2,0) = 4.; mat(2,1) = 9.; mat(2,2) = 2.; return Result(ublas::project(mat, ublas::range(0, m), ublas::range(0, n))); } }; template <> struct MatrixGenerator { typedef dmat_t Result; inline Result operator() (size_t m, size_t n) { Result mat(row_size, col_size); mat(0,0) = 8.; mat(0,1) = 1.; mat(0,2) = 6.; mat(1,0) = 3.; mat(1,1) = 5.; mat(1,2) = 7.; mat(2,0) = 4.; mat(2,1) = 9.; mat(2,2) = 2.; return Result(ublas::project(mat, ublas::range(0, m), ublas::range(0, n))); } }; template <> struct MatrixGenerator { typedef fcmat_t Result; inline Result operator() (size_t m, size_t n) { typedef Result::value_type val_t; Result mat(row_size , col_size); mat(0,0) = val_t(35.,1.); mat(0,1) = val_t(6.,26.); mat(0,2) = val_t(19.,24.); mat(1,0) = val_t(3.,32.); mat(1,1) = val_t(7.,21.); mat(1,2) = val_t(23.,25.); mat(2,0) = val_t(31.,9.); mat(2,1) = val_t(2.,22.); mat(2,2) = val_t(27.,20.); return Result(ublas::project(mat, ublas::range(0, m), ublas::range(0, n))); } }; template <> struct MatrixGenerator { typedef dcmat_t Result; inline Result operator() (size_t m, size_t n) { typedef Result::value_type val_t; Result mat(row_size , col_size); mat(0,0) = val_t(35.,1.); mat(0,1) = val_t(6.,26.); mat(0,2) = val_t(19.,24.); mat(1,0) = val_t(3.,32.); mat(1,1) = val_t(7.,21.); mat(1,2) = val_t(23.,25.); mat(2,0) = val_t(31.,9.); mat(2,1) = val_t(2.,22.); mat(2,2) = val_t(27.,20.); return Result(ublas::project(mat, ublas::range(0, m), ublas::range(0, n))); } }; // structs to create vectors for testing template struct VectorGenerator {}; template <> struct VectorGenerator { typedef fvec_t Result; inline Result operator() (size_t m) { typedef Result::value_type val_t; Result v(m); for (size_t i=0; i < m; ++i) { val_t val = val_t(i+1); v(i) = val; } return v; } }; template <> struct VectorGenerator { typedef dvec_t Result; inline Result operator() (size_t m) { typedef Result::value_type val_t; Result v(m); for (size_t i=0; i < m; ++i) { val_t val = val_t(i+1); v(i) = val; } return v; } }; template <> struct VectorGenerator { typedef fcvec_t Result; inline Result operator() (size_t m) { typedef Result::value_type val_t; Result v(m); for (size_t i=0; i < m; ++i) { val_t::value_type val = val_t::value_type(i); v(i) = val_t(val+1, val+1); } return v; } }; template <> struct VectorGenerator { typedef dcvec_t Result; inline Result operator() (size_t m) { typedef Result::value_type val_t; Result v(m); for (size_t i=0; i < m; ++i) { val_t::value_type val = val_t::value_type(i); v(i) = val_t(val+1, val+1); } return v; } }; #endifboost-bindings/libs/numeric/bindings/lapack/test/ublas_gels.cpp0000644000175000017500000003602710664627350025062 0ustar andreasandreas #include "convenience.h" #include // set to 1 for more output //#define VERBOSE_OUTPUT 1 // set to 1 to write test output to file, otherwise outputs to console #define OUTPUT_TO_FILE 0 // determines which tests to run #define TEST_SQUARE 1 #define TEST_UNDERDETERMINED 0 #define TEST_OVERDETERMINED 0 #define TEST_MULTIPLE_SOLUTION_VECTORS 0 #define TEST_TRANSPOSE 0 // determines if optimal, minimal, or both workspaces are used for testing #define USE_OPTIMAL_WORKSPACE 1 #define USE_MINIMAL_WORKSPACE 0 namespace lapack = boost::numeric::bindings::lapack; // test function declarations template int test_square_gels(StreamType& oss); template int test_under_gels(StreamType& oss); template int test_over_gels(StreamType& oss); template int test_multiple_gels(StreamType& oss); template int test_transpose_gels(StreamType& oss, const char& trans); int main() { // stream for test output typedef std::ostringstream stream_t; stream_t oss; #if TEST_SQUARE oss << "Start Square Matrix Least Squares Tests" << std::endl; oss << "Testing sgels" << std::endl; if (test_square_gels(oss) == 0) { oss << "sgels passed." << std::endl; } oss << "End sgels tests" << std::endl; oss << std::endl; oss << "Testing dgels" << std::endl; if (test_square_gels(oss) == 0) { oss << "dgels passed." << std::endl; } oss << "End dgels tests" << std::endl; oss << std::endl; oss << "Testing cgels" << std::endl; if (test_square_gels(oss) == 0) { oss << "cgels passed." << std::endl; } oss << "End cgels tests" << std::endl; oss << std::endl; oss << "Testing zgels" << std::endl; if (test_square_gels(oss) == 0) { oss << "zgels passed." << std::endl; } oss << "End zgels tests" << std::endl; oss << std::endl; oss << "End Square Matrix Least Squares Tests" << std::endl; #endif #if TEST_UNDERDETERMINED oss << std::endl; oss << "Start Under-determined Matrix Least Squares Test" << std::endl; oss << "Testing sgels" << std::endl; if (test_under_gels(oss) == 0) { oss << "sgels passed." << std::endl; } oss << "End sgels tests" << std::endl; oss << std::endl; oss << "Testing dgels" << std::endl; if (test_under_gels(oss) == 0) { oss << "dgels passed." << std::endl; } oss << "End dgels tests" << std::endl; oss << std::endl; oss << "Testing cgels" << std::endl; if (test_under_gels(oss) == 0) { oss << "cgels passed." << std::endl; } oss << "End cgels tests" << std::endl; oss << std::endl; oss << "Testing zgels" << std::endl; if (test_under_gels(oss) == 0) { oss << "zgels passed." << std::endl; } oss << "End zgels tests" << std::endl; oss << std::endl; oss << "End Underdetermined Matrix Least Squares Tests" << std::endl; #endif #if TEST_OVERDETERMINED oss << std::endl; oss << "Start Overdetermined Matrix Least Squares Test" << std::endl; oss << "Testing sgels" << std::endl; if (test_over_gels(oss) == 0) { oss << "sgels passed." << std::endl; } oss << "End sgels tests" << std::endl; oss << std::endl; oss << "Testing dgels" << std::endl; if (test_over_gels(oss) == 0) { oss << "dgels passed." << std::endl; } oss << "End dgels tests" << std::endl; oss << std::endl; oss << "Testing cgels" << std::endl; if (test_over_gels(oss) == 0) { oss << "cgels passed." << std::endl; } oss << "End cgels tests" << std::endl; oss << std::endl; oss << "Testing zgels" << std::endl; if (test_over_gels(oss) == 0) { oss << "zgels passed." << std::endl; } oss << "End zgels tests" << std::endl; oss << std::endl; oss << "End Overdetermined Matrix Least Squares Test" << std::endl; #endif #if TEST_MULTIPLE_SOLUTION_VECTORS oss << std::endl; oss << "Start Multiple Solution Vectors Least Squares Test" << std::endl; oss << "Testing sgels" << std::endl; if (test_multiple_gels(oss) == 0) { oss << "sgels passed." << std::endl; } oss << "End sgels tests" << std::endl; oss << std::endl; oss << "Testing dgels" << std::endl; if (test_multiple_gels(oss) == 0) { oss << "dgels passed." << std::endl; } oss << "End dgels tests" << std::endl; oss << std::endl; oss << "Testing cgels" << std::endl; if (test_multiple_gels(oss) == 0) { oss << "cgels passed." << std::endl; } oss << "End cgels tests" << std::endl; oss << std::endl; oss << "Testing zgels" << std::endl; if (test_multiple_gels(oss) == 0) { oss << "zgels passed." << std::endl; } oss << "End zgels tests" << std::endl; oss << std::endl; oss << "End Multiple Solution Vectors Least Squares Test" << std::endl; #endif #if TEST_TRANSPOSE oss << std::endl; oss << "Start Transpose Least Squares Test" << std::endl; oss << "Testing sgels" << std::endl; if (test_transpose_gels(oss, 'T') == 0) { oss << "sgels passed." << std::endl; } oss << "End sgels tests" << std::endl; oss << std::endl; oss << "Testing dgels" << std::endl; if (test_transpose_gels(oss, 'T') == 0) { oss << "dgels passed." << std::endl; } oss << "End dgels tests" << std::endl; oss << std::endl; oss << "Testing cgels" << std::endl; if (test_transpose_gels(oss, 'C') == 0) { oss << "cgels passed." << std::endl; } oss << "End cgels tests" << std::endl; oss << std::endl; oss << "Testing zgels" << std::endl; if (test_transpose_gels(oss, 'C') == 0) { oss << "zgels passed." << std::endl; } oss << "End zgels tests" << std::endl; oss << std::endl; oss << "End Transpose Least Squares Test" << std::endl; #endif // Finished testing std::cout << std::endl; std::cout << "Tests Completed." << std::endl; std::cout << std::endl; #if OUTPUT_TO_FILE std::string filename; std::cout << "Enter filename to write test results: "; std::getline(std::cin, filename); std::ofstream testFile(filename.c_str()); if (testFile) { testFile << oss.str(); testFile.close(); } #else std::cout << oss.str() << std::endl; #endif // wait for user to finish std::string done; std::cout << "Press Enter to exit"; std::getline(std::cin, done); } // tests square system (m-by-n where m == n) template int test_square_gels(StreamType& oss) { // return value int err = 0; // square matrix test MatType mat(MatrixGenerator()(row_size, col_size)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gels('N', optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gels('N', minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif // check A*x=B #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests overdetermined system (m-by-n where m < n) template int test_under_gels(StreamType& oss) { // return value int err = 0; // under-determined matrix test MatType mat(MatrixGenerator()(row_range, col_size)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gels('N', optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gels('N', minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif // check A*x=B #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests overdetermined system (m-by-n where m > n) template int test_over_gels(StreamType& oss) { // return value int err = 0; // overdetermined matrix test MatType mat(MatrixGenerator()(row_size, col_range)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gels('N', optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gels('N', minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif // check A*x=B #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests multiple solution vectors stored column-wise in B for equation A*x=B template int test_multiple_gels(StreamType& oss) { // return value int err = 0; // multiple solutions vectors test MatType mat(MatrixGenerator()(row_size, col_size)); MatType vec(mat.size1(), 2); ublas::column(vec, 0) = VectorGenerator()(mat.size1()); ublas::column(vec, 1) = VectorGenerator()(mat.size1()); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); const int nrhs = traits::matrix_size2(vec); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); MatType optimalvec(vec); err += lapack::gels('N', optimalmat, optimalvec, lapack::optimal_workspace()); MatType optimalanswer(ublas::project(optimalvec, ublas::range(0, n), ublas::range(0, nrhs))); MatType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); MatType minimalvec(vec); err += lapack::gels('N', minimalmat, minimalvec, lapack::minimal_workspace()); MatType minimalanswer(ublas::project(minimalvec, ublas::range(0, n), ublas::range(0, nrhs))); MatType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; matrix_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE matrix_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE matrix_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif // check A*x=B #if USE_OPTIMAL_WORKSPACE matrix_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE matrix_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } template int test_transpose_gels(StreamType& oss, const char& trans) { // return value int err = 0; // overdetermined matrix test MatType mat(MatrixGenerator()(row_size, col_size)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gels(trans, optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gels(trans, minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif // check A*x=B #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; }boost-bindings/libs/numeric/bindings/lapack/test/ublas_gelsd.cpp0000644000175000017500000003112010664627322025212 0ustar andreasandreas #include "convenience.h" #include // set to 1 for more output //#define VERBOSE_OUTPUT 0 // set to 1 to write test output to file, otherwise outputs to console #define OUTPUT_TO_FILE 0 // determines which tests to run #define TEST_SQUARE 1 #define TEST_UNDERDETERMINED 0 #define TEST_OVERDETERMINED 0 #define TEST_MULTIPLE_SOLUTION_VECTORS 0 // determines if optimal, minimal, or both workspaces are used for testing #define USE_OPTIMAL_WORKSPACE 1 #define USE_MINIMAL_WORKSPACE 0 namespace lapack = boost::numeric::bindings::lapack; // test function declarations template int test_square_gelsd(StreamType& oss); template int test_under_gelsd(StreamType& oss); template int test_over_gelsd(StreamType& oss); template int test_multiple_gelsd(StreamType& oss); template int test_transpose_gel(StreamType& oss, const char& trans); int main() { // stream for test output typedef std::ostringstream stream_t; stream_t oss; #if TEST_SQUARE oss << "Start Square Matrix Least Squares Tests" << std::endl; oss << "Testing sgelsd" << std::endl; if (test_square_gelsd(oss) == 0) { oss << "sgelsd passed." << std::endl; } oss << "End sgelsd tests" << std::endl; oss << std::endl; oss << "Testing dgelsd" << std::endl; if (test_square_gelsd(oss) == 0) { oss << "dgelsd passed." << std::endl; } oss << "End dgelsd tests" << std::endl; oss << std::endl; oss << "Testing cgelsd" << std::endl; if (test_square_gelsd(oss) == 0) { oss << "cgelsd passed." << std::endl; } oss << "End cgelsd tests" << std::endl; oss << std::endl; oss << "Testing zgelsd" << std::endl; if (test_square_gelsd(oss) == 0) { oss << "zgelsd passed." << std::endl; } oss << "End zgelsd tests" << std::endl; oss << std::endl; oss << "End Square Matrix Least Squares Tests" << std::endl; #endif #if TEST_UNDERDETERMINED oss << std::endl; oss << "Start Under-determined Matrix Least Squares Test" << std::endl; oss << "Testing sgelsd" << std::endl; if (test_under_gelsd(oss) == 0) { oss << "sgelsd passed." << std::endl; } oss << "End sgelsd tests" << std::endl; oss << std::endl; oss << "Testing dgelsd" << std::endl; if (test_under_gelsd(oss) == 0) { oss << "dgelsd passed." << std::endl; } oss << "End dgelsd tests" << std::endl; oss << std::endl; oss << "Testing cgelsd" << std::endl; if (test_under_gelsd(oss) == 0) { oss << "cgelsd passed." << std::endl; } oss << "End cgelsd tests" << std::endl; oss << std::endl; oss << "Testing zgelsd" << std::endl; if (test_under_gelsd(oss) == 0) { oss << "zgelsd passed." << std::endl; } oss << "End zgelsd tests" << std::endl; oss << std::endl; oss << "End Underdetermined Matrix Least Squares Tests" << std::endl; #endif #if TEST_OVERDETERMINED oss << std::endl; oss << "Start Overdetermined Matrix Least Squares Test" << std::endl; oss << "Testing sgelsd" << std::endl; if (test_over_gelsd(oss) == 0) { oss << "sgelsd passed." << std::endl; } oss << "End sgelsd tests" << std::endl; oss << std::endl; oss << "Testing dgelsd" << std::endl; if (test_over_gelsd(oss) == 0) { oss << "dgelsd passed." << std::endl; } oss << "End dgelsd tests" << std::endl; oss << std::endl; oss << "Testing cgelsd" << std::endl; if (test_over_gelsd(oss) == 0) { oss << "cgelsd passed." << std::endl; } oss << "End cgelsd tests" << std::endl; oss << std::endl; oss << "Testing zgelsd" << std::endl; if (test_over_gelsd(oss) == 0) { oss << "zgelsd passed." << std::endl; } oss << "End zgelsd tests" << std::endl; oss << std::endl; oss << "End Overdetermined Matrix Least Squares Test" << std::endl; #endif #if TEST_MULTIPLE_SOLUTION_VECTORS oss << std::endl; oss << "Start Multiple Solution Vectors Least Squares Test" << std::endl; oss << "Testing sgelsd" << std::endl; if (test_multiple_gelsd(oss) == 0) { oss << "sgelsd passed." << std::endl; } oss << "End sgelsd tests" << std::endl; oss << std::endl; oss << "Testing dgelsd" << std::endl; if (test_multiple_gelsd(oss) == 0) { oss << "dgelsd passed." << std::endl; } oss << "End dgelsd tests" << std::endl; oss << std::endl; oss << "Testing cgelsd" << std::endl; if (test_multiple_gelsd(oss) == 0) { oss << "cgelsd passed." << std::endl; } oss << "End cgelsd tests" << std::endl; oss << std::endl; oss << "Testing zgelsd" << std::endl; if (test_multiple_gelsd(oss) == 0) { oss << "zgelsd passed." << std::endl; } oss << "End zgelsd tests" << std::endl; oss << std::endl; oss << "End Multiple Solution Vectors Least Squares Test" << std::endl; #endif #if OUTPUT_TO_FILE // Finished testing std::cout << std::endl; std::cout << "Tests Completed." << std::endl; std::cout << std::endl; std::string filename; std::cout << "Enter filename to write test results: "; std::getline(std::cin, filename); std::ofstream testFile(filename.c_str()); if (testFile) { testFile << oss.str(); testFile.close(); } #else std::cout << oss.str() << std::endl; // Finished testing std::cout << std::endl; std::cout << "Tests Completed." << std::endl; std::cout << std::endl; #endif // wait for user to finish std::string done; std::cout << "Press Enter to exit"; std::getline(std::cin, done); } // tests square system (m-by-n where m == n) template int test_square_gelsd(StreamType& oss) { // return value int err = 0; // square matrix test MatType mat(MatrixGenerator()(row_size, col_size)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gelsd(optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gelsd(minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif #if USE_OPTIMAL_WORKSPACE // check A*x=B vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests overdetermined system (m-by-n where m < n) template int test_under_gelsd(StreamType& oss) { // return value int err = 0; // under-determined matrix test MatType mat(MatrixGenerator()(row_range, col_size)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gelsd(optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gelsd(minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif #if USE_OPTIMAL_WORKSPACE // check A*x=B vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests overdetermined system (m-by-n where m > n) template int test_over_gelsd(StreamType& oss) { // return value int err = 0; // overdetermined matrix test MatType mat(MatrixGenerator()(row_size, col_range)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gelsd(optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gelsd(minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif #if USE_OPTIMAL_WORKSPACE // check A*x=B vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests multiple solution vectors stored column-wise in B for equation A*x=B template int test_multiple_gelsd(StreamType& oss) { // return value int err = 0; // multiple solutions vectors test MatType mat(MatrixGenerator()(row_size, col_size)); MatType vec(mat.size1(), 2); ublas::column(vec, 0) = VectorGenerator()(mat.size1()); ublas::column(vec, 1) = VectorGenerator()(mat.size1()); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); const int nrhs = traits::matrix_size2(vec); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); MatType optimalvec(vec); err += lapack::gelsd(optimalmat, optimalvec, lapack::optimal_workspace()); MatType optimalanswer(ublas::project(optimalvec, ublas::range(0, n), ublas::range(0, nrhs))); MatType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); MatType minimalvec(vec); err += lapack::gelsd(minimalmat, minimalvec, lapack::minimal_workspace()); MatType minimalanswer(ublas::project(minimalvec, ublas::range(0, n), ublas::range(0, nrhs))); MatType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; matrix_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE matrix_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE matrix_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif #if USE_OPTIMAL_WORKSPACE // check A*x=B matrix_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE matrix_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } boost-bindings/libs/numeric/bindings/lapack/test/ublas_gelss.cpp0000644000175000017500000003111610664627362025242 0ustar andreasandreas #include "convenience.h" #include // set to 1 for more output //#define VERBOSE_OUTPUT 0 // set to 1 to write test output to file, otherwise outputs to console #define OUTPUT_TO_FILE 0 // determines which tests to run #define TEST_SQUARE 1 #define TEST_UNDERDETERMINED 0 #define TEST_OVERDETERMINED 0 #define TEST_MULTIPLE_SOLUTION_VECTORS 0 // determines if optimal, minimal, or both workspaces are used for testing #define USE_OPTIMAL_WORKSPACE 1 #define USE_MINIMAL_WORKSPACE 0 namespace lapack = boost::numeric::bindings::lapack; // test function declarations template int test_square_gelss(StreamType& oss); template int test_under_gelss(StreamType& oss); template int test_over_gelss(StreamType& oss); template int test_multiple_gelss(StreamType& oss); template int test_transpose_gel(StreamType& oss, const char& trans); int main() { // stream for test output typedef std::ostringstream stream_t; stream_t oss; #if TEST_SQUARE oss << "Start Square Matrix Least Squares Tests" << std::endl; oss << "Testing sgelss" << std::endl; if (test_square_gelss(oss) == 0) { oss << "sgelss passed." << std::endl; } oss << "End sgelss tests" << std::endl; oss << std::endl; oss << "Testing dgelss" << std::endl; if (test_square_gelss(oss) == 0) { oss << "dgelss passed." << std::endl; } oss << "End dgelss tests" << std::endl; oss << std::endl; oss << "Testing cgelss" << std::endl; if (test_square_gelss(oss) == 0) { oss << "cgelss passed." << std::endl; } oss << "End cgelss tests" << std::endl; oss << std::endl; oss << "Testing zgelss" << std::endl; if (test_square_gelss(oss) == 0) { oss << "zgelss passed." << std::endl; } oss << "End zgelss tests" << std::endl; oss << std::endl; oss << "End Square Matrix Least Squares Tests" << std::endl; #endif #if TEST_UNDERDETERMINED oss << std::endl; oss << "Start Under-determined Matrix Least Squares Test" << std::endl; oss << "Testing sgelss" << std::endl; if (test_under_gelss(oss) == 0) { oss << "sgelss passed." << std::endl; } oss << "End sgelss tests" << std::endl; oss << std::endl; oss << "Testing dgelss" << std::endl; if (test_under_gelss(oss) == 0) { oss << "dgelss passed." << std::endl; } oss << "End dgelss tests" << std::endl; oss << std::endl; oss << "Testing cgelss" << std::endl; if (test_under_gelss(oss) == 0) { oss << "cgelss passed." << std::endl; } oss << "End cgelss tests" << std::endl; oss << std::endl; oss << "Testing zgelss" << std::endl; if (test_under_gelss(oss) == 0) { oss << "zgelss passed." << std::endl; } oss << "End zgelss tests" << std::endl; oss << std::endl; oss << "End Underdetermined Matrix Least Squares Tests" << std::endl; #endif #if TEST_OVERDETERMINED oss << std::endl; oss << "Start Overdetermined Matrix Least Squares Test" << std::endl; oss << "Testing sgelss" << std::endl; if (test_over_gelss(oss) == 0) { oss << "sgelss passed." << std::endl; } oss << "End sgelss tests" << std::endl; oss << std::endl; oss << "Testing dgelss" << std::endl; if (test_over_gelss(oss) == 0) { oss << "dgelss passed." << std::endl; } oss << "End dgelss tests" << std::endl; oss << std::endl; oss << "Testing cgelss" << std::endl; if (test_over_gelss(oss) == 0) { oss << "cgelss passed." << std::endl; } oss << "End cgelss tests" << std::endl; oss << std::endl; oss << "Testing zgelss" << std::endl; if (test_over_gelss(oss) == 0) { oss << "zgelss passed." << std::endl; } oss << "End zgelss tests" << std::endl; oss << std::endl; oss << "End Overdetermined Matrix Least Squares Test" << std::endl; #endif #if TEST_MULTIPLE_SOLUTION_VECTORS oss << std::endl; oss << "Start Multiple Solution Vectors Least Squares Test" << std::endl; oss << "Testing sgelss" << std::endl; if (test_multiple_gelss(oss) == 0) { oss << "sgelss passed." << std::endl; } oss << "End sgelss tests" << std::endl; oss << std::endl; oss << "Testing dgelss" << std::endl; if (test_multiple_gelss(oss) == 0) { oss << "dgelss passed." << std::endl; } oss << "End dgelss tests" << std::endl; oss << std::endl; oss << "Testing cgelss" << std::endl; if (test_multiple_gelss(oss) == 0) { oss << "cgelss passed." << std::endl; } oss << "End cgelss tests" << std::endl; oss << std::endl; oss << "Testing zgelss" << std::endl; if (test_multiple_gelss(oss) == 0) { oss << "zgelss passed." << std::endl; } oss << "End zgelss tests" << std::endl; oss << std::endl; oss << "End Multiple Solution Vectors Least Squares Test" << std::endl; #endif #if OUTPUT_TO_FILE // Finished testing std::cout << std::endl; std::cout << "Tests Completed." << std::endl; std::cout << std::endl; std::string filename; std::cout << "Enter filename to write test results: "; std::getline(std::cin, filename); std::ofstream testFile(filename.c_str()); if (testFile) { testFile << oss.str(); testFile.close(); } #else std::cout << oss.str() << std::endl; // Finished testing std::cout << std::endl; std::cout << "Tests Completed." << std::endl; std::cout << std::endl; #endif // wait for user to finish std::string done; std::cout << "Press Enter to exit"; std::getline(std::cin, done); } // tests square system (m-by-n where m == n) template int test_square_gelss(StreamType& oss) { // return value int err = 0; // square matrix test MatType mat(MatrixGenerator()(row_size, col_size)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gelss(optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gelss(minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif #if USE_OPTIMAL_WORKSPACE // check A*x=B vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests overdetermined system (m-by-n where m < n) template int test_under_gelss(StreamType& oss) { // return value int err = 0; // under-determined matrix test MatType mat(MatrixGenerator()(row_range, col_size)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gelss(optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gelss(minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif #if USE_OPTIMAL_WORKSPACE // check A*x=B vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests overdetermined system (m-by-n where m > n) template int test_over_gelss(StreamType& oss) { // return value int err = 0; // overdetermined matrix test MatType mat(MatrixGenerator()(row_size, col_range)); VecType vec(VectorGenerator()(row_size)); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); VecType optimalvec(vec); err += lapack::gelss(optimalmat, optimalvec, lapack::optimal_workspace()); VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); VecType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); VecType minimalvec(vec); err += lapack::gelss(minimalmat, minimalvec, lapack::minimal_workspace()); VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); VecType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; vector_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE vector_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif #if USE_OPTIMAL_WORKSPACE // check A*x=B vector_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE vector_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } // tests multiple solution vectors stored column-wise in B for equation A*x=B template int test_multiple_gelss(StreamType& oss) { // return value int err = 0; // multiple solutions vectors test MatType mat(MatrixGenerator()(row_size, col_size)); MatType vec(mat.size1(), 2); ublas::column(vec, 0) = VectorGenerator()(mat.size1()); ublas::column(vec, 1) = VectorGenerator()(mat.size1()); const int m = traits::matrix_size1(mat); const int n = traits::matrix_size2(mat); const int nrhs = traits::matrix_size2(vec); #if USE_OPTIMAL_WORKSPACE MatType optimalmat(mat); MatType optimalvec(vec); err += lapack::gelss(optimalmat, optimalvec, lapack::optimal_workspace()); MatType optimalanswer(ublas::project(optimalvec, ublas::range(0, n), ublas::range(0, nrhs))); MatType optimal_check = ublas::prod(mat, optimalanswer); #endif #if USE_MINIMAL_WORKSPACE MatType minimalmat(mat); MatType minimalvec(vec); err += lapack::gelss(minimalmat, minimalvec, lapack::minimal_workspace()); MatType minimalanswer(ublas::project(minimalvec, ublas::range(0, n), ublas::range(0, nrhs))); MatType minimal_check = ublas::prod(mat, minimalanswer); #endif matrix_print(oss, "A", mat); oss << std::endl; matrix_print(oss, "B", vec); oss << std::endl; #if USE_OPTIMAL_WORKSPACE matrix_print(oss, "optimal workspace x", optimalanswer); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE matrix_print(oss, "minimal workspace x", minimalanswer); oss << std::endl; #endif #if USE_OPTIMAL_WORKSPACE // check A*x=B matrix_print(oss, "optimal A*x=B", optimal_check); oss << std::endl; #endif #if USE_MINIMAL_WORKSPACE matrix_print(oss, "minimal A*x=B", minimal_check); oss << std::endl; #endif return err; } boost-bindings/libs/numeric/bindings/lapack/doc/0000755000175000017500000000000010776013426022011 5ustar andreasandreasboost-bindings/libs/numeric/bindings/lapack/doc/index.html0000644000175000017500000013046610776013426024020 0ustar andreasandreas Boost.Numeric.Bindings.LAPACK

C++ Boost

Boost.Numeric.Bindings.LAPACK

Back to Bindings Library Synopsis

Contents

  1. Introduction
  2. Using LAPACK bindings
    1. Linear Equations
      1. General System
      2. Positive Definite System
      3. Positive Definite System with Coefficient Matrix in Packed Storage
      4. Symmetric (Real and Complex) Indefinite System
      5. Symmetric Indefinite System with Coefficient Matrix in Packed Storage
      6. Hermitian Indefinite System
      7. Hermitian Indefinite System with Coefficient Matrix in Packed Storage
    2. Singular Value Decomposition
      1. Simple Driver
      2. Divide and Conquer Driver
  3. Extending LAPACK bindings

1. Introduction

To introduce LAPACK, let us quote from the LAPACK Users' Guide:

``LAPACK is a library of Fortran 77 subroutines for solving the most commonly occurring problems in numerical linear algebra. It has been designed to be efficient on a wide range of modern high-performance computers. The name LAPACK is an acronym for Linear Algebra PACKage.

LAPACK can solve systems of linear equations, linear least squares problems, eigenvalue problems and singular value problems. LAPACK can also handle many associated computations such as matrix factorizations or estimating condition numbers.

LAPACK contains driver routines for solving standard types of problems, computational routines to perform a distinct computational task, and auxiliary routines to perform a certain subtask or common low-level computation. Each driver routine typically calls a sequence of computational routines. Taken as a whole, the computational routines can perform a wider range of tasks than are covered by the driver routines. [...]

Dense and band matrices are provided for, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices.''

For a complete overview of the LAPACK routines see chapter Contents of LAPACK in the LAPACK Users' Guide.

There is also the C version of LAPACK, called CLAPACK. ``The CLAPACK library was built using a Fortran to C conversion utility called f2c. The entire Fortran 77 LAPACK library is run through f2c to obtain C code, and then modified to improve readability. CLAPACK's goal is to provide LAPACK for someone who does not have access to a Fortran compiler.'' [quote from CLAPACK readme]

LAPACK Bindings Library provides generic, higher level interface to LAPACK routines. By `generic' we mean that bindings are based on traits and therefore can be used with various (sparse) matrix and vector classes, and by `higher level' that some complexities of the Fortran or C interfaces and calling conventions are hidden from the user. But, as LAPACK was written in Fortran (and CLAPACK is a direct conversion to C), matrices must have column major storage order.

2. Using LAPACK bindings

All header files are in the directory boost/numeric/bindings/lapack.

All `public' functions are in the namespace boost::numeric::bindings::lapack.

Note: LAPACK bindings can be used with either LAPACK or CLAPACK libraries. We recommend to use bindings with genuine LAPACK. But if you use CLAPACK, define BOOST_NUMERIC_BINDINGS_USE_CLAPACK before the inclusion of LAPACK bindings files.

2.1 Linear Equations

We will write a system of simultaneous linear equations with several right-hand sides as

A X = B,

where A is the coefficient matrix, the columns of B are the individual right hand sides and the columns of X are corresponding unknown vectors.

To find the solution (i.e. determine X, given A and B), A is first factorised as a product of triangular matrices (and in some cases also a diagonal matrix or permutation matrix), and then a backward or forward substitution is carried out. The form of the factorisation depends on the structure and properties of the matrix A:

  • general matrices -- LU factorisation with partial pivoting: A = PLU, where P is a permutation matrix, L is lower triangular (with unit diagonal elements) and U is upper triangular;
  • symmetric and Hermitian positive definite matrices -- Cholesky factorisation: A = UTU or A = LLT (A symmetric) and A = UHU or A = LLH (A Hermitian), where U and L are upper and lower triangular, respectively;
  • symmetric and Hermitian indefinite matrices -- Bunch-Kaufman factorisation: A = UDUT or A = LDLT or A = UDUH or A = LDLH, where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with diagonal blocks of order 1 or 2.

LAPACK bindings follow LAPACK's naming scheme, except for the first letter which denotes the type of the matrix elements as it is not needed (because of function overloading and templates). So, all function names have the form xxyyy (or xxyy), where xx denotes the structure/properties of the matrix, and yyy indicates the computation to be done:

  • matrix structure/properties (xx):
    • ge -- general,
    • po -- symmetric/Hermitian positive definite (not packed),
    • pp -- symmetric/Hermitian positive definite stored in packed format,
    • sy -- symmetric (real and complex) indefinite (not packed),
    • sp -- symmetric indefinite stored in packed format,
    • he -- Hermitian indefinite (not packed),
    • hp -- Hermitian indefinite stored in packed format;
  • computation (yyy):
    • sv -- solve the system (driver routine),
    • trf -- factor (computational routine),
    • trs -- solve from factorisation, i.e. backward (or forward) substitution (computational routine).

Our convention is to group the functions which solve the same problem (or part of it) in separate files, named after the corresponding driver routine -- for example, gesv(), getrf() and getrs(), that is, functions for solving (perhaps in several steps) a system with general coefficient matrix, are defined in gesv.hpp.

2.1.1 General System

Defined in boost/numeric/bindings/lapack/gesv.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, B, L, U are matrices, ipiv is a vector of pivot indices representing premutation matrix P (for more details see description of the LU factorisation above), Trans can be 'N', 'T' or 'C', denoting A, AT or AH, respectively, and ierr is `diagnostic argument' INFO (as described in LAPACK Users' Guide).

ExpressionSemantics
gesv(A,ipiv,B)using AP=LU, B <- A-1B, A <- LU, ipiv <- P;   returns ierr
gesv(A,B)as above, with ipiv allocated and deallocated internally
getrf(A,ipiv)using AP=LU, A <- LU, ipiv <- P;   returns ierr
getrs(Trans,A,ipiv,B) B <- op(A)-1B assuming A <- LU and ipiv <- P,   op (A) == A || AT || AH;   returns ierr
getrs(A,ipiv,B)B <- A-1B assuming A <- LU and ipiv <- P;   returns ierr

2.1.2 Positive Definite System

Defined in boost/numeric/bindings/lapack/posv.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, B, L, U are matrices (for more details see description of the Cholesky factorisation above), Uplo can be 'U' or 'L', denoting that leading upper or lower, respectively, triangular part of A contains the upper or lower triangular part of the symmetric/Hermitian matrix (and that the lower or upper triangular part, respectively, is not referenced) and ierr is LAPACK's `diagnostic argument' INFO.

ExpressionSemantics
posv(Uplo,A,B) B <- A-1B, using A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
posv(A,B) B <- A-1B, using A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr    [1]
potrf(Uplo,A) A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
potrf(A) A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr    [1]
potrs(Uplo,A,B) B <- A-1B assuming A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
potrs(A,B) B <- A-1B assuming A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr    [1]

[1] It is assumed that matrix traits class can determine whether upper or lower triangular part of A contains the corresponding part of the symmetric/Hermitian matrix (e.g. traits for ublas::symmetric_adaptor<> and ublas::hermitian_adaptor<>).

2.1.3 Positive Definite System with Coefficient Matrix in Packed Storage

Defined in boost/numeric/bindings/lapack/ppsv.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, B, L, U are matrices (for more details see description of the Cholesky factorisation above) and ierr is LAPACK's `diagnostic argument' INFO. Matrix A is stored in packed format (e.g. ublas::symmetric_matrix<> and ublas::hermitian_matrix<>).

ExpressionSemantics
ppsv(A,B) B <- A-1B, using A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
pptrf(A) A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr
pptrs(A,B) B <- A-1B assuming A = UTU or A = LLT or A = UHU or A = LLH;   returns ierr

It is assumed that matrix traits class can determine whether or lower triangular part of the symmetric/Hermitian matrix is stored (e.g. traits for ublas::symmetric_matrix<> and ublas::hermitian_matrix<>).

2.1.4 Symmetric (Real and Complex) Indefinite System

Defined in boost/numeric/bindings/lapack/sysv.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, B, L, U, D are matrices, ipiv is a vector of pivot indices (for more details see description of the Bunch-Kaufman factorisation above), w is a `work' vector, Uplo can be 'U' or 'L', denoting that leading upper or lower, respectively, triangular part of A contains the upper or lower triangular part of the symmetric matrix (and that the lower or upper triangular part, respectively, is not referenced), Spec can be 'O' or 'M', specifying whether optimal or minimum size is to be returned, and ierr is LAPACK's `diagnostic argument' INFO.

ExpressionSemantics
sysv(Uplo,A,ipiv,B,w) B <- A-1B, using A = UDUT or A = LDLT;   returns ierr
sysv(Uplo,A,B) as above, with ipiv and w allocated and deallocated internally
sysv(A,ipiv,B,w) B <- A-1B, using A = UDUT or A = LDLT;   returns ierr    [1]
sysv(A,B) as above, with ipiv and w allocated and deallocated internally    [1]
sysv_work(Spec,Uplo,A) returns optimal or minimum size of the vector w
sysv_work(Spec,A) returns optimal or minimum size of the vector w    [1]
sytrf(Uplo,A,ipiv,w) A = UDUT or A = LDLT;   returns ierr
sytrf(Uplo,A,ipiv) as above, with w allocated and deallocated internally
sytrf(A,ipiv,w) A = UDUT or A = LDLT;   returns ierr    [1]
sytrf(A,ipiv) as above, with w allocated and deallocated internally    [1]
sytrf_work(Spec,Uplo,A) returns optimal or minimum size of the vector w
sytrf_work(Spec,A) returns optimal or minimum size of the vector w    [1]
sytrf_block(Spec,Uplo,A) returns optimal or minimum block size    [2]
sytrf_block(Spec,A) returns optimal or minimum block size    [1][2]
sytrs(Uplo,A,ipiv,B) B <- A-1B assuming A = UDUT or A = LDLT;   returns ierr
sytrs(A,ipiv,B) B <- A-1B assuming A = UDUT or A = LDLT;   returns ierr    [1]

[1] It is assumed that matrix traits class can determine whether upper or lower triangular part of A contains the corresponding part of the symmetric matrix (e.g. traits for ublas::symmetric_adaptor<>).

[2] Optimal size of the `work' vector w is n*nb, where nb is optimal block size and n the order of matrix A.

2.1.5 Symmetric Indefinite System with Coefficient Matrix in Packed Storage

Defined in boost/numeric/bindings/lapack/spsv.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, B, L, U, D are matrices, ipiv is a vector of pivot indices (for more details see description of the Bunch-Kaufman factorisation above) and ierr is LAPACK's `diagnostic argument' INFO. Matrix A is stored in packed format (e.g. ublas::symmetric_matrix<>).

ExpressionSemantics
spsv(A,ipiv,B) B <- A-1B, using A = UDUT or A = LDLT;   returns ierr
spsv(A,B) as above, with ipiv allocated and deallocated internally
sptrf(A,ipiv) A = UDUT or A = LDLT;   returns ierr
sptrs(A,ipiv,B) B <- A-1B assuming A = UDUT or A = LDLT;   returns ierr

It is assumed that matrix traits class can determine whether upper or lower triangular part of the symmetric matrix is stored (e.g. traits for ublas::symmetric_matrix<>).

2.1.6 Hermitian Indefinite System

Defined in boost/numeric/bindings/lapack/hesv.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, B, L, U, D are matrices, ipiv is a vector of pivot indices (for more details see description of the Bunch-Kaufman factorisation above), w is a `work' vector, Uplo can be 'U' or 'L', denoting that leading upper or lower, respectively, triangular part of A contains the upper or lower triangular part of the Hermitian matrix (and that the lower or upper triangular part, respectively, is not referenced), Spec can be 'O' or 'M', specifying whether optimal or minimum size is to be returned, and ierr is LAPACK's `diagnostic argument' INFO.

ExpressionSemantics
hesv(Uplo,A,ipiv,B,w) B <- A-1B, using A = UDUH or A = LDLH;   returns ierr
hesv(Uplo,A,B) as above, with ipiv and w allocated and deallocated internally
hesv(A,ipiv,B,w) B <- A-1B, using A = UDUH or A = LDLH;   returns ierr    [1]
hesv(A,B) as above, with ipiv and w allocated and deallocated internally    [1]
hesv_work(Spec,Uplo,A) returns optimal or minimum size of the vector w
hesv_work(Spec,A) returns optimal or minimum size of the vector w    [1]
hetrf(Uplo,A,ipiv,w) A = UDUH or A = LDLH;   returns ierr
hetrf(Uplo,A,ipiv) as above, with w allocated and deallocated internally
hetrf(A,ipiv,w) A = UDUH or A = LDLH;   returns ierr    [1]
hetrf(A,ipiv) as above, with w allocated and deallocated internally    [1]
hetrf_work(Spec,Uplo,A) returns optimal or minimum size of the vector w
hetrf_work(Spec,A) returns optimal or minimum size of the vector w    [1]
hetrf_block(Spec,Uplo,A) returns optimal or minimal block size    [2]
hetrf_block(Spec,A) returns optimal or minimal block size    [1][2]
hetrs(Uplo,A,ipiv,B) B <- A-1B assuming A = UDUH or A = LDLH;   returns ierr
hetrs(A,ipiv,B) B <- A-1B assuming A = UDUH or A = LDLH;   returns ierr    [1]

[1] It is assumed that matrix traits class can determine whether upper or lower triangular part of A contains the corresponding part of the Hermitian matrix (e.g. traits for ublas::hermitian_adaptor<>).

[2] Optimal size of the `work' vector w is n*nb, where nb is optimal block size and n the order of matrix A.

2.1.7 Hermitian Indefinite System with Coefficient Matrix in Packed Storage

Defined in boost/numeric/bindings/lapack/hpsv.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, B, L, U, D are matrices, ipiv is a vector of pivot indices (for more details see description of the Bunch-Kaufman factorisation above) and ierr is LAPACK's `diagnostic argument' INFO. Matrix A is stored in packed format (e.g. ublas::hermitian_matrix<>).

ExpressionSemantics
hpsv(A,ipiv,B) B <- A-1B, using A = UDUH or A = LDLH;   returns ierr
hpsv(A,B) as above, with ipiv allocated and deallocated internally
hptrf(A,ipiv) A = UDUH or A = LDLH;   returns ierr
hptrs(A,ipiv,B) B <- A-1B assuming A = UDUH or A = LDLH;   returns ierr

It is assumed that matrix traits class can determine whether upper or lower triangular part of the Hermitian matrix is stored (e.g. traits for ublas::hermitian_matrix<>).

2.2 Singular Value Decomposition

The singular value decomposition (SVD) of an m-by-n matrix A is given by

A = U S VT

if A is real and by

A = U S VH

if A is complex matrix. U and V are ortogonal in real case and unitary in complex case; U is m-by-m and V is n-by-n. First min(m,n) columns of U and V are the left and right singular vectors of A. S is an m-by-n real matrix with non-negative elements sii and with sij==0 for i!=j. The sii are singular values of A. Matrix S is in LAPACK represented by a vector s (such that ii->i).

LAPACK Bindings Library currently provides bindings for LAPACK driver routines only.

2.2.1 Simple Driver

Simple driver gesvd() computes all the singular values and optionally left and/or right singular vectors.

Defined in boost/numeric/bindings/lapack/gesvd.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, U, VT (denoting VT or VH -- namely, routine returns VT or VH, not V) are matrices; s is a vector representing matrix S; w, rw, are `work' vectors (elements of w can be real or complex, elements of rw are real). Jobu specifies options for computing U:

  • 'N' -- no left singular vectors are computed,
  • 'S' -- left singular vectors are returned in the first min(m,n) columns of U,
  • 'A' -- complete matrix U is computed,
  • 'O' -- left singular vectors are overwritten on the first min(m,n) columns of A.
Jobvt specifies options for computing VT:
  • 'N' -- no right singular vectors are computed,
  • 'S' -- right singular vectors are returned in the first min(m,n) rows of VT,
  • 'A' -- complete matrix VT is computed,
  • 'O' -- right singular vectors are overwritten on the first min(m,n) rows of A.
Note that Jobu and Jobvt cannot both be 'O'. Lw can be 'O' or 'M', specifying whether optimal or minimum size of the `work' vector is to be used or calculated; 'O' can be used with LAPACK version 3.0 only. And finally, ierr is LAPACK's `diagnostic argument' INFO.

ExpressionSemantics
gesvd(Jobu,Jobvt,A,s,U,VT,w) SVD of real A;   returns ierr
gesvd(Jobu,Jobvt,A,s,U,VT,w,rw) SVD of complex A;   returns ierr
gesvd(Lw,Jobu,Jobvt,A,s,U,VT) SVD of real or complex A, with `internal' work space;   returns ierr
gesvd(Jobu,Jobvt,A,s,U,VT) same as gesvd('O',Jobu,Jobvt,A,s,U,VT);   returns ierr
gesvd(A,s,U,VT) same as gesvd('O','S','S',A,s,U,VT);   returns ierr
gesvd(A,s) same as gesvd('O','N','N',A,s,U,VT);   returns ierr    [1]
gesvd_work(Lw,Jobu,Jobvt,A) returns optimal or minimum size of the vector w
gesvd_rwork(A) returns minimum size of the vector rw

[1] U and VT are not referenced.

2.2.2 Divide and Conquer Driver

Divide and conquer driver gesdd() solves the same as the simple driver. It is much faster than the simple driver for large matrices, but uses more workspace.

Defined in boost/numeric/bindings/lapack/gesdd.hpp.

Namespace is boost::numeric::bindings::lapack.

In the following table A, U, VT (denoting VT or VH) are matrices; s is a vector representing matrix S; w, rw, iw, are `work' vectors (elements of w can be real or complex, elements of rw are real, elements of rw are ints). Jobz specifies options for computing U and VT:

  • 'N' -- no left or right singular vectors are computed;
  • 'S' -- left singular vectors are returned in the first min(m,n) columns of U and right singular vectors are returned in the first min(m,n) rows of VT;
  • 'A' -- complete matrices U and VT are computed;
  • 'O' -- if m>=n, left singular vectors are overwritten on the first min(m,n) columns of A and complete VT is computed; otherwise, right singular vectors are overwritten on the first min(m,n) rows of A and complete U is computed.
Lw can be 'O' or 'M', specifying whether optimal or minimum size of the `work' vector is to be used or calculated; 'O' can be used with LAPACK version 3.0 only. Finally, ierr is LAPACK's `diagnostic argument' INFO.

ExpressionSemantics
gesdd(Jobz,A,s,U,VT,w,iw) SVD of real A;   returns ierr
gesdd(Jobz,A,s,U,VT,w,rw,iw) SVD of complex A;   returns ierr
gesdd(Lw,Jobz,A,s,U,VT) SVD of real or complex A, with `internal' work space;   returns ierr
gesdd(Jobz,A,s,U,VT) same as gesdd('O',Jobz,A,s,U,VT);   returns ierr
gesdd(A,s,U,VT) same as gesdd('O','S',A,s,U,VT);   returns ierr
gesdd(A,s) same as gesdd('O','N',A,s,U,VT);   returns ierr    [1]
gesdd_work(Lw,Jobz,A) returns optimal or minimum size of the vector w
gesdd_rwork(Jobz,A) returns minimum size of the vector rw
gesdd_iwork(A) returns minimum size of the vector iw

[1] U and VT are not referenced.

3. Extending LAPACK bindings

LAPACK is a huge library and LAPACK Bindings Library does not contain bindings for all LAPACK routines. In this section we will describe the implementation of function getrs to provide guidelines for user's additions and extensions.

Implementation will be described in two stages:

  1. core implementation, i.e. binding to Fortran routine;
  2. some workarounds for broken compilers.

1. There are four versions of almost all LAPACK routines for matrices with single and double precision real and complex elements. Type of the matrix elements is encoded as the first letter of the routine's name:

  • s -- single precision real (REAL), which (usually) corresponds to float in C/C++;
  • d -- double precision real (DOUBLE PRECISION), which corresponds to double in C/C++;
  • c -- single precision complex (COMPLEX); unfortunately, it can't be said that corresponding type in C++ is std::complex<float>,[1]  although we don't know of any implementation where it is not the case;
  • z -- double precision complex (COMPLEX*16); regarding std::complex<double> see above.
Thus, there are sgetrs, dgetrs, cgetrs and zgetrs.

There are several conventions for calling Fortran from C/C++: some compilers require trailing underscore in function names, some don't, etc. So, the first step is to define `portable' function names in lapack_names.h using the macro FORTRAN_ID (defined in traits/fortran.h): 

     #define LAPACK_SGETRS FORTRAN_ID( sgetrs )
     #define LAPACK_DGETRS FORTRAN_ID( dgetrs )
     #define LAPACK_CGETRS FORTRAN_ID( cgetrs )
     #define LAPACK_ZGETRS FORTRAN_ID( zgetrs )

Next step is to declare interfaces of LAPACK routines in lapack.h. Only dgetrs and zgetrs are shown below; sgetrs and cgetrs differ only in the type of array parameters: 

     void LAPACK_DGETRS (char const* trans, int const* n, int const* nrhs,
                         double const* a, int const* lda, int const* ipiv, double* b, int const* ldb, int* info);
     void LAPACK_ZGETRS (char const* trans, int const* n, int const* nrhs,
                         dcomplex_t const* a, int const* lda, int const* ipiv, dcomplex_t* b, int const* ldb, int* info);
All parameters, including scalars like n and nrhs, are defined as pointers; input parameters, i.e. those which are not modified inside the routine, are pointers to const. Functions have C linkage (extern "C" { ... }) and are in the global namespace.

Using function overloading, we can remove array parameters type from the function name: 

     void getrs (char const trans, int const n, int const nrhs, double const* a, int const lda, 
                 int const* ipiv, double* b, int const ldb, int* info) 
     {
        LAPACK_DGETRS (&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info);
     }

     void getrs (char const trans, int const n, int const nrhs, traits::complex_d const* a, int const lda,
                 int const* ipiv, traits::complex_d* b, int const ldb, int* info)
     {
        LAPACK_ZGETRS (&trans, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info);
     }
(and there are two more functions which call sgetrs and cgetrs). Now we are closer to C/C++ calling convention: array parameters are pointers and scalars are passed by value.

As these overloads are not intended for direct use, they are in the subnamespace detail of boost::numeric::bindings::lapack.

Finally, we can define higher level, generic C++ interface.

Higher level interfaces (bindings) are written in terms of traits classes which are the interface between LAPACK routines and vector and matrix classes. Namely, the idea is to make bindings independent of the concrete vector/matrix libraries as much as possible. LAPACK routines usually require the starting address of the matrix, number of rows and columns and the so-called leading dimension. So, matrix_traits<> class and its specializations for various matrix classes provide these functions and some typedefs. Note that bindings don't know and need not know anything about traits specializations -- e.g. boost/numeric/bindings/traits/ublas_matrix.hpp must be included in your program (if it uses ublas::matrix<>), but not in bindings headers, which include only boost/numeric/bindings/traits/matrix_traits.hpp.

To simplify the use of traits classes, some free accessor functions were introduced, so instead of writing e.g. 

     traits::matrix_traits<matrix_type const>::size1 (m)
you can write just 
     traits::matrix_size1 (m)

As matrix objects (usually) know about their sizes, we can reduce the number parameters from nine to four[2] (and a return value): 

     template <typename MatrA, typename MatrB, typename IVec>
     int getrs (char const trans, MatrA const& a, IVec const& ipiv, MatrB& b)

The heart of this generic function is the call of the one of the functions (depending on the type of array pointers) from the overloaded set: 

     int info;
     detail::getrs (trans,  
                    traits::matrix_size1 (a),
                    traits::matrix_size2 (b),
                    traits::matrix_storage (a),
                    traits::leading_dimension (a),
                    traits::vector_storage (ipiv),
                    traits::matrix_storage (b),
                    traits::leading_dimension (b),
                    &info);
using accessor function which through matrix and vector traits classes extract appropriate data (storage addresses and sizes) from matrix and vector objects a, b and ipiv. Function returns info.

Before the call we made some compile-time (matrix structure) and run-time (matching sizes) checks.

Overloaded set and the generic function are defined in gesv.hpp.

In short, addition of a new binding is done in four steps:

  1. using the macro FORTRAN_ID, define names to be used to refer to LAPACK subroutines in C/C++ code;
  2. declare interfaces of LAPACK routines; interfaces are written in terms of pointers to matrix and vector storage and pointers to corresponding sizes;
  3. define a set of overloaded functions which call LAPACK routines (overload resolution is based on the type of matrix elements); parameters are pointers to storage and sizes (their values now, not pointers);
  4. using traits classes and/or free accessor functions to extract storage and size data from matrix and vector objects, define generic function(s) which forward the job to the overloaded functions.

Although not shown (and not needed) in the example, some type names must be known in certain cases. They can be obtained through traits classes, e.g.: 

     typedef typename traits::matrix_traits<MatrA>::value_type val_t;
     typedef typename traits::matrix_traits<MatrA>::pointer ptr_t;
     typedef typename traits::matrix_traits<MatrA>::matrix_structure mstruct_t;

2. On compilers which do not support partial template specialisation, traits classes cannot be used. Accessor functions are then (i.e. when macro BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS is defined) simple set of overloaded functions (defined in traits/vector_raw.hpp and traits/matrix_raw.hpp). Unfortunately, some of these compilers cannot distinguish functions 

     template <typename T, typename F, typename A>
     typename ublas::matrix<T,F,A>::const_pointer matrix_storage (ublas::matrix<T,F,A> const& m);
and 
     template <typename T, typename F, typename A>
     typename ublas::matrix<T,F,A>::pointer matrix_storage (ublas::matrix<T,F,A>& m);
(boost macro BOOST_NO_FUNCTION_TEMPLATE_ORDERING covers this case).

Therefore we introduced additional function 

     template <typename T, typename F, typename A>
     typename ublas::matrix<T,F,A>::const_pointer matrix_storage_const (ublas::matrix<T,F,A> const& m);
and the call in the generic getrs() is now :o( 
         detail::getrs (trans,  
                        traits::matrix_size1 (a),
                        traits::matrix_size2 (b),
     #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
                        traits::matrix_storage (a),
     #else 
                        traits::matrix_storage_const (a),
     #endif
                        traits::leading_dimension (a),
     #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
                        traits::vector_storage (ipiv),
     #else 
                        traits::vector_storage_const (ipiv),
     #endif
                        traits::matrix_storage (b),
                        traits::leading_dimension (b),
                        &info);

If some type name is needed, workaround is e.g.: 

         template <typename MatrA>
         void func (M const&l m) {
            // ...
     #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
            typedef typename traits::matrix_traits<MatrA>::value_type val_t;
     #else
            typedef typename MatrA::value_type val_t;
     #endif
            // ...
         }
Prerequisite is, of course, that MatrA has value_type defined.

[1] These are thorny issues; see C++ Standards Committee Papers:

    G. Dos Reis: Enhancing Numerical Support

    R. W. Grosse-Kunstleve and D. Abrahams: Predictable Data Layout for Certain Non-Pod Types

[2] First parameter of getrs, char const trans, specifies the form of the system of equations: AX = B, ATX = B or AHX = B. As the form AX = B is the most common, LAPACK Bindings Library also provides version with three parameters: 

     template 
     int getrs (MatrA const& a, IVec const& ipiv, MatrB& b) {
        char const no_transpose = 'N';
        return getrs (no_transpose, a, ipiv, b);
     }


boost-bindings/libs/numeric/bindings/lapack/Jamfile0000644000175000017500000000012510776160766022546 0ustar andreasandreassubproject libs/numeric/bindings/lapack ; subinclude libs/numeric/blasbindings/tst ; boost-bindings/libs/numeric/bindings/mumps/0000755000175000017500000000000010776013426021152 5ustar andreasandreasboost-bindings/libs/numeric/bindings/mumps/test/0000755000175000017500000000000010776013426022131 5ustar andreasandreasboost-bindings/libs/numeric/bindings/mumps/test/mumps_ublas.cpp0000644000175000017500000000327410776013426025172 0ustar andreasandreas#include #include #include #include #include #include #include #include int main() { namespace ublas = ::boost::numeric::ublas ; namespace mumps = ::boost::numeric::bindings::mumps ; int const n = 10 ; typedef ublas::coordinate_matrix > coo_type ; coo_type coo( n, n, n + 6 ) ; for (int i=0; i v( 10 ) ; ublas::vector w( 10 ) ; std::fill( w.begin(), w.end(), 1.0 ) ; for (int i=1; i mumps_coo ; mumps_coo.icntl[2]=mumps_coo.icntl[3] = 0 ; // Analysis mumps_coo.job = 1 ; matrix_integer_data( mumps_coo, coo ) ; driver( mumps_coo ) ; // Factorization mumps_coo.job = 2 ; matrix_value_data( mumps_coo, coo ) ; driver( mumps_coo ) ; // Solve mumps_coo.job = 3 ; rhs_sol_value_data( mumps_coo, v ) ; driver( mumps_coo ) ; std::cout << "w : " << w << std::endl ; std::cout << "v : " << v << std::endl ; } boost-bindings/libs/numeric/bindings/mumps/test/makefile0000644000175000017500000000115610776013426023634 0ustar andreasandreasBOOST = -I$(HOME)/local_disk/ext/boost BOOSTSANDBOX = -I$(HOME)/local_disk/svn/boost-sandbox BLAS = -L$(HOME)/local_disk/ext/lib -lf77blas -latlas /usr/lib/libf2c.a LAPACK = -L$(HOME)/local_disk/ext/lapack -llapack-gfortran411 -llapack_tools CPP = $(HOME)/local_disk/ext/bin/g++ -g MUMPS = -I$(HOME)/local_disk/ext/mumps/MUMPS_4.6.4/include -L$(HOME)/local_disk/ext/mumps/MUMPS_4.6.4/lib -ldmumps -lsmumps -lcmumps -lzmumps -lpord -L$(HOME)/local_disk/ext/mumps/MUMPS_4.6.4/libseq -lmpiseq mumps_ublas: mumps_ublas.cpp $(CPP) -o mumps_ublas mumps_ublas.cpp $(BOOST) $(BOOSTSANDBOX) $(MUMPS) $(BLAS) -lgfortran -lpthread boost-bindings/libs/numeric/bindings/traits/0000755000175000017500000000000010776013426021317 5ustar andreasandreasboost-bindings/libs/numeric/bindings/traits/test/0000755000175000017500000000000010776013426022276 5ustar andreasandreasboost-bindings/libs/numeric/bindings/traits/test/Jamfile0000644000175000017500000000063710776013426023576 0ustar andreasandreas#exe ublas_vector # : ublas_vector.cpp # : $(BOOST) # ; # #exe ublas_vector_proxy # : ublas_vector_proxy.cpp # : $(BOOST) # ; exe compatible_calling_conventions : compatible_calling_convention.cpp fortran_functions.f /user-config//libfortran # should point to fortran runtime library : $(BOOST) ; boost-bindings/libs/numeric/bindings/traits/test/fortran_functions.f0000644000175000017500000000072510776013426026214 0ustar andreasandreasC This function just returns a double. C This function serves to test if the return value C can be correctly captured in C. C double precision function dfunction() dfunction = 9.87 return end double complex function dzfunction(d,i) double complex temp double precision t(2), d, i equivalence (temp,t(1)) t(1) = d t(2) = i dzfunction = temp return end boost-bindings/libs/numeric/bindings/traits/test/ublas_vector.cpp0000644000175000017500000000064410776013426025476 0ustar andreasandreas#include #include int main() { /* using namespace boost::numeric::ublas ; using namespace boost::numeric::bindings::traits ; vector< double > v( 10 ) ; if ( vector_storage( v ) != & v[0] ) return 1 ; if ( vector_size( v ) != 10 ) return 2 ; if ( vector_stride( v ) != 1 ) return 3 ; */ return 0 ; } boost-bindings/libs/numeric/bindings/traits/test/ublas_vector_proxy.cpp0000644000175000017500000000204110776013426026730 0ustar andreasandreas#include #include #include int main() { using namespace boost::numeric::ublas ; using namespace boost::numeric::bindings::traits ; vector< double > v( 10 ) ; range r(2, 5) ; slice s(1,3,3) ; vector_range< vector< double > > vr( v, r ) ; vector_slice< vector< double > > vs( v, s ) ; if ( vector_storage( v ) != & v[0] ) return 1 ; if ( vector_size( v ) != 10 ) return 2 ; if ( vector_stride( v ) != 1 ) return 3 ; if ( vector_storage( v ) + 2 != vector_storage( vr ) ) return 4 ; if ( vector_size( vr ) != 3 ) return 5 ; if ( vector_stride( vr ) != 1 ) return 6 ; if ( vector_storage( v ) + 1 != vector_storage( vs ) ) return 7 ; if ( vector_size( vs ) != 3 ) return 8 ; if ( vector_stride( vs ) != 3 ) return 9 ; return 0 ; } boost-bindings/libs/numeric/bindings/traits/test/compatible_calling_convention.cpp0000644000175000017500000000160610776013426031057 0ustar andreasandreas/* This test serves to test if the calling conventions * between C and Fortran are compatible. * This serves to correctly make bindings for fortran libraries * like BLAS and LAPACK. */ #include #include /* * signatures for functions defined in 'fortran_functions.f' */ extern "C" { double dfunction() ; void dzfunction(double*,double*,double*) ; } int main() { { double d = dfunction() ; if ( ( d - 9.87 ) > 1e-5 ) { std::cerr << "return value was " << d << " instead of 9.87" << std::endl ; return 1 ; } } { std::complex< double > dc ; double* p = (double*)&dc ; double d = 9.87, i = 3.21 ; dzfunction(p,&d,&i) ; if ( ( dc.real() - 9.87 ) > 1e-5 && ( dc.imag() - 3.21 ) > 1e-5 ) { std::cerr << "return value was " << dc << " instead of (9.87,3.21)" << std::endl ; return 2 ; } } return 0 ; } boost-bindings/libs/numeric/bindings/traits/doc/0000755000175000017500000000000010776013426022064 5ustar andreasandreasboost-bindings/libs/numeric/bindings/traits/doc/index.html0000644000175000017500000007002310776013426024063 0ustar andreasandreas Boost.Numeric.Bindings.Traits

C++ Boost

Boost.Numeric.Bindings.Traits


Back to Bindings Library Synopsis

Contents

  1. Generic Storage Layout Information
    1. Rationale
    2. Using Traits Classes
    3. Vector Traits
      1. Description
      2. Definition
      3. Associated Types
      4. Expression Semantics
      5. Implementation
    4. Matrix Traits
      1. Description
      2. Definition
      3. Associated Types
      4. Expression Semantics
      5. Implementation
    5. Sparse Matrix Traits
      1. Description
      2. Definition
      3. Associated Types
      4. Static Constants
      5. Expression Semantics
      6. Implementation
    6. Free functions
  2. Calling Conventions
  3. Type Mapping

1. Generic Storage Layout Information

1.1 Rationale

The Traits Library provides the mappings from the interfaces of various vector and matrix C++ libraries to the storage layout format required by the original API's of different external numeric libraries.

These mappings are implemented by means of traits classes and their specialisations. One advantage of this approach is that the traits idiom is non-intrusive: no changes or additions to vector and matrix classes are needed. Another advantage is the extensibility since traits classes can be specialised for many different vector or matrix libraries. Furthermore, the traits idiom is a compile-time mechanism and thus adds no run-time overhead.

1.2 Using Traits Classes

To use particular vector or matrix class in bindings to some external library, proper traits specialisation must be included. Specialisations for following vector and matrix classes are currently available:
  • vector classes:
    • uBLAS:
      • ublas::vector<>, ublas::c_vector<> and vector proxies -- in ublas_vector.hpp
      • ublas::matrix_row<> and ublas::matrix_column<> -- in ublas_matrix.hpp
    • std::valarray<> -- in std_valarray.hpp
    • std::vector<> -- in std_vector.hpp
    • boost::array<> -- in boost_array.hpp
    • C array -- in c_array.hpp
    • TNT 1D arrays -- in tnt.hpp
  • matrix classes:
    • uBLAS:
      • ublas::matrix<>, ublas::c_matrix<> and matrix proxies -- in ublas_matrix.hpp
      • ublas::symmetric_matrix<> and ublas::symmetric_adaptor<> -- in ublas_symmetric.hpp
      • ublas::hermitian_matrix<> and ublas::hermitian_adaptor<> -- in ublas_hermitian.hpp
      • ublas::vector<> and ublas::c_vector<> (matrices with one column and one row) -- in ublas_vector2.hpp
    • TNT 2D arrays -- in tnt.hpp
  • sparse matrix classes:
    • uBLAS:
      • ublas::compressed_matrix<> and ublas::coordinate_matrix<> -- in ublas_sparse.hpp
All mentioned files are in the directory boost/numeric/bindings/traits.

If you are using any of these vector or matrix classes, this is in fact all you need to know about traits classes and their specialisations.

Example. Simple initialisation and dot product of vectors v (represented by std::vector<>) and w (represented by `plain' C array) using ATLAS bindings: 

  #include <iostream> 
  #include <boost/numeric/bindings/traits/std_vector.hpp>
  #include <boost/numeric/bindings/traits/c_array.hpp>
  #include <boost/numeric/bindings/atlas/cblas1.hpp>

  namespace atlas = boost::numeric::bindings::atlas;

  int main() {
    std::vector v(10);
    double w[10]; 
    atlas::set (0.1, v);  // v = [ 0.1  0.1  ...  0.1 ]^T
    atlas::set (0.2, w);  // w = [ 0.2  0.2  ...  0.2 ]^T
    std::cout << atlas::dot (v, w) << std::endl; 
  }

1.3 Vector Traits

1.3.1.Description

Generic bindings functions which manipulate vectors are written in terms of types (subsection 1.3.3) and static functions (subsection 1.3.4) defined in the vector_traits<> class. This class was designed taking into account requirements of the interfaces of BLAS levels 1 and 2 functions.

1.3.2.Definition

Generic class vector_traits<> is defined in the header boost/numeric/bindings/traits/vector_traits.hpp.

Specialisations are defined in:

HeaderVector class(es)
boost_array.hpp boost::array<>
c_array.hpp C array: T[N]
std_valarray.hpp std::valarray<>
std_vector.hpp std::vector<>
tnt.hpp TNT::Array1D<>, TNT::Fortran_Array1D<>
ublas_matrix.hpp ublas::matrix_row<>, ublas::matrix_column<>
ublas_vector.hpp ublas::vector<>, ublas::c_vector<>, ublas::vector_range<>, ublas::vector_slice<>

All headers are in boost/numeric/bindings/traits/.

1.3.3 Associated Types

Value typevalue_typeThe type of the objects contained in the vector
Pointer typepointerData type used to point to any entry of the vector in memory

1.3.4 Expression Semantics

NameExpressionSemantics
Beginning of storagestorage(v)Returns a pointer to the beginning of the storage of vector v
Size of vectorsize(v)Returns the size of vector v
Stridestride(v)Returns the distance between pointers pointing to consecutive entries in v

1.3.5 Implementation

Class vector_traits<> is implemented in three steps (see vector_traits.hpp):
  1. definition of class default_vector_traits<>,
  2. definition of class vector_detail_traits<>,
  3. definition of class vector_traits<>.
1. Class default_vector_traits<> defines default functionality: 
  template <typename V, typename T = typename V::value_type>
  struct default_vector_traits {
    typedef T value_type;
    typedef typename detail::generate_const<V,T>::type* pointer;
    static pointer storage (V& v) { return v.begin(); }
    static int size (V& v) { return v.size(); }
    static int stride (V& v) { return 1; }
  };

Metafunction generate_const<> `copies' const, if present, from V to T, that is, if vector type V is non-const, pointer will be T*, and if V is const, pointer will be T const*.

As can be seen from the implementation of function storage(), the assumption is that V provides function begin() and that V::iterator (or V::const_iterator, if V is const) is pointer, as e.g. uBLAS storage classes (unbounded_array<>, bounded_array<> and array_adaptor<>) and boost::array<>. Also, it is assumed that V provides function size() and that stride is 1. If this is not the case with your vector class, you must write specialisation.

2. Class vector_detail_traits<> was introduced having the writing of specialisations in mind. It has two template parameters: VIdentifier and VType. VIdentifier is used to identify the (written) implementation and VType is the actual type for which the specialisation is needed in the code which uses traits -- VIdentifier is always non-const (e.g. ublas::vector<>), while VType can be const (e.g. ublas::vector<> or ublas::vector<> const).

Generic/default implementation is: 

  template <typename VIdentifier, typename VType>
  struct vector_detail_traits : default_vector_traits<VType> {};

3. Class vector_traits<> is derived from vector_detail_traits<>. It deduces VIdentifier from its template parameter VType by removing const, if present: 

  template <typename VType>
  struct vector_traits : vector_detail_traits<typename boost::remove_const<VType>::type, VType> {};

Specialisations. Class vector_detail_traits<> can be specialised if default implementation is not appropriate for particular vector type. All specialisations must provide types defined in subsection 1.3.3 and static member functions defined in subsection 1.3.4.

Example. Specialisation for built-in C array (see c_array.hpp): 

  template <typename T, std::size_t N, typename VType>
  struct vector_detail_traits<T[N],VType> {
    typedef T value_type;
    typedef typename detail::generate_const<VType,T>::type* pointer; 
    static pointer storage (VType& a) { return a; }
    static int size (VType&) { return N; }
    static int stride (VType&) { return 1; }
  };

Example. Specialisation for std::vector<> (see std_vector.hpp): 

  template <typename T, typename Alloc, typename VType>
  struct vector_traits<std::vector<T, Alloc>, VType> : default_vector_traits<V,T> {
    typedef typename default_vector_traits<VType,T>::pointer pointer;
    static pointer storage (VType& v) { return &v.front(); }
  };
Type value_type and functions size() and stride() are inherited from default_vector_traits<>.

1.4 Matrix Traits

1.4.1 Description

Generic bindings functions which manipulate matrices are written in terms of types (subsection 1.4.3) and static functions (subsection 1.4.4) defined in the matrix_traits<> class. This class was designed taking into account requirements of the interfaces of BLAS (levels 2 and 3) and LAPACK functions.

1.4.2 Definition

Generic class matrix_traits<> is defined in header boost/numeric/bindings/traits/matrix_traits.hpp.

Specialisations are defined in:

HeaderMatrix classes
tnt.hpp TNT::Array2D<>, TNT::Fortran_Array2D<>
ublas_hermitian.hpp ublas::hermitian_matrix<>, ublas::hermitian_adaptor<>
ublas_matrix.hpp ublas::matrix<>, ublas::c_matrix<>, ublas::matrix_range<>, ublas::matrix_slice<>
ublas_symmetric.hpp ublas::symmetric_matrix<>, ublas::symmetric_adaptor<>
ublas_vector2.hpp ublas::vector<> (as n-by-1 matrix), ublas::c_vector<> (as 1-by-n matrix)

All headers are in boost/numeric/bindings/traits/.

1.4.3 Associated Types

Value typevalue_typeThe type of the objects contained in the matrix
Pointer typepointerData type used to point to any entry of the matrix in memory
Matrix structurematrix_structureDescribes the pattern of nonzero and zero elements and the storage layout [1]
Ordering typeordering_typeRow or column major [2]
Upper/lower typeuplo_type For triangular, symmetric and hermitian matrices: indicates whether upper or lower triangular part is referenced or stored [3]

[1] matrix_structure is a tag which can be:

  • general_t
  • symmetric_t
  • symmetric_packed_t
  • hermitian_t
  • hermitian_packed_t
  • unknown_structure_t

[2] ordering_type can be:

  • row_major_t
  • column_major_t

[3] Upper/lower tag must be defined only for triangular (full and packed), symmetric (full and packed) and hermitian (full and packed) matrices. For packed types it indicates whether upper or lower triangular part is stored, and for full matrices it denotes part that is referenced. uplo_type can be:

  • upper_t
  • lower_t

1.4.4 Expression Semantics

NameExpressionSemantics
Beginning of storagestorage(m)Returns a pointer to the beginning of the storage of matrix m
Size of storagestorage_size(m)Returns the size of the storage
Number of rowssize1(m)Returns the number of rows of matrix m
Number of columnssize2(m)Returns the number of columns matrix m
Leading dimensionleading_dimension(m)Returns the distance between pointers to the first element in consecutive rows/columns in case of row-major/column-major matrices [1]

[1] Not needed for all matrix types (e.g. not needed for triangular, symmetric and hermitian packed matrices).

1.4.5 Implementation

Implementation of matrix_traits<> is similar to the vector_traits<>'s implementation (subsection 1.3.5); only, first step is omitted because there is no reasonable default -- different matrix libraries provide different interfaces (for example, functions that return number of rows and columns are named size1(), size2() in uBLAS, dim1(), dim2() in TNT, and nrows(), ncols() in MTL). Definitions in matrix_traits.hpp are: 
  template <typename MIdentifier, typename MType>
  struct matrix_detail_traits {};

  template <typename MType>
  struct matrix_traits : matrix_detail_traits<typename boost::remove_const::type, MType> {};

Specialisations of matrix_detail_traits<> must provide types defined in subsection 1.4.3 and static member functions defined in subsection 1.4.4.

Example. Specialisation of matrix_detail_traits<> for ublas::matrix<> (see ublas_matrix.hpp): 

  template <typename T, typename F, typename ArrT, typename MType>
  struct matrix_detail_traits<boost::numeric::ublas::matrix<T,F,ArrT>, Mtype> {

    typedef general_t matrix_structure;
    typedef typename detail::ublas_ordering<typename F::orientation_category>::type ordering_type;

    typedef T value_type;
    typedef typename detail::generate_const<MType,T>::type* pointer; 

    static pointer storage (MType& m) {
      typedef typename detail::generate_const<MType,ArrT>::type array_type;
      return vector_traits<array_type>::storage (m.data());
    }
    static int size1 (MType& m) { return m.size1(); }
    static int size2 (MType& m) { return m.size2(); }
    static int storage_size (MType& m) { return size1 (m) * size2 (m); }
    static int leading_dimension (MType& m) { return F::size2 (m.size1(), m.size2()); }

    static int stride1 (MType& m) { return F::one1 (m.size1(), m.size2()); }
    static int stride2 (MType& m) { return F::one2 (m.size1(), m.size2()); }
  };
Notes:

[1] As ublas::matrix<> is general matrix, uplo_type is not defined.

[2] Metafunction detail::ublas_ordering<> (defined in detail/ublas_ordering.hpp) maps orientation_category, as defined in uBLAS, to corresponding ordering type.

[3] Note that the storage() function uses vector_traits::storage<>().

[4] This specialisation also defines functions stride1() and stride2() because they are needed in specialisations of vector_traits<> for ublas::matrix_row<> and ublas::matrix_column<>.

Example. Specialisation of matrix_detail_traits<> for ublas::symmetric_matrix<> (see ublas_symmetric.hpp): 

  template <typename T, typename F1, typename F2, typename A, typename MType>
  struct matrix_detail_traits<boost::numeric::ublas::symmetric_matrix<T, F1, F2, A>, Mtype> {

    typedef symmetric_packed_t matrix_structure;
    typedef typename detail::ublas_ordering<typename F2::orientation_category>::type ordering_type;
    typedef typename detail::ublas_uplo<typename F1::packed_category>::type uplo_type;

    typedef T value_type;
    typedef typename detail::generate_const<MType,T>::type* pointer; 

    static pointer storage (MType& sm) {
      typedef typename detail::generate_const<MType,A>::type array_type ;
      return vector_traits<array_type>::storage (sm.data());
    }
    static int size1 (MType& sm) { return sm.size1(); }
    static int size2 (MType& sm) { return sm.size2(); }
    static int storage_size (MType& sm) { return (size1 (sm) + 1) * size2 (sm) / 2; }
  };
This specialisation defines uplo_type, but leading_dimension() makes no sense for packed matrix storage types.

1.5 Sparse Matrix Traits

1.5.1 Description

Generic bindings functions which manipulate sparse matrices are written in terms of types (subsection 1.5.3), static constants (subsection 1.5.4) and static functions (subsection 1.5.5) defined in the sparse_matrix_traits<> class.

1.5.2 Definition

Generic class sparse_matrix_traits<> is defined in header boost/numeric/bindings/traits/sparse_traits.hpp.

Specialisations are defined in:

HeaderMatrix classes
ublas_sparse.hpp ublas::compressed_matrix<>, ublas::coordinate_matrix<>

All headers are in boost/numeric/bindings/traits/.

1.5.3 Associated Types

Value typevalue_typeThe type of the objects contained in the matrix
Value pointer typevalue_pointerData type used to point to (nonzero) matrix elements
Index pointer typeindex_pointerData type used to point to row and column indices
Matrix structurematrix_structureDescribes the pattern of nonzero and zero elements and the storage layout [1]
Ordering typeordering_typeRow or column major [2]
Storage formatstorage_formatData structure used to store the matrix [3]

[1] matrix_structure is a tag which can be:

  • general_t

[2] ordering_type can be:

  • row_major_t
  • column_major_t

[3] storage_format can be:

  • compressed_t
  • coordinate_t

1.5.4 Static Constants

BOOST_STATIC_CONSTANT (std::size_t, index_base);

1.5.5 Expression Semantics

NameExpressionSemantics
Major indexindex1_storage(m) Depends on storage_format and ordering_type [1]
Minor indexindex2_storage(m) Depends on storage_format and ordering_type [2]
Element storagestorage(m)Returns a pointer to the beginning of the storage of matrix entries [3]
Number of rowssize1(m)Returns the number of rows of matrix m
Number of columnssize2(m)Returns the number of columns matrix m
Number of entriesnum_nonzeros(m)Returns the number of matrix entries [3]

[1] Returned value is a pointer to the beginning of:

the array of column start locationsfor compressed column format;
the array of row start locationsfor compressed row format;
the array of column indicesfor column major coordinate format;
the array of row indicesfor row major coordinate format.

[2] Returned value is a pointer to the beginning of:

the array of row indicesfor compressed column format;
the array of column indicesfor compressed row format;
the array of row indicesfor column major coordinate format;
the array of column indicesfor row major coordinate format.

[3] All nonzeros are entries, but an entry may be numerically zero.

1.5.6 Implementation

Implementation of sparse_matrix_traits<> is similar to the matrix_traits<>'s implementation (subsection 1.4.5).

Specialisations of sparse_matrix_detail_traits<> must provide types defined in subsection 1.5.3, static constants defined in subsection 1.5.4 and static member functions defined in subsection 1.5.5.

1.6 Free functions

There are also free functions available to obtain storage layout information:

  • in vector_traits.hpp:

    ExpressionSemantics
    vector_storage(v)Returns a pointer to the beginning of the storage of vector v
    vector_size(v)Returns the size of vector v
    vector_stride(v)Returns the distance between pointers pointing to consecutive entries in v

  • in matrix_traits.hpp:

    ExpressionSemantics
    matrix_storage(m)Returns a pointer to the beginning of the storage of matrix m
    matrix_storage_size(m)Returns the size of the storage
    matrix_size1(m)Returns the number of rows of matrix m
    matrix_size2(m)Returns the number of columns matrix m
    leading_dimension(m)Returns the leading dimension of matrix m

The syntax of these is slightly simpler than that of the traits class; e.g. instead of 

  traits::vector_traits<some_vector_type const>::storage (v)
one can write 
  traits::vector_storage (v)

Although these free functions generally rely on the traits classes, they can also implement an alternative strategy on compilers that are unable to handle the traits idiom (see vector_raw.hpp and matrix_raw.hpp).

2. Calling conventions

To facilitate generic bindings for libraries of which the API is defined in Fortran, the Traits Library provides a multi-platform mapping between C and Fortran calling conventions: some Fortran compilers add a trailing underscore to all defined symbols, some generate symbols in uppercase only.

When including the traits/fortran.h header, one of following symbols will be defined:

  • BIND_FORTRAN_LOWERCASE_UNDERSCORE
  • BIND_FORTRAN_LOWERCASE
Function names are generated using the FORTRAN_ID macro: 
      #if defined(BIND_FORTRAN_LOWERCASE_UNDERSCORE)
      #define FORTRAN_ID( id ) id##_
      #elif defined(BIND_FORTRAN_LOWERCASE)
      #define FORTRAN_ID( id ) id
      #endif

Here's more information on how to call Fortran routines from C and C++.

3. Type mapping

See type.h for mapping of Fortran types to C.

See type.hpp for mapping of Fortran types to C++

See value_traits.hpp for value_type inside complex types. boost-bindings/libs/numeric/bindings/traits/boost-build.jam0000644000175000017500000000004610776013426024233 0ustar andreasandreasboost-build $(BOOST)/tools/build/v2 ; boost-bindings/libs/numeric/bindings/traits/project-root.jam0000644000175000017500000000000010776013426024425 0ustar andreasandreasboost-bindings/libs/numeric/bindings/umfpack/0000755000175000017500000000000010776013426021437 5ustar andreasandreasboost-bindings/libs/numeric/bindings/umfpack/test/0000755000175000017500000000000010776013426022416 5ustar andreasandreasboost-bindings/libs/numeric/bindings/umfpack/test/umf4.cc0000644000175000017500000002300410776013426023577 0ustar andreasandreas/* ========================================================================= */ /* === umf4 ================================================================ */ /* ========================================================================= */ /* ------------------------------------------------------------------------- */ /* UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. */ /* Davis. All Rights Reserved. See ../README for License. */ /* email: davis@cise.ufl.edu CISE Department, Univ. of Florida. */ /* web: http://www.cise.ufl.edu/research/sparse/umfpack */ /* ------------------------------------------------------------------------- */ /***********************************************************************/ /* UMFPACK Copyright, License and Availability */ /***********************************************************************/ /* * * UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. * Davis. All Rights Reserved. * * UMFPACK License: * * Your use or distribution of UMFPACK or any modified version of * UMFPACK implies that you agree to this License. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY * EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program, provided * that the Copyright, this License, and the Availability of the original * version is retained on all copies. User documentation of any code that * uses UMFPACK or any modified version of UMFPACK code must cite the * Copyright, this License, the Availability note, and "Used by permission." * Permission to modify the code and to distribute modified code is granted, * provided the Copyright, this License, and the Availability note are * retained, and a notice that the code was modified is included. This * software was developed with support from the National Science Foundation, * and is provided to you free of charge. * * Availability: * * http://www.cise.ufl.edu/research/sparse/umfpack * */ /* Used by permission. */ /* modified by Kresimir Fresl, 2003 */ /* UMFPACK bindings * ublas::compressed_matrix<> or ublas::coordinate_matrix<> * ... to use coordinate_matrix<> define COORDINATE */ /* Demo program for UMFPACK v4.1. * * Reads in a triplet-form matrix and right-hand side vector. * Input file format: * num_rows_of_A num_cols_of_A * num_nonzeros_in_A * row col val * row col val * ... * num_nonzeros_in_B * idx val * ... * * Then calls UMFPACK to analyze, factor, and solve the system. * * Syntax: * * umf4 default "auto" strategy, 1-norm row scaling * umf4 a default "auto" strategy, 1-norm row scaling * umf4 u unsymmetric strategy, 1-norm row scaling * umf4 s symmetric strategy, 1-norm row scaling * umf4 2 2-by-2 strategy, maxnorm row scaling * umf4 A default "auto" strategy, maxnorm row scaling * umf4 U unsymmetric strategy, maxnorm row scaling * umf4 S symmetric strategy, maxnorm row scaling * umf4 T 2-by-2 strategy , maxnorm row scaling * umf4 ?n ? can be in [aus2AUST], n: no aggressive absorption */ #include #include #include #include #include #include #ifdef __ICC # include #endif #include #include #include using std::max; using std::cout; using std::cin; using std::endl; using std::string; using std::ifstream; using std::ofstream; using std::exit; namespace ublas = boost::numeric::ublas; namespace umf = boost::numeric::bindings::umfpack; namespace traits = boost::numeric::bindings::traits; #ifndef COORDINATE typedef ublas::compressed_matrix, ublas::unbounded_array > cm_t; #else typedef ublas::coordinate_matrix, ublas::unbounded_array > cm_t; #endif typedef ublas::vector v_t; // wait for 'y' void wait4y() { char yes = 'n'; while (1) { cout << "Continue (y/n) -> "; cin >> yes; if (yes == 'y') break; } } // resid: compute the relative residual, ||Ax-b||/||b|| template double resid (M const& m, V const& x, V const& b, V& r) { int const* Ap = traits::spmatrix_index1_storage (m); int const* Ai = traits::spmatrix_index2_storage (m); double const* Ax = traits::spmatrix_value_storage (m); double rnorm, bnorm, absr, absb; int n = traits::vector_size (r); r = prod (m, x); #if 0 if (transpose) { int i; for (int j = 0; j < n; j++) for (int p = Ap [j]; p < Ap [j+1]; p++) { i = Ai [p]; r [j] += Ax [p] * x [i]; } } else { int i; for (int j = 0; j < n; j++) for (int p = Ap [j]; p < Ap [j+1]; p++) { i = Ai [p]; r [i] += Ax [p] * x [j]; } } #endif for (int i = 0; i < n; i++) r [i] -= b [i]; rnorm = 0.; bnorm = 0.; for (int i = 0; i < n; i++) { #ifndef NO_NAN if (isnan (r [i])){ rnorm = r [i]; break; } #endif absr = fabs (r [i]); rnorm = max (rnorm, absr); } for (int i = 0; i < n; i++) { #ifndef NO_NAN if (isnan (b [i])){ bnorm = b [i]; break; } absb = fabs (b [i]); bnorm = max (bnorm, absb); } #endif if (bnorm == 0) bnorm = 1; return (rnorm / bnorm); } //////////////////////////////////////////////////////////////// // main program int main (int argc, char **argv) { cout << "\n===========================================================\n" << "=== UMFPACK v4.1 ==========================================\n" << "===========================================================\n" << endl; // set controls umf::control_type<> Control; Control [UMFPACK_PRL] = 3; Control [UMFPACK_BLOCK_SIZE] = 32; if (argc > 1) { char *s = argv [1]; // get the strategy if (s [0] == 'u') Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_UNSYMMETRIC; else if (s [0] == 'a') Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_AUTO; else if (s [0] == 's') Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_SYMMETRIC; else if (s [0] == '2') Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_2BY2; else if (s [0] == 'U') { Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_UNSYMMETRIC; Control [UMFPACK_SCALE] = UMFPACK_SCALE_MAX; } else if (s [0] == 'A') { Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_AUTO; Control [UMFPACK_SCALE] = UMFPACK_SCALE_MAX; } else if (s [0] == 'S') { Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_SYMMETRIC; Control [UMFPACK_SCALE] = UMFPACK_SCALE_MAX; } else if (s [0] == 'T') { Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_2BY2; Control [UMFPACK_SCALE] = UMFPACK_SCALE_MAX; } else printf ("unrecognized strategy: %s\n", argv [1]); if (s [1] == 'n') // no aggressive absorption Control [UMFPACK_AGGRESSIVE] = 0; } umf::report_control (Control); // open the matrix file cout << "input file -> "; string ifs_name; cin >> ifs_name; ifstream f (ifs_name.c_str()); if (!f) { cout << "unable to open file" << endl; exit (1); } // initialize matrix A cout << "reading A" << endl; int nrow, ncol, nz; f >> nrow >> ncol >> nz; cm_t A (nrow, ncol, nz); int r, c; for (int i = 0; i < nz; ++i) { f >> r >> c; f >> A (r, c); } Control[UMFPACK_PRL] = (nz > 20) ? 4 : 5; cout << "matrix A: "; umf::report_matrix (A, Control); wait4y(); // symbolic factorization umf::info_type<> Info; umf::symbolic_type<> Symbolic; int status = umf::symbolic (A, Symbolic, Control, Info); cout << "symbolic status:" << endl; umf::report_status (Control, status); if (status != UMFPACK_OK) { umf::report_info (Control, Info); cout << "umf::symbolic failed" << endl; exit (1); } umf::report_symbolic (Symbolic, Control); wait4y(); // numeric factorization umf::numeric_type<> Numeric; status = umf::numeric (A, Symbolic, Numeric, Control, Info); cout << "numeric status:" << endl; umf::report_status (Control, status); if (status < UMFPACK_OK) { umf::report_info (Control, Info); cout << "umf::numeric failed" << endl; exit (1); } umf::report_numeric (Numeric, Control); wait4y(); // solve Ax=b if (nrow == ncol && status == UMFPACK_OK) { // create right-hand side vector B v_t B (ncol), X (ncol), R (ncol); cout << "reading B" << endl; int m2, ii; f >> m2; for (int i = 0; i < m2; ++i) { f >> ii; f >> B[ii]; } cout << "vector B: "; umf::report_vector (B, Control); status = umf::solve (A, X, B, Numeric, Control, Info); cout << "solve status:" << endl; umf::report_status (Control, status); umf::report_info (Control, Info); if (status < UMFPACK_OK) { cout << "umf::solve failed" << endl; exit (1); } cout << "solution vector X: "; umf::report_vector (X, Control); cout << "relative maxnorm of residual, ||Ax-b||/||b||: " << resid (A, X, B, R) << endl; } else { cout << "system not solved" << endl; umf::report_info (Control, Info); } cout << endl; } boost-bindings/libs/numeric/bindings/umfpack/test/umfpack_zi_demo.cc0000644000175000017500000004273610776013426026075 0ustar andreasandreas/* ====================================================================== */ /* === umfpack_zi_demo ================================================== */ /* ====================================================================== */ /* ---------------------------------------------------------------------- */ /* UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. */ /* Davis. All Rights Reserved. See ../README for License. */ /* email: davis@cise.ufl.edu CISE Department, Univ. of Florida. */ /* web: http://www.cise.ufl.edu/research/sparse/umfpack */ /* ---------------------------------------------------------------------- */ /***********************************************************************/ /* UMFPACK Copyright, License and Availability */ /***********************************************************************/ /* * * UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. * Davis. All Rights Reserved. * * UMFPACK License: * * Your use or distribution of UMFPACK or any modified version of * UMFPACK implies that you agree to this License. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY * EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program, provided * that the Copyright, this License, and the Availability of the original * version is retained on all copies. User documentation of any code that * uses UMFPACK or any modified version of UMFPACK code must cite the * Copyright, this License, the Availability note, and "Used by permission." * Permission to modify the code and to distribute modified code is granted, * provided the Copyright, this License, and the Availability note are * retained, and a notice that the code was modified is included. This * software was developed with support from the National Science Foundation, * and is provided to you free of charge. * * Availability: * * http://www.cise.ufl.edu/research/sparse/umfpack * */ /* Used by permission. */ /* modified by Kresimir Fresl, 2003 */ /* UMFPACK bindings & ublas::compressed_matrix<> */ /* A demo of UMFPACK: umfpack_zi_* version. First, factor and solve a 5-by-5 system, Ax=b, using default parameters. Then solve A'x=b using the factors of A. Modify one entry (A (1,4) = 0, where the row and column indices range from 0 to 4. The pattern of A has not changed (it has explicitly zero entry), so a reanalysis with umfpack_zi_symbolic does not need to be done. Refactorize (with umfpack_zi_numeric), and solve Ax=b. Note that the pivot ordering has changed. Next, change all of the entries in A, but not the pattern. Finally, compute C = A', and do the symbolic and numeric factorization of C. Factorizing A' can sometimes be better than factorizing A itself (less work and memory usage). Solve C'x=b; the solution is the same as the solution to Ax=b. */ #include #include #include #include #include #include #include #include #include #include using std::max; using std::cout; using std::cin; using std::endl; using std::exit; namespace ublas = boost::numeric::ublas; namespace umf = boost::numeric::bindings::umfpack; namespace traits = boost::numeric::bindings::traits; typedef ublas::compressed_matrix< std::complex, ublas::column_major, 0, ublas::unbounded_array, ublas::unbounded_array > > cm_t; typedef std::vector > v_t; /* --------------------------------------------------------------- */ /* wait for 'y' */ /* --------------------------------------------------------------- */ void wait4y() { char yes = 'n'; while (1) { cout << "Continue (y/n) -> "; cin >> yes; if (yes == 'y') break; } } /* --------------------------------------------------------------- */ /* error: print a message and exit */ /* --------------------------------------------------------------- */ void error (char *message) { cout << "\n\n====== error: " << message << " =====\n" << endl; exit (1); } /* ------------------------------------------------------------------------- */ /* resid: compute the residual, r = Ax-b or r = A'x=b and return maxnorm (r) */ /* A' is the complex conjugate transpose, not the array transpose */ /* note: works only with compressed column matrices */ /* ------------------------------------------------------------------------- */ template double resid (M const& A, V const& x, V const& b, V& r, int transpose = 0) { double norm; int const* Ap = traits::spmatrix_index1_storage (A); int const* Ai = traits::spmatrix_index2_storage (A); std::complex const* Ax = traits::spmatrix_value_storage (A); int n = traits::vector_size (r); for (int i = 0; i < n; i++) r [i] = -b [i]; if (transpose) { int i; for (int j = 0; j < n; j++) for (int p = Ap [j]; p < Ap [j+1]; p++) { i = Ai [p]; r [j] += std::conj (Ax [p]) * x [i]; } } else { int i; for (int j = 0; j < n; j++) for (int p = Ap [j]; p < Ap [j+1]; p++) { i = Ai [p]; r [i] += Ax [p] * x [j]; } } norm = 0. ; for (int i = 0 ; i < n ; i++) norm = max (std::abs (r [i]), norm); return (norm) ; } /* ------------------------------------------------------------------- */ /* main program */ /* ------------------------------------------------------------------- */ int main() { /* ---------------------------------------------------------------- */ /* initialisations */ /* ---------------------------------------------------------------- */ cout << "\n" << UMFPACK_VERSION << " demo: _di_ version\n" << endl; // get the default control parameters umf::control_type > Control; // change the default print level for this demo // (otherwise, nothing will print) Control [UMFPACK_PRL] = 6; // print the license agreement umf::report_status (Control, UMFPACK_OK); Control [UMFPACK_PRL] = 5; // print the control parameters umf::report_control (Control); umf::info_type > Info; // matrix A int n = 5, nz = 12 ; int Arow [ ] = { 0, 4, 1, 1, 2, 2, 0, 1, 2, 3, 4, 4} ; int Acol [ ] = { 0, 4, 0, 2, 1, 2, 1, 4, 3, 2, 1, 2} ; double Aval [ ] = {2., 1., 3., 4., -1., -3., 3., 6., 2., 1., 4., 2.} ; double Avalz[ ] = {1., .4, .1, .2, -1., -.2, 0., 6., 3., 0., .3, .3} ; cm_t A (n, n, nz); for (int i = 0; i < nz; ++i) A (Arow[i], Acol[i]) = std::complex (Aval[i], Avalz[i]); cout << "matrix A: "; umf::report_matrix (A, Control); // right-hand-side etc. double bx[ ] = {8., 45., -3., 3., 19.}; double bz[ ] = {1., -5., -2., 0., 2.2}; v_t b (n), x (n), r (n); for (int i = 0; i < n; ++i) b[i] = std::complex (bx[i], bz[i]); cout << "vector B: "; umf::report_vector (b, Control); /* ---------------------------------------------------------------- */ /* symbolic factorisation */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nSymbolic factorisation:" << endl; umf::symbolic_type > Symbolic; int status = umf::symbolic (A, Symbolic, Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::symbolic failed"); } umf::report_symbolic (Symbolic, Control); /* ---------------------------------------------------------------- */ /* numeric factorisation */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nNumeric factorisation:" << endl; umf::numeric_type > Numeric; status = umf::numeric (A, Symbolic, Numeric,Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::numeric failed"); } umf::report_numeric (Numeric, Control); /* ---------------------------------------------------------------- */ /* solve Ax=b */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nSolve Ax = b:" << endl; status = umf::solve (UMFPACK_A, A, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (solution of Ax=b): "; umf::report_vector (x, Control); double rnorm = resid (A, x, b, r); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ---------------------------------------------------------------- */ /* solve Ax=b, broken down into steps */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nSolve Ax = b (broken down into steps):" << endl; // Rb = R*b std::vector > Rb (n), y (n); status = umf::scale (Rb, b, Numeric); if (status < 0) error ("umf::scale failed"); // solve Ly = P*(Rb) status = umf::solve (UMFPACK_Pt_L, A, y, Rb, Numeric, Control, Info); if (status < 0) error ("first umf::solve failed"); // solve UQ'x=y status = umf::solve (UMFPACK_U_Qt, A, x, y, Numeric, Control, Info); if (status < 0) error ("second umf::solve failed"); cout << "\nx (solution of Ax=b, solve is split into 3 steps): "; umf::report_vector (x, Control); rnorm = resid (A, x, b, r); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ------------------------------------------------------------------- */ /* solve A'x=b */ /* note that this is the complex conjugate transpose, A' */ /* ------------------------------------------------------------------- */ wait4y(); cout << "\nSolve A'x = b:" << endl; status = umf::solve (UMFPACK_At, A, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (solution of A'x=b): "; umf::report_vector (x, Control); rnorm = resid (A, x, b, r, 1); // '1' -- transpose cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ----------------------------------------------------------------- */ /* modify one numerical value in the column-form of A */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nModify A (1,4) if present:" << endl; int row = 1, col = 4; cm_t::iterator1 i1 = A.begin1(); ++i1; // go to row 1 cm_t::iterator2 i2 = i1.begin(); for (; i2 != i1.end(); ++i2) if (i2.index2() == 4) break; if (i2 != i1.end()) { if (i2.index1() != 1 || i2.index2() != 4) error ("something\'s very wrong"); cout << "\nchanging A (1,4) to zero" << endl; A (1, 4) = 0.0; } cout << "\nmodified A: "; umf::report_matrix (A, Control); /* ----------------------------------------------------------------- */ /* redo the numeric factorization */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nRedo the numeric factorization:" << endl; // The pattern (Ap and Ai) hasn't changed, so the symbolic factorisation // doesn't have to be redone, no matter how much we change Ax. // We don't need the Numeric object any more, so free it. umf::free (Numeric); // or: Numeric.free(); // Note that a memory leak would have occured if the old Numeric // had not been free'd. status = umf::numeric (A, Symbolic, Numeric, Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::numeric failed"); } cout << "\nNumeric factorization of modified A: "; umf::report_numeric (Numeric, Control); /* ------------------------------------------------------------------ */ /* solve Ax=b, with the modified A */ /* ------------------------------------------------------------------ */ wait4y(); cout << "\nSolve Ax = b with the modified A:" << endl; status = umf::solve (A, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (with modified A): "; umf::report_vector (x, Control); rnorm = resid (A, x, b, r); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ------------------------------------------------------------------ */ /* modify all of the numerical values of A, but not the pattern */ /* ------------------------------------------------------------------ */ wait4y(); cout << "\nModify numerical values of A:" << endl; for (i2 = A.begin2(); i2 != A.end2(); ++i2) for (i1 = i2.begin(); i1 != i2.end(); ++i1) { std::complex c = *i1; cout << "changing A (" << i1.index1() << "," << i1.index2() << ") from " << c; double a = std::real (c) + 10 * i1.index2() - i1.index1(); double ai = std::imag (c); c = std::complex (a, ai); cout << " to " << c << endl; *i1 = c; } cout << endl; cout << "\ncompletely modified A (same pattern): "; umf::report_matrix (A, Control); /* ------------------------------------------------------------------ */ /* redo the numeric factorization */ /* ------------------------------------------------------------------ */ wait4y(); cout << "\nRedo the numeric factorization:" << endl; umf::free (Numeric); status = umf::numeric (A, Symbolic, Numeric, Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::numeric failed"); } cout << "\nNumeric factorization of completely modified A: "; umf::report_numeric (Numeric, Control); /* ------------------------------------------------------------------ */ /* solve Ax=b, with the modified A */ /* ------------------------------------------------------------------ */ wait4y(); cout << "\nSolve Ax = b with the modified A:" << endl; status = umf::solve (A, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (with completely modified A): "; umf::report_vector (x, Control); rnorm = resid (A, x, b, r); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ---------------------------------------------------------------- */ /* free the symbolic and numeric factorization */ /* ---------------------------------------------------------------- */ Symbolic.free(); Numeric.free(); /* ---------------------------------------------------------------- */ /* C = transpose of A */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nC = transpose of A:" << endl; cm_t C (herm (A)); umf::report_matrix (C, Control); /* ----------------------------------------------------------------- */ /* symbolic factorization of C */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nSymbolic factorization of C:" << endl; status = umf::symbolic (C, Symbolic,Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::symbolic failed"); } umf::report_symbolic (Symbolic, Control); /* ----------------------------------------------------------------- */ /* numeric factorization of C */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nNumeric factorization of C:" << endl; status = umf::numeric (C, Symbolic, Numeric,Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::numeric failed"); } umf::report_numeric (Numeric, Control); /* ----------------------------------------------------------------- */ /* solve C'x=b */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nSolve C'x = b:" << endl; status = umf::solve (UMFPACK_At, C, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (solution of C'x=b): "; umf::report_vector (x, Control); rnorm = resid (C, x, b, r, 1); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; } boost-bindings/libs/numeric/bindings/umfpack/test/umfpack_simple.cc0000644000175000017500000000607610776013426025735 0ustar andreasandreas/* ------------------------------------------------------------------------- */ /* UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. */ /* Davis. All Rights Reserved. See ../README for License. */ /* email: davis@cise.ufl.edu CISE Department, Univ. of Florida. */ /* web: http://www.cise.ufl.edu/research/sparse/umfpack */ /* ------------------------------------------------------------------------- */ /***********************************************************************/ /* UMFPACK Copyright, License and Availability */ /***********************************************************************/ /* * * UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. * Davis. All Rights Reserved. * * UMFPACK License: * * Your use or distribution of UMFPACK or any modified version of * UMFPACK implies that you agree to this License. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY * EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program, provided * that the Copyright, this License, and the Availability of the original * version is retained on all copies. User documentation of any code that * uses UMFPACK or any modified version of UMFPACK code must cite the * Copyright, this License, the Availability note, and "Used by permission." * Permission to modify the code and to distribute modified code is granted, * provided the Copyright, this License, and the Availability note are * retained, and a notice that the code was modified is included. This * software was developed with support from the National Science Foundation, * and is provided to you free of charge. * * Availability: * * http://www.cise.ufl.edu/research/sparse/umfpack * */ /* Used by permission. */ /* Simple demo program for UMFPACK */ /* from UMFPACK Version 4.1 Quick Start Guide */ /* modified by Kresimir Fresl, 2003 */ /* UMFPACK bindings & ublas::compressed_matrix<> */ #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace umf = boost::numeric::bindings::umfpack; int main() { ublas::compressed_matrix, ublas::unbounded_array > A (5,5,12); ublas::vector B (5), X (5); A(0,0) = 2.; A(0,1) = 3; A(1,0) = 3.; A(1,2) = 4.; A(1,4) = 6; A(2,1) = -1.; A(2,2) = -3.; A(2,3) = 2.; A(3,2) = 1.; A(4,1) = 4.; A(4,2) = 2.; A(4,4) = 1.; B(0) = 8.; B(1) = 45.; B(2) = -3.; B(3) = 3.; B(4) = 19.; umf::symbolic_type Symbolic; umf::numeric_type Numeric; umf::symbolic (A, Symbolic); umf::numeric (A, Symbolic, Numeric); umf::solve (A, X, B, Numeric); std::cout << X << std::endl; // output: [5](1,2,3,4,5) } boost-bindings/libs/numeric/bindings/umfpack/test/in10000644000175000017500000000022210776013426023024 0ustar andreasandreas5 5 12 0 0 19.0 1 0 12.0 4 0 12.0 1 1 21.0 2 1 12.0 4 1 12.0 0 2 21.0 2 2 16.0 0 3 21.0 3 3 5.0 3 4 21.0 4 4 18.0 5 0 1.0 1 1.0 2 1.0 3 1.0 4 1.0 boost-bindings/libs/numeric/bindings/umfpack/test/in40000644000175000017500000000132710776013426023036 0ustar andreasandreas12 12 68 0 0 0.5904 2 0 1.327 6 0 0.4366 8 0 3.106 9 0 -27.2 0 1 -0.4 2 1 -1.327 3 1 -19.0 6 1 0.5904 8 1 -1.416 0 2 -0.19 3 2 18.389 5 2 -1.42 9 2 0.611 11 2 -1.42 3 3 0.611 5 3 1.42 6 3 -0.272 9 3 25.629 11 3 -0.5 1 4 -0.347 7 4 -0.0589 8 4 0.0519 10 4 -1.405 11 4 3.09 1 5 0.251 2 5 0.295 4 5 -0.478 5 5 1.05 7 5 -0.947 1 6 -0.004 2 6 -0.275 4 6 21.078 5 6 -1.05 10 6 -20.6 4 7 -20.6 7 7 -0.014 8 7 -0.0519 10 7 46 11 7 -3.09 0 8 1.416 2 8 2.477 6 8 0.274 7 8 0.0519 8 8 8.905 10 8 -5.19 11 8 3.176 0 9 1.327 1 9 0.295 2 9 3.772 4 9 -29.5 5 9 3.12 6 9 -1.327 8 9 2.477 1 10 0.01 2 10 0.0312 3 10 1.42 4 10 -1.05 5 10 7.49 9 10 -1.92 11 10 2.2 3 11 1.42 5 11 2.2 7 11 3.09 8 11 9.176 9 11 0.5 10 11 -3.09 11 11 18.6 1 3 1 2 boost-bindings/libs/numeric/bindings/umfpack/test/umfpack_di_demo.cc0000644000175000017500000004134110776013426026036 0ustar andreasandreas /* ====================================================================== */ /* === umfpack_di_demo ================================================== */ /* ====================================================================== */ /* ---------------------------------------------------------------------- */ /* UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. */ /* Davis. All Rights Reserved. See ../README for License. */ /* email: davis@cise.ufl.edu CISE Department, Univ. of Florida. */ /* web: http://www.cise.ufl.edu/research/sparse/umfpack */ /* ---------------------------------------------------------------------- */ /***********************************************************************/ /* UMFPACK Copyright, License and Availability */ /***********************************************************************/ /* * * UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. * Davis. All Rights Reserved. * * UMFPACK License: * * Your use or distribution of UMFPACK or any modified version of * UMFPACK implies that you agree to this License. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY * EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program, provided * that the Copyright, this License, and the Availability of the original * version is retained on all copies. User documentation of any code that * uses UMFPACK or any modified version of UMFPACK code must cite the * Copyright, this License, the Availability note, and "Used by permission." * Permission to modify the code and to distribute modified code is granted, * provided the Copyright, this License, and the Availability note are * retained, and a notice that the code was modified is included. This * software was developed with support from the National Science Foundation, * and is provided to you free of charge. * * Availability: * * http://www.cise.ufl.edu/research/sparse/umfpack * */ /* Used by permission. */ /* modified by Kresimir Fresl, 2003 */ /* UMFPACK bindings & ublas::compressed_matrix<> */ /* A demo of UMFPACK: umfpack_di_* version. First, factor and solve a 5-by-5 system, Ax=b, using default parameters. Then solve A'x=b using the factors of A. Modify one entry (A (1,4) = 0, where the row and column indices range from 0 to 4. The pattern of A has not changed (it has explicitly zero entry), so a reanalysis with umfpack_di_symbolic does not need to be done. Refactorize (with umfpack_di_numeric), and solve Ax=b. Note that the pivot ordering has changed. Next, change all of the entries in A, but not the pattern. Finally, compute C = A', and do the symbolic and numeric factorization of C. Factorizing A' can sometimes be better than factorizing A itself (less work and memory usage). Solve C'x=b; the solution is the same as the solution to Ax=b. */ #include #include #include #include #include #include #include #include #include using std::max; using std::cout; using std::cin; using std::endl; using std::exit; namespace ublas = boost::numeric::ublas; namespace umf = boost::numeric::bindings::umfpack; namespace traits = boost::numeric::bindings::traits; typedef ublas::compressed_matrix, ublas::unbounded_array > cm_t; /* --------------------------------------------------------------- */ /* wait for 'y' */ /* --------------------------------------------------------------- */ void wait4y() { char yes = 'n'; while (1) { cout << "Continue (y/n) -> "; cin >> yes; if (yes == 'y') break; } } /* --------------------------------------------------------------- */ /* error: print a message and exit */ /* --------------------------------------------------------------- */ void error (char *message) { cout << "\n\n====== error: " << message << " =====\n" << endl; exit (1); } /* ------------------------------------------------------------------------- */ /* resid: compute the residual, r = Ax-b or r = A'x=b and return maxnorm (r) */ /* note: works only with compressed column matrices */ /* ------------------------------------------------------------------------- */ template double resid (M const& A, V const& x, V const& b, V& r, int transpose = 0) { double norm; int const* Ap = traits::spmatrix_index1_storage (A); int const* Ai = traits::spmatrix_index2_storage (A); double const* Ax = traits::spmatrix_value_storage (A); int n = traits::vector_size (r); for (int i = 0; i < n; i++) r [i] = -b [i]; if (transpose) { int i; for (int j = 0; j < n; j++) for (int p = Ap [j]; p < Ap [j+1]; p++) { i = Ai [p]; r [j] += Ax [p] * x [i]; } } else { int i; for (int j = 0; j < n; j++) for (int p = Ap [j]; p < Ap [j+1]; p++) { i = Ai [p]; r [i] += Ax [p] * x [j]; } } norm = 0.; for (int i = 0; i < n; i++) norm = max (fabs (r [i]), norm); return (norm); } /* ------------------------------------------------------------------- */ /* main program */ /* ------------------------------------------------------------------- */ int main() { /* ---------------------------------------------------------------- */ /* initialisations */ /* ---------------------------------------------------------------- */ cout << "\n" << UMFPACK_VERSION << " demo: _di_ version\n" << endl; // get the default control parameters umf::control_type<> Control; // change the default print level for this demo // (otherwise, nothing will print) Control [UMFPACK_PRL] = 6; // print the license agreement umf::report_status (Control, UMFPACK_OK); Control [UMFPACK_PRL] = 5; // print the control parameters umf::report_control (Control); umf::info_type<> Info; // matrix A int n = 5, nz = 12; int Arow [ ] = { 0, 4, 1, 1, 2, 2, 0, 1, 2, 3, 4, 4}; int Acol [ ] = { 0, 4, 0, 2, 1, 2, 1, 4, 3, 2, 1, 2}; double Aval [ ] = {2., 1., 3., 4., -1., -3., 3., 6., 2., 1., 4., 2.}; cm_t A (n, n, nz); for (int i = 0; i < nz; ++i) A (Arow[i], Acol[i]) = Aval[i]; cout << "matrix A: "; umf::report_matrix (A, Control); // right-hand-side etc. double b [ ] = {8., 45., -3., 3., 19.}, x [5], r [5]; cout << "vector B: "; umf::report_vector (b, Control); /* ---------------------------------------------------------------- */ /* symbolic factorisation */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nSymbolic factorisation:" << endl; umf::symbolic_type<> Symbolic; int status = umf::symbolic (A, Symbolic, Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::symbolic failed"); } umf::report_symbolic (Symbolic, Control); /* ---------------------------------------------------------------- */ /* numeric factorisation */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nNumeric factorisation:" << endl; umf::numeric_type<> Numeric; status = umf::numeric (A, Symbolic, Numeric,Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::numeric failed"); } umf::report_numeric (Numeric, Control); /* ---------------------------------------------------------------- */ /* solve Ax=b */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nSolve Ax = b:" << endl; status = umf::solve (UMFPACK_A, A, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (solution of Ax=b): "; umf::report_vector (x, Control); double rnorm = resid (A, x, b, r); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ---------------------------------------------------------------- */ /* solve Ax=b, broken down into steps */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nSolve Ax = b (broken down into steps):" << endl; // Rb = R*b std::vector Rb (n), y (n); status = umf::scale (Rb, b, Numeric); if (status < 0) error ("umf::scale failed"); // solve Ly = P*(Rb) status = umf::solve (UMFPACK_Pt_L, A, y, Rb, Numeric, Control, Info); if (status < 0) error ("first umf::solve failed"); // solve UQ'x=y status = umf::solve (UMFPACK_U_Qt, A, x, y, Numeric, Control, Info); if (status < 0) error ("second umf::solve failed"); cout << "\nx (solution of Ax=b, solve is split into 3 steps): "; umf::report_vector (x, Control); rnorm = resid (A, x, b, r); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ------------------------------------------------------------------- */ /* solve A'x=b */ /* ------------------------------------------------------------------- */ wait4y(); cout << "\nSolve A'x = b:" << endl; status = umf::solve (UMFPACK_At, A, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (solution of A'x=b): "; umf::report_vector (x, Control); rnorm = resid (A, x, b, r, 1); // '1' -- transpose cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ----------------------------------------------------------------- */ /* modify one numerical value in the column-form of A */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nModify A (1,4) if present:" << endl; int row = 1, col = 4; cm_t::iterator1 i1 = A.begin1(); ++i1; // go to row 1 cm_t::iterator2 i2 = i1.begin(); for (; i2 != i1.end(); ++i2) if (i2.index2() == 4) break; if (i2 != i1.end()) { if (i2.index1() != 1 || i2.index2() != 4) error ("something\'s very wrong"); cout << "\nchanging A (1,4) to zero" << endl; A (1, 4) = 0.0; } cout << "\nmodified A: "; umf::report_matrix (A, Control); /* ----------------------------------------------------------------- */ /* redo the numeric factorization */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nRedo the numeric factorization:" << endl; // The pattern (Ap and Ai) hasn't changed, so the symbolic factorisation // doesn't have to be redone, no matter how much we change Ax. // We don't need the Numeric object any more, so free it. umf::free (Numeric); // or: Numeric.free(); // Note that a memory leak would have occured if the old Numeric // had not been free'd. status = umf::numeric (A, Symbolic, Numeric, Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::numeric failed"); } cout << "\nNumeric factorization of modified A: "; umf::report_numeric (Numeric, Control); /* ------------------------------------------------------------------ */ /* solve Ax=b, with the modified A */ /* ------------------------------------------------------------------ */ wait4y(); cout << "\nSolve Ax = b with the modified A:" << endl; status = umf::solve (A, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (with modified A): "; umf::report_vector (x, Control); rnorm = resid (A, x, b, r); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ------------------------------------------------------------------ */ /* modify all of the numerical values of A, but not the pattern */ /* ------------------------------------------------------------------ */ wait4y(); cout << "\nModify numerical values of A:" << endl; for (i2 = A.begin2(); i2 != A.end2(); ++i2) for (i1 = i2.begin(); i1 != i2.end(); ++i1) { cout << "changing A (" << i1.index1() << "," << i1.index2() << ") from " << *i1; double a = *i1 + 10 * i1.index2() - i1.index1(); *i1 = a; cout << " to " << *i1 << endl; } cout << endl; cout << "\ncompletely modified A (same pattern): "; umf::report_matrix (A, Control); /* ------------------------------------------------------------------ */ /* redo the numeric factorization */ /* ------------------------------------------------------------------ */ wait4y(); cout << "\nRedo the numeric factorization:" << endl; umf::free (Numeric); status = umf::numeric (A, Symbolic, Numeric, Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::numeric failed"); } cout << "\nNumeric factorization of completely modified A: "; umf::report_numeric (Numeric, Control); /* ------------------------------------------------------------------ */ /* solve Ax=b, with the modified A */ /* ------------------------------------------------------------------ */ wait4y(); cout << "\nSolve Ax = b with the modified A:" << endl; status = umf::solve (A, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (with completely modified A): "; umf::report_vector (x, Control); rnorm = resid (A, x, b, r); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; /* ---------------------------------------------------------------- */ /* free the symbolic and numeric factorization */ /* ---------------------------------------------------------------- */ Symbolic.free(); Numeric.free(); /* ---------------------------------------------------------------- */ /* C = transpose of A */ /* ---------------------------------------------------------------- */ wait4y(); cout << "\nC = transpose of A:" << endl; cm_t C (trans (A)); umf::report_matrix (C, Control); /* ----------------------------------------------------------------- */ /* symbolic factorization of C */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nSymbolic factorization of C:" << endl; status = umf::symbolic (C, Symbolic,Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::symbolic failed"); } umf::report_symbolic (Symbolic, Control); /* ----------------------------------------------------------------- */ /* numeric factorization of C */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nNumeric factorization of C:" << endl; status = umf::numeric (C, Symbolic, Numeric,Control, Info); umf::report_status (Control, status); if (status < 0) { umf::report_info (Control, Info); error ("umf::numeric failed"); } umf::report_numeric (Numeric, Control); /* ----------------------------------------------------------------- */ /* solve C'x=b */ /* ----------------------------------------------------------------- */ wait4y(); cout << "\nSolve C'x = b:" << endl; status = umf::solve (UMFPACK_At, C, x, b, Numeric, Control, Info); umf::report_status (Control, status); umf::report_info (Control, Info); if (status < 0) error ("umf::solve failed"); cout << "\nx (solution of C'x=b): "; umf::report_vector (x, Control); rnorm = resid (C, x, b, r, 1); cout << "\nmaxnorm of residual: " << rnorm << endl << endl; } boost-bindings/libs/numeric/bindings/umfpack/doc/0000755000175000017500000000000010776013426022204 5ustar andreasandreasboost-bindings/libs/numeric/bindings/umfpack/doc/index.html0000644000175000017500000006474010776013426024214 0ustar andreasandreas Boost.Numeric.Bindings.UMFPACK

C++ Boost

Boost.Numeric.Bindings.UMFPACK


Back to Bindings Library Synopsis

Contents

  1. Introduction
  2. Using UMFPACK bindings
    1. Solving Linear Systems
    2. Function Call Syntax and Semantics
      1. symbolic()
      2. numeric()
      3. factor()
      4. solve()
      5. umf_solve()
      6. free()
      7. defaults()
      8. scale()
      9. report_status()
      10. report_control()
      11. report_info()
      12. report_matrix()
      13. report_vector()
      14. report_symbolic()
      15. report_numeric()
      16. report_permutation()
  3. Matrix Storage Schemes
  4. Associted Types
  5. UMFPACK Copyright, Licence and Availability

1. Introduction

UMFPACK (current version 4.1) is a set of functions for the direct solution of systems of linear equations Ax=b and related systems, where A is sparse and unsymmetric coefficient matrix, b is right-hand side vector and x is vector of unknowns. Matrix A can be square or rectangular, regular or singular. Rectangular matrices can only be factorised; to solve the system Ax=b, matrix A must be square. (If solving system with singular A, divide by zero will occur and solutions will contain Infs and/or NaNs, but parts of the solution may be valid.) Matrix elements can be real (C/C++ type double) or complex (real and imaginary part are represented by doubles).

UMFPACK is based on the Unsymmetric-pattern MultiFrontal method. It factorises PAQ, PRAQ or PR-1AQ into LU, where:

  • P and Q are permutation matrices -- column ordering Q is selected to give a good a priori upper bound on fill-in and is refined during numerical factorisation, while the row ordering P has the dual role of preserving sparsity and maintaining numerical accuracy via relaxed partial pivoting and row interchanges;
  • R is a diagonal matrix of row scaling factors;
  • L and U are lower and upper triangular matrices.
Method is described in more details in: Timothy A. Davis, A column pre-ordering strategy for the unsymmetric-pattern multifrontal method, Univ. of Florida, CISE Dept., Technical report TR-03-006, 2003 (PDF or PS).

UMFPACK (version 4.1) is written in ANSI C. Interface of the so-called primary routines, with a simple example, is described in: Timothy A. Davis, UMFPACK Version 4.1 Quick Start Guide, TR-03-009 (PDF); see also: Timothy A. Davis, Algorithm 8xx: UMFPACK V4.1, an unsymmetric-pattern multifrontal method, TR-03-007 (PDF or PS). Detailed description of the C interface is given in: Timothy A. Davis, UMFPACK Version 4.1 User Guide, TR-03-008 (PDF).

UMFPACK Bindings Library provides generic, higher level interface to UMFPACK functions. By `generic' we mean that bindings are based on traits and therefore can be used with various matrix and vector classes, and by `higher level' that some complexities of the C interface are hidden from the user.

2. Using UMFPACK bindings

All header files are in the directory boost/numeric/bindings/umfpack. C++ program should include umfpack.hpp. All `public' functions are in the namespace boost::numeric::bindings::umfpack.

The location of UMFPACK header files may depend on your installation, so probably you should edit umfpack_incl.hpp providing your path to UMFPACK's header umfpack.h.

2.1 Solving Linear Systems

Let's start with a short program which illustrates the basic usage of UMFPACK bindings (this is an adaptation of the simple introductory example from UMFPACK documentation): 
    #include <iostream>
    #include <boost/numeric/bindings/traits/ublas_vector.hpp>
    #include <boost/numeric/bindings/traits/ublas_sparse.hpp>
    #include <boost/numeric/bindings/umfpack/umfpack.hpp>
    #include <boost/numeric/ublas/io.hpp>

    namespace ublas = boost::numeric::ublas;
    namespace umf = boost::numeric::bindings::umfpack;

    int main() {

      ublas::compressed_matrix<double, ublas::column_major, 0,
       ublas::unbounded_array<int>, ublas::unbounded_array<double> > A (5,5,12); 
      ublas::vector<double> B (5), X (5);

      A(0,0) = 2.; A(0,1) = 3; 
      A(1,0) = 3.; A(1,2) = 4.; A(1,4) = 6;
      A(2,1) = -1.; A(2,2) = -3.; A(2,3) = 2.;
      A(3,2) = 1.;
      A(4,1) = 4.; A(4,2) = 2.; A(4,4) = 1.; 

      B(0) = 8.; B(1) = 45.; B(2) = -3.; B(3) = 3.; B(4) = 19.; 

      umf::symbolic_type<double> Symbolic;
      umf::numeric_type<double> Numeric;

      umf::symbolic (A, Symbolic); 
      umf::numeric (A, Symbolic, Numeric); 
      umf::solve (A, X, B, Numeric);   

      std::cout << X << std::endl;  // output: [5](1,2,3,4,5)
    }
Solution of the linear system AX = B consists of three steps: symbolic analysis of the matrix A, numerical factorisation and backward substition. In more details:
  1. Function symbolic() pre-orders the columns of A to reduce fill-in (using COLAMD, AMD or user-provided ordering), finds the supernodal column elimination tree and post-orders the tree. (Matrix A can be rectangular or square.) Symbolic analysis details are returned in an object of type symbolic_type<> (see sec. 4) which is passed by reference.
  2. Function numeric() performs the numerical factorisation PAQ = LU, PRAQ = LU or PR-1AQ = LU, using the symbolic analysis previously computed by symbolic(). Numerical factorisation is returned in an object of type numeric_type<> (see sec. 4) which is passed by reference.
  3. Function solve() solves a linear system for the solution X, using numerical factorisation previously computed by numeric(). Only square systems are handled. Optionally, function performs iterative refinement.

Functions symbolic(), numeric() and solve() correspond to UMFPACK's functions umfpack_*_symbolic()/umfpack_*_qsymbolic(), umfpack_*_numeric() and umfpack_*_solve(), where * can be di or zi, that is, matrix and vector elements can be doubles or complex numbers represented by two doubles, while indices, sizes etc. have type int.

Bindings provide two additional functions:

  • factor() combines symbolic analysis and numerical factorisation (symbolic_type<> object is used only internally): 
         // ...
     umf::numeric_type Numeric;

     umf::factor (A, Numeric);
     umf::solve (A, X, B, Numeric);
  • umf_solve() combines all three steps (both symbolic_type<> and numeric_type<> objects are used internally): 
         // ...
     umf::umf_solve (A, X, B);

2.2 Function Call Syntax and Semantics

Used symbols:

SymbolType
status, sys int
A matrix (see sec. 3)
B, X vector
Qinit vector of ints
Symbolic symbolic_type<> (see sec. 4)
Numeric numeric_type<> (see sec. 4)
Control control_type<> (see sec. 4)
Info info_type<> (see sec. 4).

For possible values assigned to status see UMFPACK User Guide.

2.2.1 symbolic()

Performs symbolic analysis. (Calls umfpack_*_symbolic() or umfpack_*_qsymbolic().)

Syntax:

1  status = symbolic (A, Symbolic);
2  status = symbolic (A, Symbolic, Control);
3  status = symbolic (A, Symbolic, Control, Info);
4  status = symbolic (A, Qinit, Symbolic);
5  status = symbolic (A, Qinit, Symbolic, Control);
6  status = symbolic (A, Qinit, Symbolic, Control, Info);  

Symbolic analysis details are returned in Symbolic.

1, 2, 3 use COLAMD or AMD for column pre-ordering, while 4, 5, 6 use pre-ordering given in Qinit (for more details see UMFPACK documentation).

1, 4 use default control settings; 2, 3, 5, 6 use control settings given in Control.

3, 6 return statistics about ordering in Info.

2.2.2 numeric()

Performs numerical factorisation using Symbolic computed previously by symbolic(). (Calls umfpack_*_numeric()).

Syntax:

1  status = numeric (A, Symbolic, Numeric);
2  status = numeric (A, Symbolic, Numeric, Control);
3  status = numeric (A, Symbolic, Numeric, Control, Info);  

Numerical factorisation is returned in Numeric.

1 uses default control settings; 2, 3 use control settings given in Control.

3 returns statistics about factorisation in Info.

2.2.3 factor()

Performs symbolic analysis (using COLAMD or AMD) and numerical factorisation. (Calls umfpack_*_symbolic() or umfpack_*_qsymbolic() and then umfpack_*_numeric().)

Syntax:

1  status = factor (A, Numeric);
2  status = factor (A, Numeric, Control);
3  status = factor (A, Numeric, Control, Info);  

Numerical factorisation is returned in Numeric.

1 uses default control settings; 2, 3 use control settings given in Control.

3 returns statistics about factorisation in Info.

2.2.4 solve()

Solves the linear system AX = B or related systems (see below) using Numeric computed previously by numeric() or factor(). (Calls umfpack_*_solve()).

Syntax:

1  status = solve (A, X, B, Numeric);
2  status = solve (A, X, B, Numeric, Control);
3  status = solve (A, X, B, Numeric, Control, Info);  
4  status = solve (sys, A, X, B, Numeric);
5  status = solve (sys, A, X, B, Numeric, Control);
6  status = solve (sys, A, X, B, Numeric, Control, Info);  

1, 2, 3 solve system AX = B; 4, 5, 6 solve system denoted by sys:

sysSystem
UMFPACK_AAX = B
UMFPACK_AtAHX = B
UMFPACK_AatATX = B
UMFPACK_Pt_LPTLX = B
UMFPACK_LLX = B
UMFPACK_Lt_PLHPX = B
UMFPACK_Lat_PLTPX = B
UMFPACK_LtLHX = B
UMFPACK_LatLTX = B
UMFPACK_U_QtUQTX = B
UMFPACK_UUX = B
UMFPACK_Q_UtQUHX = B
UMFPACK_Q_UatQUTX = B
UMFPACK_UtUHX = B
UMFPACK_UatUTX = B

1, 4 use default control settings; 2, 3, 5, 6 use control settings given in Control.

3, 6 return statistics about ordering in Info.

2.2.5 umf_solve()

Performs symbolic analysis and numerical factorisation and then solves the linear system AX = B. (Calls umfpack_*_symbolic()/umfpack_*_qsymbolic(), umfpack_*_numeric() and umfpack_*_solve().)

Syntax:

1  status = umf_solve (A, X, B);
2  status = umf_solve (A, X, B, Control);
3  status = umf_solve (A, X, B, Control, Info);  

1 uses default control settings; 2, 3 use control settings given in Control.

3 returns statistics about factorisation in Info.

2.2.6 free()

Clears the contents of symbolic_type<> or numeric_type<> objects. (Calls umfpack_*_free_symbolic() or umfpack_*_free_numeric().)

Syntax:

free (Symbolic);
Symbolic.free();
free (Numeric);
Numeric.free();

2.2.7 defaults()

Sets the default control parameters in the control_type<> object's array. (Calls umfpack_*_defaults().

Syntax:

defaults (Control);
Control.defaults();

2.2.8 scale()

Computes X = B, X = RB or X = R-1B, as appropriate. (Calls umfpack_*_scale().)

Syntax:

status = scale (X, B, Numeric);

2.2.9 report_status()

Prints the status (return value) of other UMFPACK bindings functions. (Calls umfpack_*_report_status().)

Syntax:

report_status (Control, status);

For control parameters used in various report_* functions see UMFPACK User Guide.

2.2.10 report_control()

Prints the current control settings. (Calls umfpack_*_report_control().)

Syntax:

report_control (Control);

2.2.11 report_info()

Prints the statistics returned in Info by symbolic(), numeric(), factor(), solve() and umf_solve(). (Calls umfpack_*_report_info().)

Syntax:

report_info (Control, Info);

2.2.12 report_matrix()

Verifies and prints a sparse matrix in compressed column or coordinate form (for matrix storage forms see sec. 2.3). (Calls umfpack_*_report_matrix() or umfpack_*_report_triplet().)

Syntax:

status = report_matrix (A, Control);

2.2.13 report_vector()

Verifies and prints a dense vector. (Calls umfpack_*_report_vector().)

Syntax:

status = report_vector (X, Control);

2.2.14 report_symbolic()

Verifies and prints a symbolic_type<> object. (Calls umfpack_*_report_symbolic().)

Syntax:

status = report_symbolic (Symbolic, Control);

2.2.15 report_numeric()

Verifies and prints a numeric_type<> object. (Calls umfpack_*_report_numeric().)

Syntax:

status = report_numeric (Numeric, Control);

2.2.16 report_permutation()

Verifies and prints a permutation vector. (Calls umfpack_*_report_perm().)

Syntax:

status = report_permutation (Qinit, Control);

3 Matrix Storage Schemes

UMFPACK functions manipulate matrices stored in compressed column format. Let A be m-by-n with nnz nonzero double entries. Its compressed column storage consists of three arrays: 

     int Ap[n+1];
     int Ai[nnz];
     double Ax[nnz];
Ax contains nonzero entries: elements of the matrix column k, sorted in ascending order of corresponding row indices and without duplicates, are in Ax[Ap[k]] to (and including) Ax[Ap[k+1]-1] and their row indices are in Ai[Ap[k]] to Ai[Ap[k+1]-1]. Thus, Ap is the array of column start locations in Ai and Ax; Ap[0] == 0 and Ap[n] == nnz. This is the storage scheme of ublas::compressed_matrix<double, ublas::column_major, 0>.

For example, the matrix 

     [2  3  0 0 0]
     [3  0  4 0 6]
     [0 -1 -3 2 0]
     [0  0  1 0 0]
     [0  4  2 0 1]
is represented by 
     int    Ap[] = { 0, 2, 5, 9, 10, 12 };
     int    Ai[] = {  0,  1,  0,   2,  4,  1,   2,  3,  4,  2,  1,  4 };
     double Ax[] = { 2., 3., 3., -1., 4., 4., -3., 1., 2., 2., 6., 1. };

For complex matrices, array Ax contains the real parts of complex numbers and there is an additional array for imaginary parts: 

     double Az[nnz];
Note that this is not the storage scheme of ublas::compressed_matrix<std::complex<double>, ublas::column_major, 0> which contains one array of complex values. But, UMFPACK bindings internally use function traits::detail::disentangle(), which converts array of complex numbers into two real arrays holding real and imaginary parts, and function traits::detail::interlace(), which performs opposite conversion, so you can still write: 
     ublas::compressed_matrix<std::complex<double>, ublas::column_major> C (5,5,12);
     std::vector<std::complex<double> > B (5), X (5); 
     // ...
     umf::umf_solve (C, X, B);
UMFPACK provide functions umfpack_*_triplet_to_col() which convert coordinate (AKA triplet) storage format of a sparse matrix to compressed column format. The coordinate format consists of three arrays: 
     int Ti[nnz];
     int Tj[nnz];
     double Tx[nnz];
Matrix entry aij is stored in kth triplet such that Ti[k] == i, Tj[k] == j and Tx[k] == aij. In general, triplets can be in any order (moreover, duplicate entries can exist). If column indices are stored in ascending order and if, within each column, row indices are sorted in ascending order (and if there is no duplicates), that is, for previous example 
     int    Ti[] = {  0,  1,  0,   2,  4,  1,   2,  3,  4,  2,  1,  4 };
     int    Tj[] = {  0,  0,  1,   1,  1,  2,   2,  2,  2,  3,  4,  4 };
     double Tx[] = { 2., 3., 3., -1., 4., 4., -3., 1., 2., 2., 6., 1. };
UMFPACK bindings can be used with matrices in coordinate format (internally, bindings functions use umfpack_*_triplet_to_col() to create just the pattern of the compressed column matrix (arrays Ap and Ai), and array Tx is used instead of Ax). Instead of ublas::compressed_matrix<> one can use 
     ublas::coordinate_matrix<double, ublas::column_major, 0> A (5,5,12);
in the example in section 2. (Conversion will be performed three times -- in symbolic(), numeric() and solve(). But if you use umf_solve(), conversion will be performed only once.)

4 Associated Types

Classes symbolic_type<> and numeric_type<> wrap void pointers which UMFPACK uses to pass around symbolic analysis and numerical factorisation information. Their destructors call umfpack_*_free_symbolic() and umfpack_*_free_numeric(), respectively; see also free().

Classes control_type<> and info_type<> wrap UMFPACK's control and info arrays. For arrays' entries (e.g. control parameters and error codes) see UMFPACK User Guide. Both classes provide operator[] for accessing individual entries; e.g.: 

     control_type<double> Control; 
     Control[UMFPACK_STRATEGY] = UMFPACK_STRATEGY_UNSYMMETRIC;
control_type<>'s constructor sets default parameters in the control array (i.e. calls umfpack_*_defaults()); see also defaults().

Template argument when constructing objects of these classes must be the type of matrix and vector elements: 

     compressed_matrix<std::complex<double>, column_major> C (5,5,12);
     control_type<std::complex<double> > Control;
     info_type<std::complex<double> > Info;
     symbolic_type<std::complex<double> > Symbolic; 
     numeric_type<std::complex<double> > Numeric;


5 UMFPACK Copyright, Licence and Availability

UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. Davis. All Rights Reserved.

UMFPACK License:

Your use or distribution of UMFPACK or any modified version of UMFPACK implies that you agree to this License.

THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK.

Permission is hereby granted to use or copy this program, provided that the Copyright, this License, and the Availability of the original version is retained on all copies. User documentation of any code that uses UMFPACK or any modified version of UMFPACK code must cite the Copyright, this License, the Availability note, and "Used by permission." Permission to modify the code and to distribute modified code is granted, provided the Copyright, this License, and the Availability note are retained, and a notice that the code was modified is included. This software was developed with support from the National Science Foundation, and is provided to you free of charge.

Availability:

http://www.cise.ufl.edu/research/sparse/umfpack

Used by permission.


boost-bindings/configure0000755000175000017500000000313510664337365015541 0ustar andreasandreas#! /usr/bin/env python def var_to_option(caps_name): return caps_name.lower().replace("_", "-") def var_kind(caps_name): last_underscore = caps_name.rfind("_") return caps_name[last_underscore+1:] if __name__ == "__main__": from optparse import OptionParser parser = OptionParser() parser.add_option("--prefix", default="/usr/local", help="Where to install the header files") options, args = parser.parse_args() substitutions = { "PREFIX": options.prefix } import re var_re = re.compile(r"\$\{([A-Za-z_0-9]+)\}") string_var_re = re.compile(r"\$str\{([A-Za-z_0-9]+)\}") for fname in ["Makefile"]: lines = open(fname+".in", "r").readlines() new_lines = [] for l in lines: made_change = True while made_change: made_change = False match = var_re.search(l) if match: varname = match.group(1) l = l[:match.start()] + str(substitutions[varname]) + l[match.end():] made_change = True match = string_var_re.search(l) if match: varname = match.group(1) subst = substitutions[varname] if subst is None: subst = "" else: subst = '"%s"' % subst l = l[:match.start()] + subst + l[match.end():] made_change = True new_lines.append(l) file(fname, "w").write("".join(new_lines)) boost-bindings/boost/0000755000175000017500000000000010776011453014745 5ustar andreasandreasboost-bindings/boost/numeric/0000755000175000017500000000000010776011453016407 5ustar andreasandreasboost-bindings/boost/numeric/bindings/0000755000175000017500000000000010776012707020207 5ustar andreasandreasboost-bindings/boost/numeric/bindings/amos/0000755000175000017500000000000010776011453021143 5ustar andreasandreasboost-bindings/boost/numeric/bindings/amos/amos.hpp0000644000175000017500000000721007707750440022621 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP #define BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace amos { template < typename vector_type, typename value_type > int besi(const value_type& z, // std::complex< float > or std::complex< double > const typename traits::type_traits< value_type >::real_type fnu, // float or double int kode, vector_type& cy, int& nz) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ; #endif int n = traits::vector_size( cy ) ; value_type * cy_ptr = traits::vector_storage( cy ) ; int error = 0 ; detail::besi( z, fnu, kode, n, cy_ptr, nz, error ) ; return error ; } template < typename vector_type, typename value_type > int besj(const value_type& z, const typename traits::type_traits< value_type >::real_type fnu, int kode, vector_type& cy, int& nz) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ; #endif int n = traits::vector_size( cy ) ; value_type * cy_ptr = traits::vector_storage( cy ) ; int error = 0 ; detail::besj( z, fnu, kode, n, cy_ptr, nz, error ) ; return error ; } template < typename vector_type, typename value_type > int besy(const value_type& z, const typename traits::type_traits< value_type >::real_type fnu, int kode, vector_type& cy, int& nz) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ; #endif int n = traits::vector_size( cy ) ; value_type * cy_ptr = traits::vector_storage( cy ) ; int error = 0 ; value_type * cwrk = new value_type[n]; detail::besy( z, fnu, kode, n, cy_ptr, nz, cwrk, error ) ; delete[] cwrk ; return error ; } }}}} #endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP boost-bindings/boost/numeric/bindings/amos/amos.h0000644000175000017500000000374507676532711022276 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // // Copyright Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_AMOS_AMOS_H #define BOOST_NUMERIC_BINDINGS_AMOS_AMOS_H #include #include extern "C" { void AMOS_DBESI(const double* z, const double* fnu, const int* kode, const int* n, double* cy, int* nz ) ; void AMOS_CBESI(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, int* ierr) ; void AMOS_ZBESI(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, int* ierr) ; void AMOS_DBESJ(const double * z, const double* fnu, const int* n, double* cy, int* nz ) ; void AMOS_CBESJ(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, int* ierr) ; void AMOS_ZBESJ(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, int* ierr) ; void AMOS_DBESY(const double * z, const double* fnu, const int* n, double* cy ) ; void AMOS_CBESY(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, fcomplex_t *cwrk, int* ierr) ; void AMOS_ZBESY(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, double *cwrkr, double *cwrki, int* ierr) ; } #endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP boost-bindings/boost/numeric/bindings/amos/amos_names.h0000644000175000017500000000154307676532711023453 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // // Copyright Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_AMOS_AMOS_NAMES_H #define BOOST_NUMERIC_BINDINGS_AMOS_AMOS_NAMES_H #include #define AMOS_DBESI FORTRAN_ID( dbesi ) #define AMOS_CBESI FORTRAN_ID( cbesi ) #define AMOS_ZBESI FORTRAN_ID( zbesi ) #define AMOS_DBESJ FORTRAN_ID( dbesj ) #define AMOS_CBESJ FORTRAN_ID( cbesj ) #define AMOS_ZBESJ FORTRAN_ID( zbesj ) #define AMOS_DBESY FORTRAN_ID( dbesy ) #define AMOS_CBESY FORTRAN_ID( cbesy ) #define AMOS_ZBESY FORTRAN_ID( zbesy ) #endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_NAMES_HPP boost-bindings/boost/numeric/bindings/amos/amos_overloads.hpp0000644000175000017500000000405607707750440024704 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_AMOS_AMOS_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_AMOS_AMOS_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace amos { namespace detail { using namespace ::boost::numeric::bindings::traits ; // // BESI // //inline //void besi(const fcomplex * z, const fcomplex * fnu, const int * kode, const int * n, fcomplex* cy, int * nz, int * error) ; inline void besi(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, int& error) { AMOS_DBESI( &z, &fnu, &kode, &n, cy, &nz ) ; } inline void besi(const complex_f& z, const float& fnu, const int& kode, const int& n, complex_f* cy, int & nz, int & error) { AMOS_CBESI( complex_ptr( &z ), &fnu, &kode, &n, complex_ptr( cy ), &nz, &error ) ; } // inline // void besi(const complex_d* z, const double* fnu, const int * kode, const int * n, complex_d* cy, int * nz, int * error) ; // // BESJ // inline void besj(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, int& error) { AMOS_DBESJ( &z, &fnu, &n, cy, &nz ) ; } inline void besj(const complex_f& z, const float& fnu, const int& kode, const int& n, complex_f* cy, int & nz, int & error) { AMOS_CBESJ( complex_ptr( &z ), &fnu, &kode, &n, complex_ptr( cy ), &nz, &error ) ; } // // BESY // inline void besy(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, double* wrk, int& error) { AMOS_DBESY( &z, &fnu, &n, cy ) ; } }}}}} #endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/atlas/0000755000175000017500000000000010776011453021310 5ustar andreasandreasboost-bindings/boost/numeric/bindings/atlas/cblas.hpp0000644000175000017500000000136107725607601023114 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_HPP #include #include #include #endif boost-bindings/boost/numeric/bindings/atlas/cblas1.hpp0000644000175000017500000003013507725607602023177 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_1_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_1_HPP #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_TYPE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { // x_i <- alpha for all i template inline void set (T const& alpha, Vct& x) { detail::set (traits::vector_size (x), alpha, traits::vector_storage (x), traits::vector_stride (x)); } // y <- x template inline void copy (VctX const& x, VctY& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::copy (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::vector_storage (y), traits::vector_stride (y)); } // x <-> y template inline void swap (VctX& x, VctY& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::swap (traits::vector_size (x), traits::vector_storage (x), traits::vector_stride (x), traits::vector_storage (y), traits::vector_stride (y)); } // x <- alpha * x template inline void scal (T const& alpha, Vct& x) { #ifndef BOOST_NUMERIC_BINDINGS_NO_TYPE_CHECK typedef traits::vector_traits vtraits; BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::real_type >::value )); #endif detail::scal (traits::vector_size (x), alpha, traits::vector_storage (x), traits::vector_stride (x)); } // y <- alpha * x + y template inline void axpy (T const& alpha, VctX const& x, VctY& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::axpy (traits::vector_size (x), alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::vector_storage (y), traits::vector_stride (y)); } // y <- x + y template inline void xpy (VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::vector_traits::value_type val_t; #else typedef typename VctX::value_type val_t; #endif axpy ((val_t) 1, x, y); } // y <- alpha * x + beta * y template inline void axpby (T const& alpha, VctX const& x, T const& beta, VctY& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::axpby (traits::vector_size (x), alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } /////////////////////////////////////////// // dot <- x^T * y // .. real & complex types template inline #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename VctX::value_type #endif dot (VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); return detail::dot (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y)); } // dot <- x^T * y // .. float only -- with double accumulation template inline double dsdot (VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); return cblas_dsdot (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y)); } // apdot <- alpha + x^T * y // .. float only -- computation uses double precision template inline float sdsdot (float const alpha, VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); return cblas_sdsdot (traits::vector_size (x), alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y)); } // dotu <- x^T * y // .. complex types only // .. function template inline #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename VctX::value_type #endif dotu (VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type val; #else typename VctX::value_type val; #endif detail::dotu (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), &val); return val; } // .. procedure template inline void dotu (VctX const& x, VctY const& y, #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type& val #else typename VctX::value_type& val #endif ) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::dotu (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), &val); } // dotc <- x^H * y // .. complex types only // .. function template inline #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename VctX::value_type #endif dotc (VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type val; #else typename VctX::value_type val; #endif detail::dotc (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), &val); return val; } // .. procedure template inline void dotc (VctX const& x, VctY const& y, #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type& val #else typename VctX::value_type& val #endif ) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::dotc (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), &val); } // nrm2 <- ||x||_2 template inline typename traits::type_traits< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename Vct::value_type #endif >::real_type nrm2 (Vct const& x) { return detail::nrm2 (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x)); } // asum <- ||re (x)|| + ||im (x)|| template inline typename traits::type_traits< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename Vct::value_type #endif >::real_type asum (Vct const& x) { return detail::asum (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x)); } // iamax <- 1st i: max (|re (x_i)| + |im (x_i)|) template inline CBLAS_INDEX iamax (Vct const& x) { return detail::iamax (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x)); } // TO DO: plane rotations } // namespace atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_1_HPP boost-bindings/boost/numeric/bindings/atlas/cblas1_overloads.hpp0000644000175000017500000002763307725607602025266 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS1_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS1_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace atlas { namespace detail { // dot <- x^T * y // .. real types: calls cblas_xdot // .. complex types: calls cblas_xdotu inline float dot (int const N, float const* X, int const incX, float const* Y, int const incY) { return cblas_sdot (N, X, incX, Y, incY); } inline double dot (int const N, double const* X, int const incX, double const* Y, int const incY) { return cblas_ddot (N, X, incX, Y, incY); } inline traits::complex_f dot (int const N, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY) { traits::complex_f val; cblas_cdotu_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (&val)); return val; } inline traits::complex_d dot (int const N, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY) { traits::complex_d val; cblas_zdotu_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (&val)); return val; } // dotu <- x^T * y // .. complex types only inline void dotu (int const N, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* val) { cblas_cdotu_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (val)); } inline void dotu (int const N, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* val) { cblas_zdotu_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (val)); } // dotc <- x^H * y // .. complex types only inline void dotc (int const N, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* val) { cblas_cdotc_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (val)); } inline void dotc (int const N, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* val) { cblas_zdotc_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (val)); } // nrm2 <- ||x||_2 inline float nrm2 (int const N, float const* X, int const incX) { return cblas_snrm2 (N, X, incX); } inline double nrm2 (int const N, double const* X, int const incX) { return cblas_dnrm2 (N, X, incX); } inline float nrm2 (int const N, traits::complex_f const* X, int const incX) { return cblas_scnrm2 (N, static_cast (X), incX); } inline double nrm2 (int const N, traits::complex_d const* X, int const incX) { return cblas_dznrm2 (N, static_cast (X), incX); } // asum <- ||re (x)|| + ||im (x)|| inline float asum (int const N, float const* X, int const incX) { return cblas_sasum (N, X, incX); } inline double asum (int const N, double const* X, int const incX) { return cblas_dasum (N, X, incX); } inline float asum (int const N, traits::complex_f const* X, int const incX) { return cblas_scasum (N, static_cast (X), incX); } inline double asum (int const N, traits::complex_d const* X, int const incX) { return cblas_dzasum (N, static_cast (X), incX); } // iamax <- 1st i: max (|re (x_i)| + |im (x_i)|) inline CBLAS_INDEX iamax (int const N, float const* X, int const incX) { return cblas_isamax (N, X, incX); } inline CBLAS_INDEX iamax (int const N, double const* X, int const incX) { return cblas_idamax (N, X, incX); } inline CBLAS_INDEX iamax (int const N, traits::complex_f const* X, int const incX) { return cblas_icamax (N, static_cast (X), incX); } inline CBLAS_INDEX iamax (int const N, traits::complex_d const* X, int const incX) { return cblas_izamax (N, static_cast (X), incX); } // x <-> y inline void swap (int const N, float* X, int const incX, float* Y, int const incY) { cblas_sswap (N, X, incX, Y, incY); } inline void swap (int const N, double* X, int const incX, double* Y, int const incY) { cblas_dswap (N, X, incX, Y, incY); } inline void swap (int const N, traits::complex_f* X, int const incX, traits::complex_f* Y, int const incY) { cblas_cswap (N, static_cast (X), incX, static_cast (Y), incY); } inline void swap (int const N, traits::complex_d* X, int const incX, traits::complex_d* Y, int const incY) { cblas_zswap (N, static_cast (X), incX, static_cast (Y), incY); } // y <- x inline void copy (int const N, float const* X, int const incX, float* Y, int const incY) { cblas_scopy (N, X, incX, Y, incY); } inline void copy (int const N, double const* X, int const incX, double* Y, int const incY) { cblas_dcopy (N, X, incX, Y, incY); } inline void copy (int const N, traits::complex_f const* X, int const incX, traits::complex_f* Y, int const incY) { cblas_ccopy (N, static_cast (X), incX, static_cast (Y), incY); } inline void copy (int const N, traits::complex_d const* X, int const incX, traits::complex_d* Y, int const incY) { cblas_zcopy (N, static_cast (X), incX, static_cast (Y), incY); } // y <- alpha * x + y inline void axpy (int const N, float const alpha, float const* X, int const incX, float* Y, int const incY) { cblas_saxpy (N, alpha, X, incX, Y, incY); } inline void axpy (int const N, double const alpha, double const* X, int const incX, double* Y, int const incY) { cblas_daxpy (N, alpha, X, incX, Y, incY); } inline void axpy (int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f* Y, int const incY) { cblas_caxpy (N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY); } inline void axpy (int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d* Y, int const incY) { cblas_zaxpy (N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY); } // y <- alpha * x + beta * y inline void axpby (int const N, float const alpha, float const* X, int const incX, float const beta, float* Y, int const incY) { catlas_saxpby (N, alpha, X, incX, beta, Y, incY); } inline void axpby (int const N, double const alpha, double const* X, int const incX, double const beta, double* Y, int const incY) { catlas_daxpby (N, alpha, X, incX, beta, Y, incY); } inline void axpby (int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const& beta, traits::complex_f* Y, int const incY) { catlas_caxpby (N, static_cast (&alpha), static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } inline void axpby (int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const& beta, traits::complex_d* Y, int const incY) { catlas_zaxpby (N, static_cast (&alpha), static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } // x_i <- alpha for all i inline void set (int const N, float const alpha, float* X, int const incX) { catlas_sset (N, alpha, X, incX); } inline void set (int const N, double const alpha, double* X, int const incX) { catlas_dset (N, alpha, X, incX); } inline void set (int const N, traits::complex_f const& alpha, traits::complex_f* X, int const incX) { catlas_cset (N, static_cast (&alpha), static_cast (X), incX); } inline void set (int const N, traits::complex_d const& alpha, traits::complex_d* X, int const incX) { catlas_zset (N, static_cast (&alpha), static_cast (X), incX); } // x <- alpha * x inline void scal (int const N, float const alpha, float* X, int const incX) { cblas_sscal (N, alpha, X, incX); } inline void scal (int const N, double const alpha, double* X, int const incX) { cblas_dscal (N, alpha, X, incX); } inline void scal (int const N, traits::complex_f const& alpha, traits::complex_f* X, int const incX) { cblas_cscal (N, static_cast (&alpha), static_cast (X), incX); } inline void scal (int const N, float const alpha, traits::complex_f* X, int const incX) { cblas_csscal (N, alpha, static_cast (X), incX); } inline void scal (int const N, traits::complex_d const& alpha, traits::complex_d* X, int const incX) { cblas_zscal (N, static_cast (&alpha), static_cast (X), incX); } inline void scal (int const N, double const alpha, traits::complex_d* X, int const incX) { cblas_zdscal (N, alpha, static_cast (X), incX); } }} // namepaces detail & atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS1_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/atlas/cblas2.hpp0000644000175000017500000012513307725607602023203 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002, 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_2_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_2_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { // y <- alpha * op (A) * x + beta * y // op (A) == A || A^T || A^H template inline void gemv (CBLAS_TRANSPOSE const TransA, T const& alpha, Matr const& a, VctX const& x, T const& beta, VctY& y ) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (x) >= (TransA == CblasNoTrans ? n : m)); assert (traits::vector_size (y) >= (TransA == CblasNoTrans ? m : n)); // .. what about AtlasConj? CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename Matr::orientation_category #endif >::value); detail::gemv (stor_ord, TransA, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- alpha * A * x + beta * y template inline void gemv (T const& alpha, Matr const& a, VctX const& x, T const& beta, VctY& y) { gemv (CblasNoTrans, alpha, a, x, beta, y); } // y <- A * x template inline void gemv (Matr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename Matr::value_type val_t; #endif gemv (CblasNoTrans, (val_t) 1, a, x, (val_t) 0, y); } // y <- alpha * A * x + beta * y // A real symmetric matrix (T == float | double) // [from 'dsymv.f':] /* [...] with UPLO = 'U' or 'u', the leading n by n upper * triangular part of the array A must contain the upper triangular * part of the symmetric matrix and the strictly lower triangular * part of A is not referenced. * [...] with UPLO = 'L' or 'l', the leading n by n lower * triangular part of the array A must contain the lower triangular * part of the symmetric matrix and the strictly upper * triangular part of A is not referenced. */ template inline void symv (CBLAS_UPLO const uplo, T const& alpha, SymmMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmMatr::orientation_category #endif >::value); detail::symv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } template inline void symv (T const& alpha, SymmMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmMatr::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmMatr::packed_category #endif >::value); detail::symv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- A * x template inline void symv (SymmMatr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmMatr::value_type val_t; #endif symv ((val_t) 1, a, x, (val_t) 0, y); } // y <- alpha * A * x + beta * y // A real symmetric matrix (T == float | double) in packed form // [from 'dspmv.f' (description assumes column major order):] /* A is an array of DIMENSION ( ( n*( n + 1 ) )/2 ). * Before entry with UPLO = 'U' or 'u', the array A must contain * the upper triangular part of the symmetric matrix packed * sequentially, column by column, so that A( 1 ) contains a(1,1), * A( 2 ) and A( 3 ) contain a(1,2) and a(2,2) respectively, and * so on. * Before entry with UPLO = 'L' or 'l', the array A must contain * the lower triangular part of the symmetric matrix packed * sequentially, column by column, so that A( 1 ) contains a(1,1), * A( 2 ) and A( 3 ) contain a(2,1) and a(3,1) respectively, and * so on. */ template inline void spmv (T const& alpha, SymmMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmMatr::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmMatr::packed_category #endif >::value); detail::spmv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), traits::vector_storage (x), #else traits::matrix_storage_const (a), traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- A * x template inline void spmv (SymmMatr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmMatr::value_type val_t; #endif spmv ((val_t) 1, a, x, (val_t) 0, y); } // y <- alpha * A * x + beta * y // A complex hermitian matrix // (T == std::complex | std::complex) template inline void hemv (CBLAS_UPLO const uplo, T const& alpha, HermMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermMatr::orientation_category #endif >::value); detail::hemv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } template inline void hemv (T const& alpha, HermMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermMatr::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermMatr::packed_category #endif >::value); detail::hemv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- A * x template inline void hemv (HermMatr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermMatr::value_type val_t; #endif hemv ((val_t) 1, a, x, (val_t) 0, y); } // y <- alpha * A * x + beta * y // A complex hermitian matrix in packed form // (T == std::complex | std::complex) template inline void hpmv (T const& alpha, HermMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermMatr::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermMatr::packed_category #endif >::value); detail::hpmv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), traits::vector_storage (x), #else traits::matrix_storage_const (a), traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- A * x template inline void hpmv (HermMatr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermMatr::value_type val_t; #endif hpmv ((val_t) 1, a, x, (val_t) 0, y); } // A <- alpha * x * y^T + A // .. real & complex types template inline void ger (T const& alpha, VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (x) >= m); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename Matr::orientation_category #endif >::value); detail::ger (stor_ord, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^T + A template inline void ger (VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename Matr::value_type val_t; #endif ger ((val_t) 1, x, y, a); } // A <- alpha * x * y^T + A // .. complex types only template inline void geru (T const& alpha, VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (x) >= m); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename Matr::orientation_category #endif >::value); detail::geru (stor_ord, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^T + A template inline void geru (VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename Matr::value_type val_t; #endif geru ((val_t) 1, x, y, a); } // A <- alpha * x * y^H + A // .. complex types only template inline void gerc (T const& alpha, VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (x) >= m); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename Matr::orientation_category #endif >::value); detail::gerc (stor_ord, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^H + A template inline void gerc (VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename Matr::value_type val_t; #endif gerc ((val_t) 1, x, y, a); } // A <- alpha * x * x^T + A // A real symmetric (see leading comments for 'symv()') template inline void syr (CBLAS_UPLO const uplo, T const& alpha, VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); detail::syr (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a), traits::leading_dimension (a)); } template inline void syr (T const& alpha, VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmM::packed_category #endif >::value); detail::syr (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * x^T + A template inline void syr (VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmM::value_type val_t; #endif syr ((val_t) 1, x, a); } // A <- alpha * x * x^T + A // A real symmetric in packed form (see leading comments for 'spmv()') template inline void spr (T const& alpha, VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmM::packed_category #endif >::value); detail::spr (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a)); } // A <- x * x^T + A template inline void spr (VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmM::value_type val_t; #endif spr ((val_t) 1, x, a); } // A <- alpha * x * y^T + alpha * y * x^T + A // A real symmetric (see leading comments for 'symv()') template inline void syr2 (CBLAS_UPLO const uplo, T const& alpha, VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); detail::syr2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } template inline void syr2 (T const& alpha, VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmM::packed_category #endif >::value); detail::syr2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^T + y * x^T + A template inline void syr2 (VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmM::value_type val_t; #endif syr2 ((val_t) 1, x, y, a); } // A <- alpha * x * y^T + alpha * y * x^T + A // A real symmetric in packed form (see leading comments for 'spmv()') template inline void spr2 (T const& alpha, VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmM::packed_category #endif >::value); detail::spr2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a)); } // A <- x * y^T + y * x^T + A template inline void spr2 (VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmM::value_type val_t; #endif spr2 ((val_t) 1, x, y, a); } // A <- alpha * x * x^H + A // A hermitian template inline void her (CBLAS_UPLO const uplo, T const& alpha, VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); detail::her (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a), traits::leading_dimension (a)); } template inline void her (T const& alpha, VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermM::packed_category #endif >::value); detail::her (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * x^H + A template inline void her (VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermM::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; her ((real_t) 1, x, a); } // A <- alpha * x * x^H + A // A hermitian in packed form template inline void hpr (T const& alpha, VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermM::packed_category #endif >::value); detail::hpr (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a)); } // A <- x * x^H + A template inline void hpr (VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermM::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; hpr ((real_t) 1, x, a); } // A <- alpha * x * y^H + y * (alpha * x)^H + A // A hermitian template inline void her2 (CBLAS_UPLO const uplo, T const& alpha, VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); detail::her2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } template inline void her2 (T const& alpha, VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermM::packed_category #endif >::value); detail::her2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^H + y * x^H + A template inline void her2 (VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermM::value_type val_t; #endif her2 ((val_t) 1, x, y, a); } // A <- alpha * x * y^H + y * (alpha * x)^H + A // A hermitian in packed form template inline void hpr2 (T const& alpha, VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermM::packed_category #endif >::value); detail::hpr2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a)); } // A <- x * y^H + y * x^H + A template inline void hpr2 (VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermM::value_type val_t; #endif hpr2 ((val_t) 1, x, y, a); } } // namespace atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_2_HPP boost-bindings/boost/numeric/bindings/atlas/cblas2_overloads.hpp0000644000175000017500000004421307725607602025260 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002, 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS2_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS2_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace atlas { namespace detail { // y <- alpha * op (A) * x + beta * y inline void gemv (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, int const M, int const N, float const alpha, float const* A, int const lda, float const* X, int const incX, float const beta, float* Y, int const incY) { cblas_sgemv (Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY); } inline void gemv (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, int const M, int const N, double const alpha, double const* A, int const lda, double const* X, int const incX, double const beta, double* Y, int const incY) { cblas_dgemv (Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY); } inline void gemv (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* X, int const incX, traits::complex_f const& beta, traits::complex_f* Y, int const incY) { cblas_cgemv (Order, TransA, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } inline void gemv (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* X, int const incX, traits::complex_d const& beta, traits::complex_d* Y, int const incY) { cblas_zgemv (Order, TransA, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } // y <- alpha * A * x + beta * y // A real symmetric inline void symv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* A, int const lda, float const* X, int const incX, float const beta, float* Y, int const incY) { cblas_ssymv (Order, Uplo, N, alpha, A, lda, X, incX, beta, Y, incY); } inline void symv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* A, int const lda, double const* X, int const incX, double const beta, double* Y, int const incY) { cblas_dsymv (Order, Uplo, N, alpha, A, lda, X, incX, beta, Y, incY); } // y <- alpha * A * x + beta * y // A real symmetric in packed form inline void spmv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* Ap, float const* X, int const incX, float const beta, float* Y, int const incY) { cblas_sspmv (Order, Uplo, N, alpha, Ap, X, incX, beta, Y, incY); } inline void spmv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* Ap, double const* X, int const incX, double const beta, double* Y, int const incY) { cblas_dspmv (Order, Uplo, N, alpha, Ap, X, incX, beta, Y, incY); } // y <- alpha * A * x + beta * y // A complex hermitian inline void hemv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* X, int const incX, traits::complex_f const& beta, traits::complex_f* Y, int const incY) { cblas_chemv (Order, Uplo, N, static_cast (&alpha), static_cast (A), lda, static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } inline void hemv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* X, int const incX, traits::complex_d const& beta, traits::complex_d* Y, int const incY) { cblas_zhemv (Order, Uplo, N, static_cast (&alpha), static_cast (A), lda, static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } // y <- alpha * A * x + beta * y // A complex hermitian in packed form inline void hpmv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f const& alpha, traits::complex_f const* Ap, traits::complex_f const* X, int const incX, traits::complex_f const& beta, traits::complex_f* Y, int const incY) { cblas_chpmv (Order, Uplo, N, static_cast (&alpha), static_cast (Ap), static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } inline void hpmv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d const& alpha, traits::complex_d const* Ap, traits::complex_d const* X, int const incX, traits::complex_d const& beta, traits::complex_d* Y, int const incY) { cblas_zhpmv (Order, Uplo, N, static_cast (&alpha), static_cast (Ap), static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } // A <- alpha * x * y^T + A // .. real types: calls cblas_xger // .. complex types: calls cblas_xgeru inline void ger (CBLAS_ORDER const Order, int const M, int const N, float const alpha, float const* X, int const incX, float const* Y, int const incY, float* A, int const lda) { cblas_sger (Order, M, N, alpha, X, incX, Y, incY, A, lda); } inline void ger (CBLAS_ORDER const Order, int const M, int const N, double const alpha, double const* X, int const incX, double const* Y, int const incY, double* A, int const lda) { cblas_dger (Order, M, N, alpha, X, incX, Y, incY, A, lda); } inline void ger (CBLAS_ORDER const Order, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* A, int const lda) { cblas_cgeru (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } inline void ger (CBLAS_ORDER const Order, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* A, int const lda) { cblas_zgeru (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } // A <- alpha * x * y^T + A // .. complex types only inline void geru (CBLAS_ORDER const Order, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* A, int const lda) { cblas_cgeru (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } inline void geru (CBLAS_ORDER const Order, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* A, int const lda) { cblas_zgeru (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } // A <- alpha * x * y^H + A // .. complex types only inline void gerc (CBLAS_ORDER const Order, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* A, int const lda) { cblas_cgerc (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } inline void gerc (CBLAS_ORDER const Order, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* A, int const lda) { cblas_zgerc (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } // A <- alpha * x * x^T + A // A real symmetric inline void syr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* X, int const incX, float* A, int const lda) { cblas_ssyr (Order, Uplo, N, alpha, X, incX, A, lda); } inline void syr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* X, int const incX, double* A, int const lda) { cblas_dsyr (Order, Uplo, N, alpha, X, incX, A, lda); } // A <- alpha * x * x^T + A // A real symmetric in packed form inline void spr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* X, int const incX, float* Ap) { cblas_sspr (Order, Uplo, N, alpha, X, incX, Ap); } inline void spr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* X, int const incX, double* Ap) { cblas_dspr (Order, Uplo, N, alpha, X, incX, Ap); } // A <- alpha * x * y^T + alpha * y * x^T + A // A real symmetric inline void syr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* X, int const incX, float const* Y, int const incY, float* A, int const lda) { cblas_ssyr2 (Order, Uplo, N, alpha, X, incX, Y, incY, A, lda); } inline void syr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* X, int const incX, double const* Y, int const incY, double* A, int const lda) { cblas_dsyr2 (Order, Uplo, N, alpha, X, incX, Y, incY, A, lda); } // A <- alpha * x * y^T + alpha * y * x^T + A // A real symmetric in packed form inline void spr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* X, int const incX, float const* Y, int const incY, float* Ap) { cblas_sspr2 (Order, Uplo, N, alpha, X, incX, Y, incY, Ap); } inline void spr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* X, int const incX, double const* Y, int const incY, double* Ap) { cblas_dspr2 (Order, Uplo, N, alpha, X, incX, Y, incY, Ap); } // A <- alpha * x * x^H + A // A hermitian inline void her (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, traits::complex_f const* X, int const incX, traits::complex_f* A, int const lda) { cblas_cher (Order, Uplo, N, alpha, static_cast (X), incX, static_cast (A), lda); } inline void her (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, traits::complex_d const* X, int const incX, traits::complex_d* A, int const lda) { cblas_zher (Order, Uplo, N, alpha, static_cast (X), incX, static_cast (A), lda); } // A <- alpha * x * x^H + A // A hermitian in packed form inline void hpr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, traits::complex_f const* X, int const incX, traits::complex_f* Ap) { cblas_chpr (Order, Uplo, N, alpha, static_cast (X), incX, static_cast (Ap)); } inline void hpr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, traits::complex_d const* X, int const incX, traits::complex_d* Ap) { cblas_zhpr (Order, Uplo, N, alpha, static_cast (X), incX, static_cast (Ap)); } // A <- alpha * x * y^H + y * (alpha * x)^H + A // A hermitian inline void her2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* A, int const lda) { cblas_cher2 (Order, Uplo, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } inline void her2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* A, int const lda) { cblas_zher2 (Order, Uplo, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } // A <- alpha * x * y^H + y * (alpha * x)^H + A // A hermitian in packed form inline void hpr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* Ap) { cblas_chpr2 (Order, Uplo, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (Ap)); } inline void hpr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* Ap) { cblas_zhpr2 (Order, Uplo, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (Ap)); } }} // namepaces detail & atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS2_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/atlas/cblas3.hpp0000644000175000017500000011735707725607602023215 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_3_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_3_HPP #include #include #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { // C <- alpha * op (A) * op (B) + beta * C // op (A) == A || A^T || A^H template inline void gemm (CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, T const& alpha, MatrA const& a, MatrB const& b, T const& beta, MatrC& c ) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (TransA == CblasNoTrans || TransA == CblasTrans || TransA == CblasConjTrans); assert (TransB == CblasNoTrans || TransB == CblasTrans || TransB == CblasConjTrans); int const m = TransA == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a); int const n = TransB == CblasNoTrans ? traits::matrix_size2 (b) : traits::matrix_size1 (b); int const k = TransA == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (m == traits::matrix_size1 (c)); assert (n == traits::matrix_size2 (c)); #ifndef NDEBUG int const k1 = TransB == CblasNoTrans ? traits::matrix_size1 (b) : traits::matrix_size2 (b); assert (k == k1); #endif // .. what about AtlasConj? CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); detail::gemm (stor_ord, TransA, TransB, m, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } // C <- alpha * A * B + beta * C template inline void gemm (T const& alpha, MatrA const& a, MatrB const& b, T const& beta, MatrC& c) { gemm (CblasNoTrans, CblasNoTrans, alpha, a, b, beta, c) ; } // C <- A * B template inline void gemm (MatrA const& a, MatrB const& b, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrC::value_type val_t; #endif gemm (CblasNoTrans, CblasNoTrans, (val_t) 1, a, b, (val_t) 0, c); } // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^T namespace detail { template inline void symm (CBLAS_SIDE const side, CBLAS_UPLO const uplo, T const& alpha, SymmA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (side == CblasLeft || side == CblasRight); assert (uplo == CblasUpper || uplo == CblasLower); int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (side == CblasLeft ? m == traits::matrix_size1 (a) && m == traits::matrix_size2 (a) : n == traits::matrix_size1 (a) && n == traits::matrix_size2 (a)); assert (m == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); symm (stor_ord, side, uplo, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^T template inline void symm (CBLAS_SIDE const side, CBLAS_UPLO const uplo, T const& alpha, SymmA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::symm (side, uplo, alpha, a, b, beta, c); } template inline void symm (CBLAS_SIDE const side, T const& alpha, SymmA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); detail::symm (side, uplo, alpha, a, b, beta, c); } #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS namespace detail { // C <- alpha * A * B + beta * C ; A == A^T struct symm_left { template static void f (T const& alpha, SymmA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (m == traits::matrix_size1 (a) && m == traits::matrix_size2 (a)); assert (m == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< typename traits::matrix_traits::ordering_type >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< typename traits::matrix_traits::uplo_type >::value); symm (stor_ord, CblasLeft, uplo, m, n, alpha, traits::matrix_storage (a), traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } }; // C <- alpha * A * B + beta * C ; B == B^T struct symm_right { template static void f (T const& alpha, MatrA const& a, SymmB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (n == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); assert (m == traits::matrix_size1 (a) && n == traits::matrix_size2 (a)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< typename traits::matrix_traits::ordering_type >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< typename traits::matrix_traits::uplo_type >::value); symm (stor_ord, CblasRight, uplo, m, n, alpha, traits::matrix_storage (b), traits::leading_dimension (b), traits::matrix_storage (a), traits::leading_dimension (a), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } }; } // detail // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^T template inline void symm (T const& alpha, MatrA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif typedef typename boost::mpl::if_c< boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value, detail::symm_left, detail::symm_right >::type functor; functor::f (alpha, a, b, beta, c); } // C <- A * B // C <- B * A template inline void symm (MatrA const& a, MatrB const& b, MatrC& c) { typedef typename traits::matrix_traits::value_type val_t; symm ((val_t) 1, a, b, (val_t) 0, c); } #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^H namespace detail { template inline void hemm (CBLAS_SIDE const side, CBLAS_UPLO const uplo, T const& alpha, HermA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (side == CblasLeft || side == CblasRight); assert (uplo == CblasUpper || uplo == CblasLower); int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (side == CblasLeft ? m == traits::matrix_size1 (a) && m == traits::matrix_size2 (a) : n == traits::matrix_size1 (a) && n == traits::matrix_size2 (a)); assert (m == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermA::orientation_category #endif >::value); hemm (stor_ord, side, uplo, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^H template inline void hemm (CBLAS_SIDE const side, CBLAS_UPLO const uplo, T const& alpha, HermA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::hemm (side, uplo, alpha, a, b, beta, c); } template inline void hemm (CBLAS_SIDE const side, T const& alpha, HermA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermA::packed_category #endif >::value); detail::hemm (side, uplo, alpha, a, b, beta, c); } #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS namespace detail { // C <- alpha * A * B + beta * C ; A == A^H struct hemm_left { template static void f (T const& alpha, HermA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (m == traits::matrix_size1 (a) && m == traits::matrix_size2 (a)); assert (m == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< typename traits::matrix_traits::ordering_type >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< typename traits::matrix_traits::uplo_type >::value); hemm (stor_ord, CblasLeft, uplo, m, n, alpha, traits::matrix_storage (a), traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } }; // C <- alpha * A * B + beta * C ; B == B^H struct hemm_right { template static void f (T const& alpha, MatrA const& a, HermB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (n == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); assert (m == traits::matrix_size1 (a) && n == traits::matrix_size2 (a)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< typename traits::matrix_traits::ordering_type >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< typename traits::matrix_traits::uplo_type >::value); hemm (stor_ord, CblasRight, uplo, m, n, alpha, traits::matrix_storage (b), traits::leading_dimension (b), traits::matrix_storage (a), traits::leading_dimension (a), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } }; } template inline void hemm (T const& alpha, MatrA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif typedef typename boost::mpl::if_c< boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value, detail::hemm_left, detail::hemm_right >::type functor; functor::f (alpha, a, b, beta, c); } // C <- A * B // C <- B * A template inline void hemm (MatrA const& a, MatrB const& b, MatrC& c) { typedef typename traits::matrix_traits::value_type val_t; hemm ((val_t) 1, a, b, (val_t) 0, c); } #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS // C <- alpha * A * A^T + beta * C // C <- alpha * A^T * A + beta * C // C == C^T namespace detail { template inline void syrk (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); assert (trans == CblasNoTrans || trans == CblasTrans || trans == CblasConjTrans); int const n = traits::matrix_size1 (c); assert (n == traits::matrix_size2 (c)); int const k = trans == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a))); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmC::orientation_category #endif >::value); syrk (stor_ord, uplo, trans, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * A^T + beta * C // C <- alpha * A^T * A + beta * C // C == C^T template inline void syrk (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::syrk (uplo, trans, alpha, a, beta, c); } template inline void syrk (CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmC::packed_category #endif >::value); detail::syrk (uplo, trans, alpha, a, beta, c); } // C <- A * A^T + C // C <- A^T * A + C template inline void syrk (CBLAS_TRANSPOSE trans, MatrA const& a, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmC::value_type val_t; #endif syrk (trans, (val_t) 1, a, (val_t) 0, c); } // C <- alpha * A * B^T + conj(alpha) * B * A^T + beta * C // C <- alpha * A^T * B + conj(alpha) * B^T * A + beta * C // C == C^T namespace detail { template inline void syr2k (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, MatrB const& b, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); assert (trans == CblasNoTrans || trans == CblasTrans || trans == CblasConjTrans); int const n = traits::matrix_size1 (c); assert (n == traits::matrix_size2 (c)); int const k = trans == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (k == (trans == CblasNoTrans ? traits::matrix_size2 (b) : traits::matrix_size1 (b))); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a))); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmC::orientation_category #endif >::value); syr2k (stor_ord, uplo, trans, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * B^T + conj(alpha) * B * A^T + beta * C // C <- alpha * A^T * B + conj(alpha) * B^T * A + beta * C // C == C^T template inline void syr2k (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, MatrB const& b, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::syr2k (uplo, trans, alpha, a, b, beta, c); } template inline void syr2k (CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, MatrB const& b, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmC::packed_category #endif >::value); detail::syr2k (uplo, trans, alpha, a, b, beta, c); } // C <- A * B^T + B * A^T + C // C <- A^T * B + B^T * A + C template inline void syr2k (CBLAS_TRANSPOSE trans, MatrA const& a, MatrB const& b, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmC::value_type val_t; #endif syr2k (trans, (val_t) 1, a, b, (val_t) 0, c); } // C <- alpha * A * A^H + beta * C // C <- alpha * A^H * A + beta * C // C == C^H namespace detail { template inline void herk (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); assert (trans == CblasNoTrans || trans == CblasConjTrans); int const n = traits::matrix_size1 (c); assert (n == traits::matrix_size2 (c)); int const k = trans == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a))); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermC::orientation_category #endif >::value); herk (stor_ord, uplo, trans, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * A^H + beta * C // C <- alpha * A^H * A + beta * C // C == C^H template inline void herk (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::herk (uplo, trans, alpha, a, beta, c); } template inline void herk (CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermC::packed_category #endif >::value); detail::herk (uplo, trans, alpha, a, beta, c); } // C <- A * A^H + C // C <- A^H * A + C template inline void herk (CBLAS_TRANSPOSE trans, MatrA const& a, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermC::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; herk (trans, (real_t) 1, a, (real_t) 0, c); } // C <- alpha * A * B^H + conj(alpha) * B * A^H + beta * C // C <- alpha * A^H * B + conj(alpha) * B^H * A + beta * C // C == C^H namespace detail { template inline void her2k (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T1 const& alpha, MatrA const& a, MatrB const& b, T2 const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); assert (trans == CblasNoTrans || trans == CblasConjTrans); int const n = traits::matrix_size1 (c); assert (n == traits::matrix_size2 (c)); int const k = trans == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (k == (trans == CblasNoTrans ? traits::matrix_size2 (b) : traits::matrix_size1 (b))); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a))); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermC::orientation_category #endif >::value); her2k (stor_ord, uplo, trans, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * B^H + conj(alpha) * B * A^H + beta * C // C <- alpha * A^H * B + conj(alpha) * B^H * A + beta * C // C == C^H template inline void her2k (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T1 const& alpha, MatrA const& a, MatrB const& b, T2 const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::her2k (uplo, trans, alpha, a, b, beta, c); } template inline void her2k (CBLAS_TRANSPOSE trans, T1 const& alpha, MatrA const& a, MatrB const& b, T2 const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermC::packed_category #endif >::value); detail::her2k (uplo, trans, alpha, a, b, beta, c); } // C <- A * B^H + B * A^H + C // C <- A^H * B + B^H * A + C template inline void her2k (CBLAS_TRANSPOSE trans, MatrA const& a, MatrB const& b, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermC::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; her2k (trans, (val_t) 1, a, b, (real_t) 0, c); } } // namespace atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_3_HPP boost-bindings/boost/numeric/bindings/atlas/cblas3_overloads.hpp0000644000175000017500000003461107725607602025262 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS3_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS3_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace atlas { namespace detail { // C <- alpha * op (A) * op (B) + beta * C inline void gemm (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, int const M, int const N, int const K, float const alpha, float const* A, int const lda, float const* B, int const ldb, float const beta, float* C, int const ldc) { cblas_sgemm (Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc); } inline void gemm (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, int const M, int const N, int const K, double const alpha, double const* A, int const lda, double const* B, int const ldb, double const beta, double* C, int const ldc) { cblas_dgemm (Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc); } inline void gemm (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, int const M, int const N, int const K, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_cgemm (Order, TransA, TransB, M, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } inline void gemm (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, int const M, int const N, int const K, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zgemm (Order, TransA, TransB, M, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^T inline void symm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, float const alpha, float const* A, int const lda, float const* B, int const ldb, float const beta, float* C, int const ldc) { cblas_ssymm (Order, Side, Uplo, M, N, alpha, A, lda, B, ldb, beta, C, ldc); } inline void symm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, double const alpha, double const* A, int const lda, double const* B, int const ldb, double const beta, double* C, int const ldc) { cblas_dsymm (Order, Side, Uplo, M, N, alpha, A, lda, B, ldb, beta, C, ldc); } inline void symm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_csymm (Order, Side, Uplo, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } inline void symm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zsymm (Order, Side, Uplo, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^H inline void hemm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_chemm (Order, Side, Uplo, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } inline void hemm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zhemm (Order, Side, Uplo, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * A^T + beta * C // C <- alpha * A^T * A + beta * C // C == C^T inline void syrk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, float const alpha, float const* A, int const lda, float const beta, float* C, int const ldc) { cblas_ssyrk (Order, Uplo, Trans, N, K, alpha, A, lda, beta, C, ldc); } inline void syrk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, double const alpha, double const* A, int const lda, double const beta, double* C, int const ldc) { cblas_dsyrk (Order, Uplo, Trans, N, K, alpha, A, lda, beta, C, ldc); } inline void syrk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_csyrk (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (&beta), static_cast (C), ldc); } inline void syrk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zsyrk (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * B^T + conj(alpha) * B * A^T + beta * C // C <- alpha * A^T * B + conj(alpha) * B^T * A + beta * C // C == C^T inline void syr2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, float const alpha, float const* A, int const lda, float const* B, int const ldb, float const beta, float* C, int const ldc) { cblas_ssyr2k (Order, Uplo, Trans, N, K, alpha, A, lda, B, ldb, beta, C, ldc); } inline void syr2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, double const alpha, double const* A, int const lda, double const* B, int const ldb, double const beta, double* C, int const ldc) { cblas_dsyr2k (Order, Uplo, Trans, N, K, alpha, A, lda, B, ldb, beta, C, ldc); } inline void syr2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_csyr2k (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } inline void syr2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zsyr2k (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * A^H + beta * C // C <- alpha * A^H * A + beta * C // C == C^H inline void herk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, float alpha, traits::complex_f const* A, int const lda, float beta, traits::complex_f* C, int const ldc) { cblas_cherk (Order, Uplo, Trans, N, K, alpha, static_cast (A), lda, beta, static_cast (C), ldc); } inline void herk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, double alpha, traits::complex_d const* A, int const lda, double beta, traits::complex_d* C, int const ldc) { cblas_zherk (Order, Uplo, Trans, N, K, alpha, static_cast (A), lda, beta, static_cast (C), ldc); } // C <- alpha * A * B^H + conj(alpha) * B * A^H + beta * C // C <- alpha * A^H * B + conj(alpha) * B^H * A + beta * C // C == C^H inline void her2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, float beta, traits::complex_f* C, int const ldc) { cblas_cher2k (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, beta, static_cast (C), ldc); } inline void her2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, double beta, traits::complex_d* C, int const ldc) { cblas_zher2k (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, beta, static_cast (C), ldc); } }} // namepaces detail & atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS3_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/atlas/cblas_enum.hpp0000644000175000017500000000444707725607602024151 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_ENUM_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_ENUM_HPP #include #include #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { template struct storage_order {}; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS template<> struct storage_order { // 'ename' - como (in enum_cast<>): // a template argument may not reference an unnamed type enum ename { value = CblasRowMajor }; }; template<> struct storage_order { enum ename { value = CblasColMajor }; }; #else template<> struct storage_order { enum ename { value = CblasRowMajor }; }; template<> struct storage_order { enum ename { value = CblasColMajor }; }; #endif template struct uplo_triang {}; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS template<> struct uplo_triang { enum ename { value = CblasUpper }; }; template<> struct uplo_triang { enum ename { value = CblasLower }; }; #else template<> struct uplo_triang { enum ename { value = CblasUpper }; }; template<> struct uplo_triang { enum ename { value = CblasLower }; }; #endif // g++ 3.0.4 rejects 'static_cast (e2)' template E1 enum_cast (E2 e2) { return static_cast (static_cast (e2)); } } }}} #endif boost-bindings/boost/numeric/bindings/atlas/cblas_inc.hpp0000644000175000017500000000203607725607602023746 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ ////////////////////////////////////////////////////////////////////////// // // ATLAS (Automatically Tuned Linear Algebra Software) // // ''At present, it provides C and Fortran77 interfaces to a portably // efficient BLAS implementation, as well as a few routines from LAPACK.'' // // see: http://math-atlas.sourceforge.net/ // ////////////////////////////////////////////////////////////////////////// #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_INC_H #define BOOST_NUMERIC_BINDINGS_CBLAS_INC_H extern "C" { # include } #endif boost-bindings/boost/numeric/bindings/atlas/clapack.hpp0000644000175000017500000006420307725607602023433 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CLAPACK_HPP #define BOOST_NUMERIC_BINDINGS_CLAPACK_HPP #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS # include #endif #include // see libs/numeric/bindings/atlas/doc/index.html, section 2.5.2 //#define BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { ///////////////////////////////////////////////////////////////////// // // general system of linear equations A * X = B // ///////////////////////////////////////////////////////////////////// // gesv(): 'driver' function // // [comments from 'clapack_dgesv.c':] /* clapack_xgesv computes the solution to a system of linear equations * A * X = B, * where A is an N-by-N matrix and X and B are N-by-NRHS matrices. */ // [but ATLAS FAQ says:] /* What's the deal with the RHS in the row-major factorization/solves? * Most users are confused by the row major factorization and related * solves. The right-hand side vectors are probably the biggest source * of confusion. The RHS array does not represent a matrix in the * mathematical sense, it is instead a pasting together of the various * RHS into one array for calling convenience. As such, RHS vectors are * always stored contiguously, regardless of the row/col major that is * chosen. This means that ldb/ldx is always independent of NRHS, and * dependant on N, regardless of the row/col major setting. */ // That is, it seems that, if B is row-major, it should be NRHS-by-N, // and RHS vectors should be its rows, not columns. // // [comments from 'clapack_dgesv.c':] /* The LU factorization used to factor A is dependent on the Order * parameter, as detailed in the leading comments of clapack_dgetrf. * The factored form of A is then used to solve the system of equations * A * X = B. * A is overwritten with the appropriate LU factorization, and B [...] * is overwritten with the solution X on output. */ // If B is row-major, solution vectors are its rows. template inline int gesv (MatrA& a, IVec& ipiv, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); assert (n == traits::vector_size (ipiv)); return detail::gesv (stor_ord, n, nrhs, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (ipiv), traits::matrix_storage (b), traits::leading_dimension (b)); } template inline int gesv (MatrA& a, MatrB& b) { // with 'internal' pivot vector #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); int *ipiv = new (std::nothrow) int[n]; int ierr = -101; // clapack_dgesv() errors: // if (ierr == 0), successful // if (ierr < 0), the -ierr argument had an illegal value // -- we will use -101 if allocation fails // if (ierr > 0), U(i-1,i-1) (or L(i-1,i-1)) is exactly zero if (ipiv) { ierr = detail::gesv (stor_ord, n, nrhs, traits::matrix_storage (a), traits::leading_dimension (a), ipiv, traits::matrix_storage (b), traits::leading_dimension (b)); delete[] ipiv; } return ierr; } template inline int lu_solve (MatrA& a, MatrB& b) { return gesv (a, b); } // getrf(): LU factorization of A // [comments from 'clapack_dgetrf.c':] /* Computes one of two LU factorizations based on the setting of * the Order parameter, as follows: * --------------------------------------------------------------- * Order == CblasColMajor * Column-major factorization of form * A = P * L * U * where P is a row-permutation matrix, L is lower triangular with * unit diagonal elements (lower trapezoidal if M > N), and U is * upper triangular (upper trapezoidal if M < N). * --------------------------------------------------------------- * Order == CblasRowMajor * Row-major factorization of form * A = P * L * U * where P is a column-permutation matrix, L is lower triangular * (lower trapezoidal if M > N), and U is upper triangular with * unit diagonals (upper trapezoidal if M < N). */ template inline int getrf (MatrA& a, IVec& ipiv) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (ipiv) == (m < n ? m : n)); return detail::getrf (stor_ord, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (ipiv)); } template inline int lu_factor (MatrA& a, IVec& ipiv) { return getrf (a, ipiv); } // getrs(): solves a system of linear equations // A * X = B or A' * X = B // using the LU factorization previously computed by getrf() template inline int getrs (CBLAS_TRANSPOSE const Trans, MatrA const& a, IVec const& ipiv, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (Trans == CblasNoTrans || Trans == CblasTrans || Trans == CblasConjTrans); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); assert (n == traits::vector_size (ipiv)); return detail::getrs (stor_ord, Trans, n, nrhs, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (ipiv), #else traits::vector_storage_const (ipiv), #endif traits::matrix_storage (b), traits::leading_dimension (b)); } // getrs(): solves A * X = B (after getrf()) template inline int getrs (MatrA const& a, IVec const& ipiv, MatrB& b) { return getrs (CblasNoTrans, a, ipiv, b); } template inline int lu_substitute (MatrA const& a, IVec const& ipiv, MatrB& b) { return getrs (CblasNoTrans, a, ipiv, b); } // getri(): computes the inverse of a matrix A // using the LU factorization previously computed by getrf() template inline int getri (MatrA& a, IVec const& ipiv) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (ipiv) == n); return detail::getri (stor_ord, n, traits::matrix_storage (a), traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (ipiv) #else traits::vector_storage_const (ipiv) #endif ); } template inline int lu_invert (MatrA& a, IVec& ipiv) { return getri (a, ipiv); } ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A symmetric or Hermitian positive definite matrix // ///////////////////////////////////////////////////////////////////// #ifndef BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // posv(): 'driver' function // // [from 'dposv.f' (slightly edited):] /* XPOSV computes the solution to a system of linear equations * A * X = B, * where A is an N-by-N symmetric/Hermitian positive definite matrix * and X and B are N-by-NRHS matrices. [See also comments of gesv().] * * A -- On entry, the symmetric/Hermitian matrix A. * If UPLO = 'U', the leading N-by-N upper triangular part of A * contains the upper triangular part of the matrix A, and the * strictly lower triangular part of A is not referenced. * If UPLO = 'L', the leading N-by-N lower triangular part of A * contains the lower triangular part of the matrix A, and the * strictly upper triangular part of A is not referenced. * * On exit, if INFO = 0, the factor U or L from the Cholesky * factorization A = U**T*U or A = L*L**T * [or A = U**H*U or A = L*L**H]. * * B -- On entry, the right hand side matrix B. * On exit, if INFO = 0, the solution matrix X. */ namespace detail { template inline int posv (CBLAS_UPLO const uplo, SymmA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); return posv (stor_ord, uplo, n, nrhs, traits::matrix_storage (a), traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b)); } } // detail template inline int posv (CBLAS_UPLO const uplo, SymmA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); return detail::posv (uplo, a, b); } template inline int posv (SymmA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef typename traits::matrix_traits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); return detail::posv (uplo, a, b); } template inline int cholesky_solve (SymmA& a, MatrB& b) { return posv (a, b); } #endif // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // potrf(): Cholesky factorization of A namespace detail { template inline int potrf (CBLAS_UPLO const uplo, SymmA& a) { CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); return potrf (stor_ord, uplo, n, traits::matrix_storage (a), traits::leading_dimension (a)); } } // detail template inline int potrf (CBLAS_UPLO const uplo, SymmA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); return detail::potrf (uplo, a); } template inline int potrf (SymmA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef typename traits::matrix_traits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); return detail::potrf (uplo, a); } template inline int cholesky_factor (SymmA& a) { return potrf (a); } // potrs(): solves a system of linear equations A * X = B // using the Cholesky factorization computed by potrf() namespace detail { template inline int potrs (CBLAS_UPLO const uplo, SymmA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); #ifndef BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG return potrs (stor_ord, uplo, n, nrhs, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b)); #else // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG int ierr; if (stor_ord == CblasColMajor) ierr = potrs (stor_ord, uplo, n, nrhs, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b)); else // ATLAS bug with CblasRowMajor ierr = potrs_bug (stor_ord, uplo, n, nrhs, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b)); return ierr; #endif // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG } } // detail template inline int potrs (CBLAS_UPLO const uplo, SymmA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); return detail::potrs (uplo, a, b); } template inline int potrs (SymmA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef typename traits::matrix_traits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); return detail::potrs (uplo, a, b); } template inline int cholesky_substitute (SymmA const& a, MatrB& b) { return potrs (a, b); } #ifdef BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // posv(): 'driver' function template inline int posv (CBLAS_UPLO const uplo, SymmA& a, MatrB& b) { int ierr = potrf (uplo, a); if (ierr == 0) ierr = potrs (uplo, a, b); return ierr; } template inline int posv (SymmA& a, MatrB& b) { int ierr = potrf (a); if (ierr == 0) ierr = potrs (a, b); return ierr; } template inline int cholesky_solve (SymmA& a, MatrB& b) { return posv (a, b); } #endif // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // potri(): computes the inverse of a symmetric or Hermitian positive // definite matrix A using the Cholesky factorization // previously computed by potrf() namespace detail { template inline int potri (CBLAS_UPLO const uplo, SymmA& a) { CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); return potri (stor_ord, uplo, n, traits::matrix_storage (a), traits::leading_dimension (a)); } } // detail template inline int potri (CBLAS_UPLO const uplo, SymmA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); return detail::potri (uplo, a); } template inline int potri (SymmA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef typename traits::matrix_traits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); return detail::potri (uplo, a); } template inline int cholesky_invert (SymmA& a) { return potri (a); } } // namespace atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CLAPACK_HPP boost-bindings/boost/numeric/bindings/atlas/clapack_inc.hpp0000644000175000017500000000221607725607602024260 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ ////////////////////////////////////////////////////////////////////////// // // ATLAS (Automatically Tuned Linear Algebra Software) // // ''At present, it provides C and Fortran77 interfaces to a portably // efficient BLAS implementation, as well as a few routines from LAPACK.'' // // see: http://math-atlas.sourceforge.net/ // ////////////////////////////////////////////////////////////////////////// #ifndef BOOST_NUMERIC_BINDINGS_CLAPACK_INC_H #define BOOST_NUMERIC_BINDINGS_CLAPACK_INC_H extern "C" { /* see footnote [2] in libs/numeric/bindings/lapack/doc/index.html */ /* #include */ #include } #endif boost-bindings/boost/numeric/bindings/atlas/clapack_overloads.hpp0000644000175000017500000003067407725607602025516 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CLAPACK_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_CLAPACK_OVERLOADS_HPP #include #include namespace boost { namespace numeric { namespace bindings { namespace atlas { namespace detail { // // general system of linear equations A * X = B // // 'driver' function -- factor and solve inline int gesv (CBLAS_ORDER const Order, int const N, int const NRHS, float* A, int const lda, int* ipiv, float* B, int const ldb) { return clapack_sgesv (Order, N, NRHS, A, lda, ipiv, B, ldb); } inline int gesv (CBLAS_ORDER const Order, int const N, int const NRHS, double* A, int const lda, int* ipiv, double* B, int const ldb) { return clapack_dgesv (Order, N, NRHS, A, lda, ipiv, B, ldb); } inline int gesv (CBLAS_ORDER const Order, int const N, int const NRHS, traits::complex_f* A, int const lda, int* ipiv, traits::complex_f* B, int const ldb) { return clapack_cgesv (Order, N, NRHS, static_cast (A), lda, ipiv, static_cast (B), ldb); } inline int gesv (CBLAS_ORDER const Order, int const N, int const NRHS, traits::complex_d* A, int const lda, int* ipiv, traits::complex_d* B, int const ldb) { return clapack_zgesv (Order, N, NRHS, static_cast (A), lda, ipiv, static_cast (B), ldb); } // LU factorization inline int getrf (CBLAS_ORDER const Order, int const M, int const N, float* A, int const lda, int* ipiv) { return clapack_sgetrf (Order, M, N, A, lda, ipiv); } inline int getrf (CBLAS_ORDER const Order, int const M, int const N, double* A, int const lda, int* ipiv) { return clapack_dgetrf (Order, M, N, A, lda, ipiv); } inline int getrf (CBLAS_ORDER const Order, int const M, int const N, traits::complex_f* A, int const lda, int* ipiv) { return clapack_cgetrf (Order, M, N, static_cast (A), lda, ipiv); } inline int getrf (CBLAS_ORDER const Order, int const M, int const N, traits::complex_d* A, int const lda, int* ipiv) { return clapack_zgetrf (Order, M, N, static_cast (A), lda, ipiv); } // solve (using factorization computed by getrf()) inline int getrs (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const Trans, int const N, int const NRHS, float const* A, int const lda, int const* ipiv, float* B, int const ldb) { return clapack_sgetrs (Order, Trans, N, NRHS, A, lda, ipiv, B, ldb); } inline int getrs (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const Trans, int const N, int const NRHS, double const* A, int const lda, int const* ipiv, double* B, int const ldb) { return clapack_dgetrs (Order, Trans, N, NRHS, A, lda, ipiv, B, ldb); } inline int getrs (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const Trans, int const N, int const NRHS, traits::complex_f const* A, int const lda, int const* ipiv, traits::complex_f* B, int const ldb) { return clapack_cgetrs (Order, Trans, N, NRHS, static_cast (A), lda, ipiv, static_cast (B), ldb); } inline int getrs (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const Trans, int const N, int const NRHS, traits::complex_d const* A, int const lda, int const* ipiv, traits::complex_d* B, int const ldb) { return clapack_zgetrs (Order, Trans, N, NRHS, static_cast (A), lda, ipiv, static_cast (B), ldb); } // invert (using factorization computed by getrf()) inline int getri (CBLAS_ORDER const Order, int const N, float* A, int const lda, int const* ipiv) { return clapack_sgetri (Order, N, A, lda, ipiv); } inline int getri (CBLAS_ORDER const Order, int const N, double* A, int const lda, int const* ipiv) { return clapack_dgetri (Order, N, A, lda, ipiv); } inline int getri (CBLAS_ORDER const Order, int const N, traits::complex_f* A, int const lda, int const* ipiv) { return clapack_cgetri (Order, N, static_cast (A), lda, ipiv); } inline int getri (CBLAS_ORDER const Order, int const N, traits::complex_d* A, int const lda, int const* ipiv) { return clapack_zgetri (Order, N, static_cast (A), lda, ipiv); } // // system of linear equations A * X = B // with A symmetric positive definite matrix // // 'driver' function -- factor and solve inline int posv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, float* A, int const lda, float* B, int const ldb) { return clapack_sposv (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int posv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, double* A, int const lda, double* B, int const ldb) { return clapack_dposv (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int posv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_f* A, int const lda, traits::complex_f* B, int const ldb) { return clapack_cposv (Order, Uplo, N, NRHS, static_cast (A), lda, static_cast (B), ldb); } inline int posv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_d* A, int const lda, traits::complex_d* B, int const ldb) { return clapack_zposv (Order, Uplo, N, NRHS, static_cast (A), lda, static_cast (B), ldb); } // Cholesky factorization inline int potrf (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float* A, int const lda) { return clapack_spotrf (Order, Uplo, N, A, lda); } inline int potrf (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double* A, int const lda) { return clapack_dpotrf (Order, Uplo, N, A, lda); } inline int potrf (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f* A, int const lda) { return clapack_cpotrf (Order, Uplo, N, static_cast (A), lda); } inline int potrf (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d* A, int const lda) { return clapack_zpotrf (Order, Uplo, N, static_cast (A), lda); } // solve (using factorization computed by potrf()) inline int potrs (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, float const* A, int const lda, float* B, int const ldb) { return clapack_spotrs (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int potrs (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, double const* A, int const lda, double* B, int const ldb) { return clapack_dpotrs (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int potrs (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_f const* A, int const lda, traits::complex_f* B, int const ldb) { return clapack_cpotrs (Order, Uplo, N, NRHS, static_cast (A), lda, static_cast (B), ldb); } inline int potrs (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_d const* A, int const lda, traits::complex_d* B, int const ldb) { return clapack_zpotrs (Order, Uplo, N, NRHS, static_cast (A), lda, static_cast (B), ldb); } #ifdef BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // .. ATLAS bug with row major hermitian matrices // .... symmetric matrices are OK, but to simplify generic potrs() ... inline int potrs_bug (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, float const* A, int const lda, float* B, int const ldb) { return clapack_spotrs (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int potrs_bug (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, double const* A, int const lda, double* B, int const ldb) { return clapack_dpotrs (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int potrs_bug (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_f const* A, int const lda, traits::complex_f* B, int const ldb) { int sz = N * lda; traits::complex_f* A1 = new traits::complex_f[sz]; for (int i = 0; i < sz; ++i) A1[i] = std::conj (A[i]); int r = clapack_cpotrs (Order, Uplo, N, NRHS, static_cast (A1), lda, static_cast (B), ldb); delete[] A1; return r; } inline int potrs_bug (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_d const* A, int const lda, traits::complex_d* B, int const ldb) { int sz = N * lda; traits::complex_d* A1 = new traits::complex_d[sz]; for (int i = 0; i < sz; ++i) A1[i] = std::conj (A[i]); int r = clapack_zpotrs (Order, Uplo, N, NRHS, static_cast (A1), lda, static_cast (B), ldb); delete[] A1; return r; } #endif // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // invert (using factorization computed by potrf()) inline int potri (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float* A, int const lda) { return clapack_spotri (Order, Uplo, N, A, lda); } inline int potri (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double* A, int const lda) { return clapack_dpotri (Order, Uplo, N, A, lda); } inline int potri (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f* A, int const lda) { return clapack_cpotri (Order, Uplo, N, static_cast (A), lda); } inline int potri (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d* A, int const lda) { return clapack_zpotri (Order, Uplo, N, static_cast (A), lda); } }} // namepaces detail & atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CLAPACK_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/blas/0000755000175000017500000000000010776011453021125 5ustar andreasandreasboost-bindings/boost/numeric/bindings/blas/blas.hpp0000644000175000017500000000043407675623321022567 0ustar andreasandreas#ifndef boost_blasbindings_blasbindings_hpp #define boost_blasbindings_blasbindings_hpp #include #include #include #endif // boost_blasbindings_blasbindings_hpp boost-bindings/boost/numeric/bindings/blas/blas.h0000644000175000017500000002051210201624745022214 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright (C) 2002, 2003 Si-Lab b.v.b.a and Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS_H #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS_H /* * const-correct prototypes for BLAS functions * */ #include #include extern "C" { // // Level 1 // void BLAS_SSCAL(const int *n, const float* alpha, float* x, const int* incx); void BLAS_DSCAL(const int *n, const double* alpha, double* x, const int* incx); void BLAS_CSCAL(const int *n, const fcomplex_t* alpha, fcomplex_t* x, const int* incx); void BLAS_ZSCAL(const int *n, const dcomplex_t* alpha, dcomplex_t* x, const int* incx); void BLAS_SAXPY(const int *n, const float* alpha, const float* x, const int* incx, float* y, const int* incy); void BLAS_DAXPY(const int *n, const double* alpha, const double* x, const int* incx, double* y, const int* incy); void BLAS_CAXPY(const int *n, const fcomplex_t* alpha, const fcomplex_t* x, const int* incx, fcomplex_t* y, const int* incy); void BLAS_ZAXPY(const int *n, const dcomplex_t* alpha, const dcomplex_t* x, const int* incx, dcomplex_t* y, const int* incy); float BLAS_SDOT (const int *n, const float *x, const int *incx, const float *y, const int *incy); double BLAS_DDOT (const int *n, const double *x, const int *incx, const double *y, const int *incy); void BLAS_CDOTU(fcomplex_t* ret, const int *n, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy); void BLAS_ZDOTU(dcomplex_t* ret, const int *n, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy); void BLAS_CDOTC(fcomplex_t* ret, const int *n, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy); void BLAS_ZDOTC(dcomplex_t* ret, const int *n, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy); float BLAS_SNRM2(const int *n, const float *x, const int *incx); double BLAS_DNRM2(const int *n, const double *x, const int *incx); float BLAS_SCNRM2(const int *n, const fcomplex_t *x, const int *incx); double BLAS_DZNRM2(const int *n, const dcomplex_t *x, const int *incx); float BLAS_SASUM(const int *n, const float *x, const int *incx); double BLAS_DASUM(const int *n, const double *x, const int *incx); float BLAS_SCASUM(const int *n, const fcomplex_t *x, const int *incx); double BLAS_DZASUM(const int *n, const dcomplex_t *x, const int *incx); void BLAS_SCOPY( const int *n, const float *x, const int *incx, float *y, const int *incy); void BLAS_DCOPY( const int *n, const double *x, const int *incx, double *y, const int *incy); void BLAS_CCOPY( const int *n, const fcomplex_t *x, const int *incx, fcomplex_t *y, const int *incy); void BLAS_ZCOPY( const int *n, const dcomplex_t *x, const int *incx, dcomplex_t *y, const int *incy); // // Level 2 // void BLAS_SGEMV(const char *trans, const int *m, const int *n, const float *alpha, const float *a, const int *lda, const float *x, const int *incx, const float *beta, float *y, const int *incy) ; void BLAS_DGEMV(const char *trans, const int *m, const int *n, const double *alpha, const double *a, const int *lda, const double *x, const int *incx, const double *beta, double *y, const int *incy) ; void BLAS_CGEMV(const char *trans, const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *a, const int *lda, const fcomplex_t *x, const int *incx, const fcomplex_t *beta, fcomplex_t *y, const int *incy) ; void BLAS_ZGEMV(const char *trans, const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *a, const int *lda, const dcomplex_t *x, const int *incx, const dcomplex_t *beta, dcomplex_t *y, const int *incy) ; void BLAS_SGER (const int *m, const int *n, const float * alpha, const float * x, const int *incx, const float * y, const int *incy, float *a, const int *lda); void BLAS_DGER (const int *m, const int *n, const double *alpha, const double *x, const int *incx, const double *y, const int *incy, double *a, const int *lda); void BLAS_CGERU(const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy, fcomplex_t *a, const int *lda); void BLAS_ZGERU(const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy, dcomplex_t *a, const int *lda); void BLAS_CGERC(const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy, fcomplex_t *a, const int *lda); void BLAS_ZGERC(const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy, dcomplex_t *a, const int *lda); // // Level 3 // void BLAS_SGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const float *alpha, const float *a, const int *lda, const float *b, const int *ldb, const float *beta, float *c, const int *ldc); void BLAS_DGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const double *alpha, const double *a, const int *lda, const double *b, const int *ldb, const double *beta, double *c, const int *ldc); void BLAS_CGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const fcomplex_t *alpha, const fcomplex_t *a, const int *lda, const fcomplex_t *b, const int *ldb, const fcomplex_t *beta, fcomplex_t *c, const int *ldc); void BLAS_ZGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const dcomplex_t *alpha, const dcomplex_t *a, const int *lda, const dcomplex_t *b, const int *ldb, const dcomplex_t *beta, dcomplex_t *c, const int *ldc); void BLAS_SSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const float* alpha, const float* a, const int* lda, const float* beta, float* c, const int* ldc ); void BLAS_DSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const double* alpha, const double* a, const int* lda, const double* beta, double* c, const int* ldc ); void BLAS_CSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const fcomplex_t* alpha, const fcomplex_t* a, const int* lda, const fcomplex_t* beta, fcomplex_t* c, const int* ldc ); void BLAS_ZSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const dcomplex_t* alpha, const dcomplex_t* a, const int* lda, const dcomplex_t* beta, dcomplex_t* c, const int* ldc ); void BLAS_CHERK ( const char* uplo, const char* trans, const int* n, const int* k, const float* alpha, const fcomplex_t* a, const int* lda, const float* beta, fcomplex_t* c, const int* ldc ); void BLAS_ZHERK ( const char* uplo, const char* trans, const int* n, const int* k, const double* alpha, const dcomplex_t* a, const int* lda, const double* beta, dcomplex_t* c, const int* ldc ); void BLAS_STRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m, const int* n, float const* alpha, float const* a, int const* lda, float* b, int const* ldb ); void BLAS_DTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m, const int* n, double const* alpha, double const* a, int const* lda, double* b, int const* ldb ); void BLAS_CTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m, const int* n, fcomplex_t const* alpha, fcomplex_t const* a, int const* lda, fcomplex_t* b, int const* ldb ); void BLAS_ZTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m, const int* n, dcomplex_t const* alpha, dcomplex_t const* a, int const* lda, dcomplex_t* b, int const* ldb ); } #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS_H boost-bindings/boost/numeric/bindings/blas/blas1.hpp0000644000175000017500000002072110776012506022642 0ustar andreasandreas // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen and Kresimir Fresl #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_HPP #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_HPP #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { // x <- y template < typename vector_x_type, typename vector_y_type > void copy(const vector_x_type &x, vector_y_type &y ) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< typename traits::vector_traits::value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< typename vector_x_type::value_type, typename vector_y_type::value_type >::value ) ) ; #endif const int n = traits::vector_size( x ) ; assert( n==traits::vector_size( y ) ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; typename traits::vector_traits::value_type const *x_ptr = traits::vector_storage( x ) ; typename traits::vector_traits::value_type *y_ptr = traits::vector_storage( y ) ; detail::copy( n, x_ptr, stride_x, y_ptr, stride_y ) ; } // x <- alpha * x template < typename value_type, typename vector_type > void scal(const value_type &alpha, vector_type &x ) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ; #endif const int n = traits::vector_size( x ) ; const int stride = traits::vector_stride( x ) ; value_type *x_ptr = traits::vector_storage( x ) ; detail::scal( n, alpha, x_ptr, stride ) ; } // y <- alpha * x + y template < typename value_type, typename vector_type_x, typename vector_type_y > void axpy(const value_type& alpha, const vector_type_x &x, vector_type_y &y ) { #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( is_same< value_type, typename vector_type_x::value_type >::value ) ) ; BOOST_STATIC_ASSERT( ( is_same< value_type, typename vector_type_y::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( is_same< value_type, typename traits::vector_traits< vector_type_x >::value_type >::value ) ) ; BOOST_STATIC_ASSERT( ( is_same< value_type, typename traits::vector_traits< vector_type_y >::value_type >::value ) ) ; #endif assert( traits::vector_size( x ) == traits::vector_size( y ) ) ; const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; value_type *y_ptr = traits::vector_storage( y ) ; detail::axpy( n, alpha, x_ptr, stride_x, y_ptr, stride_y ) ; } // dot <- x^T * y (real vectors) template < typename vector_type_x, typename vector_type_y > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits< vector_type_x >::value_type #else typename vector_type_x::value_type #endif dot(const vector_type_x &x, const vector_type_y &y) { #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( is_same< typename vector_type_y::value_type, typename vector_type_x::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( is_same< typename traits::vector_traits< vector_type_y >::value_type, typename traits::vector_traits< vector_type_x >::value_type >::value ) ) ; #endif assert( traits::vector_size( x ) == traits::vector_size( y ) ) ; typedef #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits< vector_type_x >::value_type #else typename vector_type_x::value_type #endif value_type ; const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; return detail::dot( n, x_ptr, stride_x, y_ptr, stride_y ) ; } // dotu <- x^T * y (complex vectors) template < typename vector_type_x, typename vector_type_y > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits< vector_type_x >::value_type #else typename vector_type_x::value_type #endif dotu(const vector_type_x &x, const vector_type_y &y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( is_same< typename traits::vector_traits< vector_type_y >::value_type, typename traits::vector_traits< vector_type_x >::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( is_same< typename vector_type_y::value_type, typename vector_type_x::value_type >::value ) ) ; #endif assert( traits::vector_size( x ) == traits::vector_size( y ) ) ; typedef typename vector_type_x::value_type value_type ; const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; value_type ret ; detail::dotu( ret, n, x_ptr, stride_x, y_ptr, stride_y ) ; return ret; } // dotc <- x^H * y (complex vectors) template < typename vector_type_x, typename vector_type_y > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits< vector_type_x >::value_type #else typename vector_type_x::value_type #endif dotc(const vector_type_x &x, const vector_type_y &y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( is_same< typename traits::vector_traits< vector_type_y >::value_type, typename traits::vector_traits< vector_type_x >::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( is_same< typename vector_type_y::value_type, typename vector_type_x::value_type >::value ) ) ; #endif assert( traits::vector_size( x ) == traits::vector_size( y ) ) ; typedef typename vector_type_x::value_type value_type ; const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; value_type ret ; detail::dotc( ret, n, x_ptr, stride_x, y_ptr, stride_y ) ; return ret; } // nrm2 <- ||x||_2 template < typename vector_type > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::type_traits< typename traits::vector_traits< vector_type >::value_type >::real_type #else typename traits::type_traits< typename vector_type::value_type >::real_type #endif nrm2(const vector_type &x) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::vector_traits< vector_type >::value_type value_type; #else typedef vector_type::value_type value_type ; #endif const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const value_type *x_ptr = traits::vector_storage( x ) ; return detail::nrm2( n, x_ptr, stride_x ) ; } // asum <- ||x||_1 // .. for now works only with real vectors template < typename vector_type > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::type_traits< typename traits::vector_traits< vector_type >::value_type >::real_type #else typename traits::type_traits< typename vector_type::value_type >::real_type #endif asum(const vector_type &x) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::vector_traits< vector_type >::value_type value_type; #else typedef vector_type::value_type value_type ; #endif const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const value_type *x_ptr = traits::vector_storage( x ) ; return detail::asum( n, x_ptr, stride_x ) ; } }}}} #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_HPP boost-bindings/boost/numeric/bindings/blas/blas1_overloads.hpp0000644000175000017500000001210210373447660024720 0ustar andreasandreas// Copyright (C) Toon Knapen 2003 // // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { namespace detail { using namespace boost::numeric::bindings::traits ; // x *= alpha inline void scal(const int& n, const float& alpha, float* x, const int& incx) { BLAS_SSCAL( &n, &alpha, x , &incx ) ; } inline void scal(const int& n, const double& alpha, double* x, const int& incx) { BLAS_DSCAL( &n, &alpha, x , &incx ) ; } inline void scal(const int& n, const complex_f& alpha, complex_f* x, const int& incx) { BLAS_CSCAL( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx ) ; } inline void scal(const int& n, const complex_d& alpha, complex_d* x, const int& incx) { BLAS_ZSCAL( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx ) ; } // y += alpha * x inline void axpy(const int& n, const float & alpha, const float * x, const int& incx, float * y, const int& incy) { BLAS_SAXPY( &n, &alpha , x , &incx, y , &incy ) ; } inline void axpy(const int& n, const double & alpha, const double * x, const int& incx, double * y, const int& incy) { BLAS_DAXPY( &n, &alpha , x , &incx, y , &incy ) ; } inline void axpy(const int& n, const complex_f& alpha, const complex_f* x, const int& incx, complex_f* y, const int& incy) { BLAS_CAXPY( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } inline void axpy(const int& n, const complex_d& alpha, const complex_d* x, const int& incx, complex_d* y, const int& incy) { BLAS_ZAXPY( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } // x^T . y inline float dot(const int& n, const float * x, const int& incx, const float * y, const int& incy) { return BLAS_SDOT( &n, x, &incx, y, &incy ) ; } inline double dot(const int& n, const double* x, const int& incx, const double* y, const int& incy) { return BLAS_DDOT( &n, x, &incx, y, &incy ) ; } // x^T . y inline void dotu(complex_f& ret, const int& n, const complex_f* x, const int& incx, const complex_f* y, const int& incy) { BLAS_CDOTU( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } inline void dotu(complex_d& ret, const int& n, const complex_d* x, const int& incx, const complex_d* y, const int& incy) { BLAS_ZDOTU( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } // x^H . y inline void dotc(complex_f& ret, const int& n, const complex_f* x, const int& incx, const complex_f* y, const int& incy) { BLAS_CDOTC( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } inline void dotc(complex_d& ret, const int& n, const complex_d* x, const int& incx, const complex_d* y, const int& incy) { BLAS_ZDOTC( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } // euclidean norm inline float nrm2(const int& n, const float* x, const int& incx) { return BLAS_SNRM2( &n, x, &incx ) ; } inline double nrm2(const int& n, const double* x, const int& incx) { return BLAS_DNRM2( &n, x, &incx ) ; } inline float nrm2(const int& n, const complex_f* x, const int& incx) { return BLAS_SCNRM2( &n, complex_ptr(x), &incx ) ; } inline double nrm2(const int& n, const complex_d* x, const int& incx) { return BLAS_DZNRM2( &n, complex_ptr(x), &incx ) ; } // 1-norm inline float asum(const int& n, const float* x, const int& incx) { return BLAS_SASUM( &n, x, &incx ) ; } inline double asum(const int& n, const double* x, const int& incx) { return BLAS_DASUM( &n, x, &incx ) ; } inline float asum(const int& n, const complex_f* x, const int& incx) { return BLAS_SCASUM( &n, complex_ptr(x), &incx ) ; } inline double asum(const int& n, const complex_d* x, const int& incx) { return BLAS_DZASUM( &n, complex_ptr(x), &incx ) ; } // copy inline void copy(const int& n, const float* x, const int& incx, float* y, const int& incy) { BLAS_SCOPY( &n, x, &incx, y, &incy ) ; } inline void copy(const int& n, const double* x, const int& incx, double* y, const int& incy) { BLAS_DCOPY( &n, x, &incx, y, &incy ) ; } inline void copy(const int& n, const complex_f* x, const int& incx, complex_f* y, const int& incy) { BLAS_CCOPY( &n, complex_ptr(x), &incx, complex_ptr(y), &incy ) ; } inline void copy(const int& n, const complex_d* x, const int& incx, complex_d* y, const int& incy) { BLAS_ZCOPY( &n, complex_ptr(x), &incx, complex_ptr(y), &incy ) ; } }}}}} #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/blas/blas2.hpp0000644000175000017500000001331307707750440022650 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen and Kresimir Fresl 2003 #ifndef BOOST_BINDINGS_BLAS_BLAS2_HPP #define BOOST_BINDINGS_BLAS_BLAS2_HPP #include #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { // y <- alpha * op (A) * x + beta * y // op (A) == A || A^T || A^H // ! CAUTION this function assumes that all matrices involved are column-major matrices template < typename matrix_type, typename vector_type_x, typename vector_type_y, typename value_type > inline void gemv(const char TRANS, const value_type& alpha, const matrix_type &a, const vector_type_x &x, const value_type& beta, vector_type_y &y ) { // precondition: matrix_type must be dense or dense_proxy /* not all compilers can handle the traits BOOST_STATIC_ASSERT( ( boost::is_same< typename mtraits::matrix_structure, boost::numeric::bindings::traits::general_t >::value ) ) ; */ const int m = traits::matrix_size1( a ) ; const int n = traits::matrix_size2( a ) ; assert ( traits::vector_size( x ) >= (TRANS == traits::NO_TRANSPOSE ? n : m) ) ; assert ( traits::vector_size( y ) >= (TRANS == traits::NO_TRANSPOSE ? m : n) ) ; const int lda = traits::leading_dimension( a ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *a_ptr = traits::matrix_storage( a ) ; const value_type *x_ptr = traits::vector_storage( x ) ; value_type *y_ptr = traits::vector_storage( y ) ; detail::gemv( TRANS, m, n, alpha, a_ptr, lda, x_ptr, stride_x, beta, y_ptr, stride_y ); } // A <- alpha * x * trans(y) ( outer product ), alpha, x and y are real-valued // ! CAUTION this function assumes that all matrices involved are column-major matrices template < typename vector_type_x, typename vector_type_y, typename value_type, typename matrix_type > inline void ger( const value_type& alpha, const vector_type_x &x, const vector_type_y &y, matrix_type &a ) { // precondition: matrix_type must be dense or dense_proxy /* not all compilers can handle the traits BOOST_STATIC_ASSERT( ( boost::is_same< typename mtraits::matrix_structure, boost::numeric::bindings::traits::general_t >::value ) ) ; */ const int m = traits::matrix_size1( a ) ; const int n = traits::matrix_size2( a ) ; assert ( traits::vector_size( x ) <= m ) ; assert ( traits::vector_size( y ) <= n ) ; const int lda = traits::leading_dimension( a ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; value_type *a_ptr = traits::matrix_storage( a ) ; detail::ger( m, n, alpha, x_ptr, stride_x, y_ptr, stride_y, a_ptr, lda ); } /* // A <- alpha * x * trans(y) ( outer product ), alpha, x and y are complex-valued template < typename vector_type_x, typename vector_type_y, typename value_type, typename matrix_type > inline void geru( const value_type& alpha, const vector_type_x &x, const vector_type_y &y, matrix_type &a ) { // precondition: matrix_type must be dense or dense_proxy // not all compilers can handle the traits // BOOST_STATIC_ASSERT( ( boost::is_same< typename mtraits::matrix_structure, // boost::numeric::bindings::traits::general_t // >::value ) ) ; // BOOST_STATIC_ASSERT( ( boost::is_same< x.value_type(), FEMTown::Complex() >::value ) ) ; const int m = traits::matrix_size1( a ) ; const int n = traits::matrix_size2( a ) ; assert ( traits::vector_size( x ) <= m ) ; assert ( traits::vector_size( y ) <= n ) ; const int lda = traits::leading_dimension( a ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; value_type *a_ptr = traits::matrix_storage( a ) ; detail::geru( m, n, alpha, x_ptr, stride_x, y_ptr, stride_y, a_ptr, lda ); } */ /* // y <- alpha * A * x + beta * y template < typename matrix_type, typename vector_type_x, typename vector_type_y > inline void gemv(const typename traits::matrix_traits::value_type &alpha, const matrix_type &a, const vector_type_x &x, const typename traits::vector_traits::value_type &beta, vector_type_y &y ) { gemv( traits::NO_TRANSPOSE, alpha, a, x, beta, y ); } // y <- A * x template < typename matrix_type, typename vector_type_x, typename vector_type_y > inline void gemv(const matrix_type &a, const vector_type_x &x, vector_type_y &y) { typedef typename traits::matrix_traits::value_type val_t; gemv( traits::NO_TRANSPOSE, (val_t) 1, a, x, (val_t) 0, y ); } */ }}}} #endif // BOOST_BINDINGS_BLAS_BLAS2_HPP boost-bindings/boost/numeric/bindings/blas/blas2_overloads.hpp0000644000175000017500000000661507707750440024735 0ustar andreasandreas// Copyright (C) Toon Knapen 2003 // // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS2_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS2_OVERLOADS_HPP #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { namespace detail { using namespace boost::numeric::bindings::traits ; inline void gemv( char TRANS, const int& m, const int& n, const float & alpha, const float * a_ptr, const int& lda, const float * x_ptr, const int& incx, const float & beta, float * y_ptr, const int& incy ) { BLAS_SGEMV( &TRANS, &m, &n, ( &alpha ), ( a_ptr ), &lda, ( x_ptr ), &incx, ( &beta ), ( y_ptr ), &incy ) ; } inline void gemv( char TRANS, const int& m, const int& n, const double & alpha, const double * a_ptr, const int& lda, const double * x_ptr, const int& incx, const double & beta, double * y_ptr, const int& incy ) { BLAS_DGEMV( &TRANS, &m, &n, ( &alpha ), ( a_ptr ), &lda, ( x_ptr ), &incx, ( &beta ), ( y_ptr ), &incy ) ; } inline void gemv( char TRANS, const int& m, const int& n, const complex_f& alpha, const complex_f* a_ptr, const int& lda, const complex_f* x_ptr, const int& incx, const complex_f& beta, complex_f* y_ptr, const int& incy ) { BLAS_CGEMV( &TRANS, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( x_ptr ), &incx, complex_ptr( &beta ), complex_ptr( y_ptr ), &incy ) ; } inline void gemv( char TRANS, const int& m, const int& n, const complex_d& alpha, const complex_d* a_ptr, const int& lda, const complex_d* x_ptr, const int& incx, const complex_d& beta, complex_d* y_ptr, const int& incy ) { BLAS_ZGEMV( &TRANS, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( x_ptr ), &incx, complex_ptr( &beta ), complex_ptr( y_ptr ), &incy ) ; } inline void ger( const int& m, const int& n, const float & alpha, const float * x_ptr, const int& incx, const float * y_ptr, const int& incy, float * a_ptr, const int& lda ) { BLAS_SGER( &m, &n, &alpha, x_ptr, &incx, y_ptr, &incy, a_ptr, &lda ) ; } inline void ger( const int& m, const int& n, const double & alpha, const double * x_ptr, const int& incx, const double * y_ptr, const int& incy, double * a_ptr, const int& lda ) { BLAS_DGER( &m, &n, &alpha, x_ptr, &incx, y_ptr, &incy, a_ptr, &lda ) ; } /* inline void geru( const int& m, const int& n, const complex_f & alpha, const complex_f * x_ptr, const int& incx, complex_f * y_ptr, const int& incy, complex_f * a_ptr, const int& lda ) { BLAS_CGERU( &m, &n, complex_ptr( &alpha ), complex_ptr( x_ptr ), &incx, complex_ptr( y_ptr ), &incy, complex_ptr( a_ptr ), &lda ) ; } inline void geru( const int& m, const int& n, const complex_d & alpha, const complex_d * x_ptr, const int& incx, complex_d * y_ptr, const int& incy, complex_d * a_ptr, const int& lda ) { BLAS_ZGERU( &m, &n, complex_ptr( &alpha ), complex_ptr( x_ptr ), &incx, complex_ptr( y_ptr ), &incy, complex_ptr( a_ptr ), &lda ) ; } */ }}}}} #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS2_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/blas/blas3.hpp0000644000175000017500000001324210201624745022641 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen and Kresimir Fresl #ifndef BOOST_BINDINGS_BLAS_BLAS3_HPP #define BOOST_BINDINGS_BLAS_BLAS3_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { // C <- alpha * op (A) * op (B) + beta * C // op (X) == X || X^T || X^H template < typename value_type, typename matrix_type_a, typename matrix_type_b, typename matrix_type_c > // ! CAUTION this function assumes that all matrices involved are column-major matrices void gemm(const char TRANSA, const char TRANSB, const value_type& alpha, const matrix_type_a &a, const matrix_type_b &b, const value_type &beta, matrix_type_c &c ) { const int m = TRANSA == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) ; const int n = TRANSB == traits::NO_TRANSPOSE ? traits::matrix_size2( b ) : traits::matrix_size1( b ); const int k = TRANSA == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ; assert( k == ( TRANSB == traits::NO_TRANSPOSE ? traits::matrix_size1( b ) : traits::matrix_size2( b ) ) ) ; assert( m == traits::matrix_size1( c ) ); assert( n == traits::matrix_size2( c ) ); const int lda = traits::leading_dimension( a ); const int ldb = traits::leading_dimension( b ); const int ldc = traits::leading_dimension( c ); const value_type *a_ptr = traits::matrix_storage( a ) ; const value_type *b_ptr = traits::matrix_storage( b ) ; value_type *c_ptr = traits::matrix_storage( c ) ; detail::gemm( TRANSA, TRANSB, m, n, k, alpha, a_ptr, lda, b_ptr, ldb, beta, c_ptr, ldc ) ; } // C <- alpha * A * B + beta * C template < typename value_type, typename matrix_type_a, typename matrix_type_b, typename matrix_type_c > void gemm(const value_type& alpha, const matrix_type_a &a, const matrix_type_b &b, const value_type &beta, matrix_type_c &c ) { gemm( traits::NO_TRANSPOSE, traits::NO_TRANSPOSE, alpha, a, b, beta, c ) ; } // C <- A * B // ! CAUTION this function assumes that all matrices involved are column-major matrices template < typename matrix_type_a, typename matrix_type_b, typename matrix_type_c > void gemm(const matrix_type_a &a, const matrix_type_b &b, matrix_type_c &c) { typedef typename traits::matrix_traits::value_type val_t; gemm( traits::NO_TRANSPOSE, traits::NO_TRANSPOSE, (val_t) 1, a, b, (val_t) 0, c ) ; } // C <- alpha * A * A^T + beta * C // C <- alpha * A^T * A + beta * C template < typename value_type, typename matrix_type_a, typename matrix_type_c > void syrk( char uplo, char trans, const value_type& alpha, const matrix_type_a& a, const value_type& beta, matrix_type_c& c) { const int n = traits::matrix_size1( c ); assert( n == traits::matrix_size2( c ) ); const int k = trans == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ; assert( n == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) ); const int lda = traits::leading_dimension( a ); const int ldc = traits::leading_dimension( c ); const value_type *a_ptr = traits::matrix_storage( a ) ; value_type *c_ptr = traits::matrix_storage( c ) ; detail::syrk( uplo, trans, n, k, alpha, a_ptr, lda, beta, c_ptr, ldc ); } // syrk() // C <- alpha * A * A^H + beta * C // C <- alpha * A^H * A + beta * C template < typename real_type, typename matrix_type_a, typename matrix_type_c > void herk( char uplo, char trans, const real_type& alpha, const matrix_type_a& a, const real_type& beta, matrix_type_c& c) { typedef typename matrix_type_c::value_type value_type ; const int n = traits::matrix_size1( c ); assert( n == traits::matrix_size2( c ) ); const int k = trans == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ; assert( n == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) ); const int lda = traits::leading_dimension( a ); const int ldc = traits::leading_dimension( c ); const value_type *a_ptr = traits::matrix_storage( a ) ; value_type *c_ptr = traits::matrix_storage( c ) ; detail::herk( uplo, trans, n, k, alpha, a_ptr, lda, beta, c_ptr, ldc ); } // herk() // B <- alpha * op( A^-1 ) // B <- alpha * B op( A^-1 ) // op( A ) = A, A^T, A^H template < class T, class A, class B > void trsm( char side, char uplo, char transa, char diag, T const& alpha, A const& a, B& b ) { const int m = traits::matrix_size1( b ) ; const int n = traits::matrix_size2( b ) ; assert( ( side=='L' && m==traits::matrix_size2( a ) && m==traits::matrix_size1( a ) ) || ( side=='R' && n==traits::matrix_size2( a ) && n==traits::matrix_size1( a ) ) ) ; assert( side=='R' || side=='L' ) ; assert( uplo=='U' || uplo=='L' ) ; assert( ( side=='L' && m==traits::matrix_size1( a ) ) || ( side=='R' && n==traits::matrix_size1( a ) ) ) ; detail::trsm( side, uplo, transa, diag, m, n, alpha, traits::matrix_storage( a ), traits::leading_dimension( a ), traits::matrix_storage( b ), traits::leading_dimension( b ) ) ; } }}}} #endif // BOOST_BINDINGS_BLAS_BLAS3_HPP boost-bindings/boost/numeric/bindings/blas/blas3_overloads.hpp0000644000175000017500000001441610201624745024723 0ustar andreasandreas// Copyright (C) Toon Knapen 2003 // // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { namespace detail { using namespace boost::numeric::bindings::traits ; inline void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const float & alpha, const float * a_ptr, const int& lda, const float * b_ptr, const int& ldb, const float & beta, float * c_ptr, const int& ldc ) { BLAS_SGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; } inline void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const double & alpha, const double * a_ptr, const int& lda, const double * b_ptr, const int& ldb, const double & beta, double * c_ptr, const int& ldc ) { BLAS_DGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; } inline void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const complex_f& alpha, const complex_f* a_ptr, const int& lda, const complex_f* b_ptr, const int& ldb, const complex_f& beta, complex_f* c_ptr, const int& ldc ) { BLAS_CGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; } inline void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const complex_d& alpha, const complex_d* a_ptr, const int& lda, const complex_d* b_ptr, const int& ldb, const complex_d& beta, complex_d* c_ptr, const int& ldc ) { BLAS_ZGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; } // // SYRK // inline void syrk( char uplo, char trans, const int& n, const int& k, const float& alpha, const float* a_ptr, const int lda, const float& beta, float* c_ptr, const int& ldc) { BLAS_SSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc); } inline void syrk( char uplo, char trans, const int& n, const int& k, const double& alpha, const double* a_ptr, const int lda, const double& beta, double* c_ptr, const int& ldc) { BLAS_DSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc); } inline void syrk( char uplo, char trans, const int& n, const int& k, const complex_f& alpha, const complex_f* a_ptr, const int lda, const complex_f& beta, complex_f* c_ptr, const int& ldc) { BLAS_CSYRK( &uplo, &trans, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc); } inline void syrk( char uplo, char trans, const int& n, const int& k, const complex_d& alpha, const complex_d* a_ptr, const int lda, const complex_d& beta, complex_d* c_ptr, const int& ldc) { BLAS_ZSYRK( &uplo, &trans, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc); } // // HERK // inline void herk( char uplo, char trans, const int& n, const int& k, const float& alpha, const float* a_ptr, const int lda, const float& beta, float* c_ptr, const int& ldc) { BLAS_SSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc); } inline void herk( char uplo, char trans, const int& n, const int& k, const double& alpha, const double* a_ptr, const int lda, const double& beta, double* c_ptr, const int& ldc) { BLAS_DSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc); } inline void herk( char uplo, char trans, const int& n, const int& k, const float& alpha, const complex_f* a_ptr, const int lda, const float& beta, complex_f* c_ptr, const int& ldc) { BLAS_CHERK( &uplo, &trans, &n, &k, &alpha, complex_ptr( a_ptr ), &lda, &beta, complex_ptr( c_ptr ), &ldc); } inline void herk( char uplo, char trans, const int& n, const int& k, const double& alpha, const complex_d* a_ptr, const int lda, const double& beta, complex_d* c_ptr, const int& ldc) { BLAS_ZHERK( &uplo, &trans, &n, &k, &alpha, complex_ptr( a_ptr ), &lda, &beta, complex_ptr( c_ptr ), &ldc); } // // trsm // inline void trsm( char side, char uplo, char transa, char diag, int m, int n, float const& alpha, float const* a_ptr, int lda, float* b_ptr, int ldb ) { BLAS_STRSM( &side, &uplo, &transa, &diag, &m, &n, &alpha, a_ptr, &lda, b_ptr, &ldb ) ; } inline void trsm( char side, char uplo, char transa, char diag, int m, int n, double const& alpha, double const* a_ptr, int lda, double* b_ptr, int ldb ) { BLAS_DTRSM( &side, &uplo, &transa, &diag, &m, &n, &alpha, a_ptr, &lda, b_ptr, &ldb ) ; } inline void trsm( char side, char uplo, char transa, char diag, int m, int n, complex_f const& alpha, complex_f const* a_ptr, int lda, complex_f* b_ptr, int ldb ) { BLAS_CTRSM( &side, &uplo, &transa, &diag, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb ) ; } inline void trsm( char side, char uplo, char transa, char diag, int m, int n, complex_d const& alpha, complex_d const* a_ptr, int lda, complex_d* b_ptr, int ldb ) { BLAS_ZTRSM( &side, &uplo, &transa, &diag, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb ) ; } }}}}} #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/blas/blas_names.h0000644000175000017500000000500010201624745023372 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright (C) 2002, 2003 Si-Lab b.v.b.a and Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS_NAMES_H #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS_NAMES_H #include // // level 1 // #define BLAS_SSCAL FORTRAN_ID( sscal ) #define BLAS_DSCAL FORTRAN_ID( dscal ) #define BLAS_CSCAL FORTRAN_ID( cscal ) #define BLAS_ZSCAL FORTRAN_ID( zscal ) #define BLAS_SAXPY FORTRAN_ID( saxpy ) #define BLAS_DAXPY FORTRAN_ID( daxpy ) #define BLAS_CAXPY FORTRAN_ID( caxpy ) #define BLAS_ZAXPY FORTRAN_ID( zaxpy ) #define BLAS_SDOT FORTRAN_ID( sdot ) #define BLAS_DDOT FORTRAN_ID( ddot ) #define BLAS_CDOTU FORTRAN_ID( cdotu ) #define BLAS_ZDOTU FORTRAN_ID( zdotu ) #define BLAS_CDOTC FORTRAN_ID( cdotc ) #define BLAS_ZDOTC FORTRAN_ID( zdotc ) #define BLAS_SNRM2 FORTRAN_ID( snrm2 ) #define BLAS_DNRM2 FORTRAN_ID( dnrm2 ) #define BLAS_SCNRM2 FORTRAN_ID( scnrm2 ) #define BLAS_DZNRM2 FORTRAN_ID( dznrm2 ) #define BLAS_SASUM FORTRAN_ID( sasum ) #define BLAS_DASUM FORTRAN_ID( dasum ) #define BLAS_SCASUM FORTRAN_ID( scasum ) #define BLAS_DZASUM FORTRAN_ID( dzasum ) #define BLAS_SCOPY FORTRAN_ID( scopy ) #define BLAS_DCOPY FORTRAN_ID( dcopy ) #define BLAS_CCOPY FORTRAN_ID( ccopy ) #define BLAS_ZCOPY FORTRAN_ID( zcopy ) // // level 2 // #define BLAS_SGEMV FORTRAN_ID( sgemv ) #define BLAS_DGEMV FORTRAN_ID( dgemv ) #define BLAS_CGEMV FORTRAN_ID( cgemv ) #define BLAS_ZGEMV FORTRAN_ID( zgemv ) #define BLAS_SGER FORTRAN_ID( sger ) #define BLAS_DGER FORTRAN_ID( dger ) #define BLAS_CGERU FORTRAN_ID( cgeru ) #define BLAS_ZGERU FORTRAN_ID( zgeru ) #define BLAS_CGERC FORTRAN_ID( cgerc ) #define BLAS_ZGERC FORTRAN_ID( zgerc ) // // level 3 // #define BLAS_SGEMM FORTRAN_ID( sgemm ) #define BLAS_DGEMM FORTRAN_ID( dgemm ) #define BLAS_CGEMM FORTRAN_ID( cgemm ) #define BLAS_ZGEMM FORTRAN_ID( zgemm ) #define BLAS_SSYRK FORTRAN_ID( ssyrk ) #define BLAS_DSYRK FORTRAN_ID( dsyrk ) #define BLAS_CSYRK FORTRAN_ID( csyrk ) #define BLAS_ZSYRK FORTRAN_ID( zsyrk ) #define BLAS_CHERK FORTRAN_ID( cherk ) #define BLAS_ZHERK FORTRAN_ID( zherk ) #define BLAS_STRSM FORTRAN_ID( strsm ) #define BLAS_DTRSM FORTRAN_ID( dtrsm ) #define BLAS_CTRSM FORTRAN_ID( ctrsm ) #define BLAS_ZTRSM FORTRAN_ID( ztrsm ) #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS_NAMES_H boost-bindings/boost/numeric/bindings/cblas/0000755000175000017500000000000010776011453021270 5ustar andreasandreasboost-bindings/boost/numeric/bindings/lapack/0000755000175000017500000000000010776160766021453 5ustar andreasandreasboost-bindings/boost/numeric/bindings/lapack/steqr.hpp0000644000175000017500000000645410776012610023313 0ustar andreasandreas// // Copyright Karl Meerbergen 2007 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_STEQR_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_STEQR_HPP #include #include #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif /********************************************************************/ /* eigenvalue problems */ /********************************************************************/ /* tridiagonal symmetric */ namespace boost { namespace numeric { namespace bindings { namespace lapack { namespace detail { inline void steqr ( char compz, int n, float* d, float* e, float* z, int ldz, float* work, int& info ) { LAPACK_SSTEQR( &compz, &n, d, e, z, &ldz, work, &info ) ; } inline void steqr ( char compz, int n, double* d, double* e, double* z, int ldz, double* work, int& info ) { LAPACK_DSTEQR( &compz, &n, d, e, z, &ldz, work, &info ) ; } } // namespace detail template inline int steqr( char compz, D& d, E& e, Z& z, W& work ) { int const n = traits::vector_size (d); assert( traits::vector_size (e) == n-1 ); assert( traits::matrix_size1 (z) == n ); assert( traits::matrix_size2 (z) == n ); assert( compz=='N' || compz=='V' || compz=='I' ); int lwork = traits::vector_size( work ) ; int info; detail::steqr( compz, n, traits::vector_storage( d ), traits::vector_storage( e ), traits::matrix_storage( z ), traits::leading_dimension( z ), traits::vector_storage( work ), info ) ; return info; } // steqr() template inline int steqr( char compz, D& d, E& e, Z& z, optimal_workspace ) { int lwork = 0 ; if (compz != 'N') lwork = 2 * traits::vector_size( d ) - 2 ; traits::detail::array::value_type> work( lwork ); return steqr( compz, d, e, z, work ) ; } template inline int steqr( char compz, D& d, E& e, Z& z, minimal_workspace ) { int lwork = 1 ; if (compz != 'N') lwork = 2 * traits::vector_size( e ) ; traits::detail::array::value_type> work( lwork ); return steqr( compz, d, e, z, work ) ; } template inline int steqr( char compz, D& d, E& e, Z& z ) { return steqr( compz, d, e, z, minimal_workspace() ) ; } }}}} #endif // BOOST_NUMERIC_BINDINGS_LAPACK_GBSV_HPP boost-bindings/boost/numeric/bindings/lapack/gels.hpp0000644000175000017500000001523310662646062023112 0ustar andreasandreas#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELS_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GELS_HPP #include #include #include #include #include #include #include #include // included to implicitly convert a vector to an nx1 matrix // so that it is compatible with lapack binding #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { //////////////////////////////////////////////////////////////////////// // // Linear Least Squares of an underdetermined or overdetermined matrix // /////////////////////////////////////////////////////////////////////// /* gels - uses the LQ or QR factorization to solve an overdetermined * or underdetermined linear system. A full rank matrix is * assumed. * * The linear least squares system is defined by A*x=b. A is the m-by-n * coefficients matrix and b is the m-by-nrhs matrix. Several * right hand side vectors b and solution vectors x can be handled in * a single call; they are stored as the columns of the m-by-nrhs right * hand side matrix B and the n-by-nrh solution matrix x. * * If trans = 'N' and m >= n: find least squares solution of overdetermined system * minimizes || b - A x ||2 * * if trans = 'N' and m < n: find minimum norm solution of underdetermined system * A*X = B * * if trans = 'T' or 'C' and m >= n: find minimum norm soltion of underdetermined system * A^H*X = B * * if trans = 'T' or 'C' and m < n: find least squares solution of overdetermined system * minimize || b - A^H x ||2 * * Workspace is organized following the arguments in the calling sequence. * optimal_workspace() : for optimizing use of blas 3 kernels * minimal_workspace() : minimum size of work arrays, but does not allow for optimization * of blas 3 kernels * workspace( work ) : where work size must be at least min(m, n) + max(1, m, n, nrhs) * * * Each solution vector x (length n) is returned column-wise in the rhs matrix B. */ namespace detail { inline void gels(char const trans, const int m, const int n, const int nrhs, float *a, const int lda, float *b, const int ldb, float *work, const int lwork, int *info) { LAPACK_SGELS(&trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork, info); } inline void gels(char const trans, const int m, const int n, const int nrhs, double *a, const int lda, double *b, const int ldb, double *work, const int lwork, int *info) { LAPACK_DGELS(&trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork, info); } inline void gels(char const trans, const int m, const int n, const int nrhs, traits::complex_f *a, const int lda, traits::complex_f *b, const int ldb, traits::complex_f *work, const int lwork, int *info) { LAPACK_CGELS(&trans, &m, &n, &nrhs, traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(work), &lwork, info); } inline void gels(char const trans, const int m, const int n, const int nrhs, traits::complex_d *a, const int lda, traits::complex_d *b, const int ldb, traits::complex_d *work, const int lwork, int *info) { LAPACK_ZGELS(&trans, &m, &n, &nrhs, traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(work), &lwork, info); } // generic function that calls more detailed lapack function template int gels(const char trans, MatrA& A, VecB& b, Work& work) { const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int mrhs = traits::matrix_size1(b); const int nrhs = traits::matrix_size2(b); // sanity checks assert(trans == 'N' || trans == 'T' || trans == 'C'); assert(m >= 0 && n >= 0); assert(mrhs >= 0 && nrhs >= 0); assert(traits::leading_dimension(A) >= 1 && traits::leading_dimension(b) >= 1); assert(mrhs == std::max(m, n)); int info; detail::gels(trans, traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(b), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(b), traits::leading_dimension(b), traits::vector_storage(work), traits::vector_size(work), &info); return info; } // query for recommended workspace template inline int gels_optimal_work(const char trans, MatrA& A, VecB& b) { MatrA::value_type work; int info; detail::gels(trans, traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(b), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(b), traits::leading_dimension(b), &work, //traits::vector_storage(work), -1, // traits::vector_size(work), &info); assert(info == 0); int lwork = traits::detail::to_int(work); return lwork; } } // namespace detail template inline int gels(const char trans, MatrA& A, VecB& b, optimal_workspace) { // query optimal workspace size int work_size = detail::gels_optimal_work(trans, A, b); traits::detail::array work(work_size); return detail::gels(trans, A, b, work); } template inline int gels(const char trans, MatrA& A, VecB& b, minimal_workspace) { const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int r = traits::matrix_size2(b); const int minmn = std::min(m, n); //m < n ? m : n; const int maxmn = std::max(m, n); // m > n ? m : n; const int maxdim = std::max(maxmn, r); // maxmn > r ? maxmn : r; traits::detail::array work(minmn + std::max(1, maxdim)); return detail::gels(trans, A, b, work); } template inline int gels(const char trans, MatrA& A, VecB& b, detail::workspace1 workspace) { return detail::gels(trans, A, b, workspace.w_); } } // namespace lapack }}} #endifboost-bindings/boost/numeric/bindings/lapack/gees.hpp0000644000175000017500000003354707752726051023116 0ustar andreasandreas/* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEES_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GEES_HPP #include #include #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Schur factorization of general matrix. // /////////////////////////////////////////////////////////////////// /* * gees() computes a Schur factorization of an N-by-N matrix A. * * The Schur decomposition is A = U S * herm(U) where U is a * unitary matrix and S is upper triangular. The eigenvalues of A * are on the main diagonal of S. If A is real, S is in pseudo * upper triangular form. * * Workspace is organized following the arguments in the calling sequence. * optimal_workspace() : for optimizing use of blas 3 kernels * minimal_workspace() : minimum size of workarrays, but does not allow for optimization * of blas 3 kernels * workspace( work ) for real matrices where work is a real array with * vector_size( work ) >= 3*matrix_size1( a ) * workspace( work, rwork ) for complex matrices where work is a complex * array with vector_size( work ) >= 2*matrix_size1( a ) * and rwork is a real array with * vector_size( rwork ) >= matrix_size1( a ). */ namespace detail { inline void gees (char const jobvs, char const sort, logical_t* select, int const n, float* a, int const lda, int& sdim, traits::complex_f* w, float* vs, int const ldvs, float* work, int const lwork, bool* bwork, int& info) { traits::detail::array wr(n); traits::detail::array wi(n); LAPACK_SGEES (&jobvs, &sort, select, &n, a, &lda, &sdim, traits::vector_storage(wr), traits::vector_storage(wi), vs, &ldvs, work, &lwork, bwork, &info); traits::detail::interlace(traits::vector_storage(wr), traits::vector_storage(wr)+n, traits::vector_storage(wi), w); } inline void gees (char const jobvs, char const sort, logical_t* select, int const n, double* a, int const lda, int& sdim, traits::complex_d* w, double* vs, int const ldvs, double* work, int const lwork, bool* bwork, int& info) { traits::detail::array wr(n); traits::detail::array wi(n); LAPACK_DGEES (&jobvs, &sort, select, &n, a, &lda, &sdim, traits::vector_storage(wr), traits::vector_storage(wi), vs, &ldvs, work, &lwork, bwork, &info); traits::detail::interlace(traits::vector_storage(wr), traits::vector_storage(wr)+n, traits::vector_storage(wi), w); } inline void gees (char const jobvs, char const sort, logical_t* select, int const n, traits::complex_f* a, int const lda, int& sdim, traits::complex_f* w, traits::complex_f* vs, int const ldvs, traits::complex_f* work, int lwork, float* rwork, bool* bwork, int& info) { LAPACK_CGEES (&jobvs, &sort, select, &n, traits::complex_ptr(a), &lda, &sdim, traits::complex_ptr(w), traits::complex_ptr (vs), &ldvs, traits::complex_ptr(work), &lwork, rwork, bwork, &info); } inline void gees (char const jobvs, char const sort, logical_t* select, int const n, traits::complex_d* a, int const lda, int& sdim, traits::complex_d* w, traits::complex_d* vs, int const ldvs, traits::complex_d* work, int lwork, double* rwork, bool* bwork, int& info) { LAPACK_ZGEES (&jobvs, &sort, select, &n, traits::complex_ptr(a), &lda, &sdim, traits::complex_ptr(w), traits::complex_ptr(vs), &ldvs, traits::complex_ptr(work), &lwork, rwork, bwork, &info); } } namespace detail { /// Compute Schur factorization, passing one work array. template inline int gees (char jobvs, MatrA& a, EigVal& w, SchVec& vs, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif typedef typename MatrA::value_type value_type ; int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (vs)); assert (n == traits::matrix_size2 (vs)); assert (n == traits::vector_size (w)); assert (3*n <= traits::vector_size (work)); logical_t* select=0; bool* bwork=0; int info, sdim; detail::gees (jobvs, 'N', select, n, traits::matrix_storage (a), traits::leading_dimension (a), sdim, traits::vector_storage (w), traits::matrix_storage (vs), traits::leading_dimension (vs), traits::vector_storage( work ), traits::vector_size( work ), bwork, info); return info ; } // gees() /// Compute Schur factorization, passing two work arrays. template inline int gees (char jobvs, MatrA& a, EigVal& w, SchVec& vs, Work& work, RWork& rwork) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif typedef typename MatrA::value_type value_type ; int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (vs)); assert (n == traits::matrix_size2 (vs)); assert (n == traits::vector_size (w)); assert (2*n <= traits::vector_size (work)); assert (n <= traits::vector_size (rwork)); logical_t* select=0; bool* bwork=0; int info, sdim; detail::gees (jobvs, 'N', select, n, traits::matrix_storage (a), traits::leading_dimension (a), sdim, traits::vector_storage (w), traits::matrix_storage (vs), traits::leading_dimension (vs), traits::vector_storage( work ), traits::vector_size( work ), traits::vector_storage( rwork ), bwork, info); return info ; } // gees() /// Compute Schur factorization, depending on whether we have one or /// two workspace arrays. N= the number of workspace arrays. template struct Gees {}; template <> struct Gees< 2 > { template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, optimal_workspace ) const { typedef typename MatrA::value_type value_type ; typedef typename traits::type_traits< value_type >::real_type real_type ; int n = traits::matrix_size1( a ); traits::detail::array work( 2*n ); traits::detail::array rwork( n ); return gees( jobvs, a, w, vs, work, rwork ); } // gees() template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, minimal_workspace ) const { typedef typename MatrA::value_type value_type ; typedef typename traits::type_traits< value_type >::real_type real_type ; int n = traits::matrix_size1( a ); traits::detail::array work( 2*n ); traits::detail::array rwork( n ); return gees( jobvs, a, w, vs, work, rwork ); } // gees() /// Compute Schur factorization, passing workspace2 as workspace template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, workspace2& workspace ) const { return gees( jobvs, a, w, vs, workspace.w_, workspace.wr_ ); } // gees() }; // Gees<2> template <> struct Gees< 1 > { template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, optimal_workspace ) const { typedef typename MatrA::value_type value_type ; typedef typename traits::type_traits< value_type >::real_type real_type ; int n = traits::matrix_size1( a ); traits::detail::array work( 3*n ); return gees( jobvs, a, w, vs, work ); } // gees() template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, minimal_workspace ) const { typedef typename MatrA::value_type value_type ; typedef typename traits::type_traits< value_type >::real_type real_type ; int n = traits::matrix_size1( a ); traits::detail::array work( 3*n ); return gees( jobvs, a, w, vs, work ); } // gees() /// Compute Schur factorization, passing workspace1 as workspace template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, detail::workspace1 workspace ) const { return gees( jobvs, a, w, vs, workspace.w_ ); } // gees() }; // Gees<1> } // namespace detail /// Compute Schur factorization with Schur vectors. /// /// Workspace can be the following : /// optimal_workspace() : for optimizing use of blas 3 kernels /// minimal_workspace() : minimum size of workarrays, but does not allow for optimization /// of blas 3 kernels /// workspace( real_work ) for real matrices where /// vector_size( real_work ) >= 3*matrix_size1( a ) /// workspace( complex_work, real_work ) for complex matrices where /// vector_size( complex_work ) >= 2*matrix_size1( a ) /// and vector_size( real_work ) >= matrix_size1( a ). template inline int gees (MatrA& a, EigVal& e, SchVec& vs, Workspace workspace ) { return detail::Gees< n_workspace_args::value>() ( 'V', a, e, vs, workspace ); } // gees() // Compute Schur factorization without Schur vectors. /// /// Workspace can be the following : /// optimal_workspace() : for optimizing use of blas 3 kernels /// minimal_workspace() : minimum size of workarrays, but does not allow for optimization /// of blas 3 kernels /// workspace( real_work ) for real matrices where /// vector_size( real_work ) >= 3*matrix_size1( a ) /// workspace( complex_work, real_work ) for complex matrices where /// vector_size( complex_work ) >= 2*matrix_size1( a ) /// and vector_size( real_work ) >= matrix_size1( a ). template inline int gees (MatrA& a, EigVal& e, Workspace workspace) { return detail::Gees< n_workspace_args::value>() ('N', a, e, a, workspace ); } } }}} #endif boost-bindings/boost/numeric/bindings/lapack/geev.hpp0000644000175000017500000002713110507532244023100 0ustar andreasandreas/* * * Copyright (c) Andreas Kloeckner 2004 * Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEEV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GEEV_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Eigendecomposition of a general matrix A * V = V * D // /////////////////////////////////////////////////////////////////// /* * geev() computes the eigendecomposition of a N x N matrix, * where V is a N x N matrix and D is a diagonal matrix. The * diagonal element D(i,i) is an eigenvalue of A and Q(:,i) is * a corresponding eigenvector. * * * int geev (char jobz, char uplo, A& a, W& w, V* vl, V* vr, optimal_workspace); * * a is the matrix whose eigendecomposition you're interested in. (input) * * w contains the diagonal of D, above. w must always be complex. (output) * * vl is an N x N matrix containing the left eigenvectors of a in its * columns. See remark on complex vs. real below. May be left NULL to indicate * that you do not want left eigenvectors. * * vr is an N x N matrix containing the right ("usual") eigenvectors of a in its * columns. See remark on complex vs. real below. As a matrix, vr fulfills * A * VR = VR * D. (except if real, see below). May be left NULL to indicate * that you do not want right eigenvectors. * * * For real A, vr and vl may be either complex or real, at your option. * If you choose to leave them real, you have to pick apart the complex-conjugate * eigenpairs as per the LAPACK documentation. If you choose them complex, * the code will do the picking-apart on your behalf, at the expense of 4*N * extra storage. Only if vr is complex, it will really fulfill its invariant * on exit to the code in all cases, since complex pairs spoil that relation. */ namespace detail { inline int geev_backend(const char* jobvl, const char* jobvr, const int* n, float* a, const int* lda, float* wr, float* wi, float* vl, const int* ldvl, float* vr, const int* ldvr, float* work, const int* lwork) { int info; LAPACK_SGEEV(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, &info); return info; } inline int geev_backend(const char* jobvl, const char* jobvr, const int* n, double* a, const int* lda, double* wr, double* wi, double* vl, const int* ldvl, double* vr, const int* ldvr, double* work, const int* lwork) { int info; LAPACK_DGEEV(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, &info); return info; } inline int geev_backend(const char* jobvl, const char* jobvr, const int* n, traits::complex_f* a, const int* lda, traits::complex_f* w, traits::complex_f* vl, const int* ldvl, traits::complex_f* vr, const int* ldvr, traits::complex_f* work, const int* lwork, float* rwork) { int info; LAPACK_CGEEV(jobvl, jobvr, n, reinterpret_cast(a), lda, reinterpret_cast(w), reinterpret_cast(vl), ldvl, reinterpret_cast(vr), ldvr, reinterpret_cast(work), lwork, rwork, &info); return info; } inline int geev_backend(const char* jobvl, const char* jobvr, const int* n, traits::complex_d* a, const int* lda, traits::complex_d* w, traits::complex_d* vl, const int* ldvl, traits::complex_d* vr, const int* ldvr, traits::complex_d* work, const int* lwork, double* rwork) { int info; LAPACK_ZGEEV(jobvl, jobvr, n, reinterpret_cast(a), lda, reinterpret_cast(w), reinterpret_cast(vl), ldvl, reinterpret_cast(vr), ldvr, reinterpret_cast(work), lwork, rwork, &info); return info; } struct real_case {}; struct mixed_case {}; struct complex_case {}; // real case template int geev(real_case, const char jobvl, const char jobvr, A& a, W& w, V* vl, V *vr) { int const n = traits::matrix_size1(a); typedef typename A::value_type value_type; traits::detail::array wr(n); traits::detail::array wi(n); traits::detail::array vl2(vl ? 0 : n); traits::detail::array vr2(vr ? 0 : n); value_type* vl_real = vl ? traits::matrix_storage(*vl) : vl2.storage(); const int ldvl = vl ? traits::matrix_size2(*vl) : 1; value_type* vr_real = vr ? traits::matrix_storage(*vr) : vr2.storage(); const int ldvr = vr ? traits::matrix_size2(*vr) : 1; // workspace query int lwork = -1; value_type work_temp; int result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, wr.storage(), wi.storage(), vl_real, &ldvl, vr_real, &ldvr, &work_temp, &lwork); if (result != 0) return result; lwork = (int) work_temp; traits::detail::array work(lwork); result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, wr.storage(), wi.storage(), vl_real, &ldvl, vr_real, &ldvr, work.storage(), &lwork); for (int i = 0; i < n; i++) w[i] = std::complex(wr[i], wi[i]); return result; } // mixed (i.e. real with complex vectors) case template int geev(mixed_case, const char jobvl, const char jobvr, A& a, W& w, V* vl, V *vr) { int const n = traits::matrix_size1(a); typedef typename A::value_type value_type; traits::detail::array wr(n); traits::detail::array wi(n); traits::detail::array vl2(vl ? n*n : n); traits::detail::array vr2(vr ? n*n : n); const int ldvl2 = vl ? n : 1; const int ldvr2 = vr ? n : 1; // workspace query int lwork = -1; value_type work_temp; int result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, wr.storage(), wi.storage(), vl2.storage(), &ldvl2, vr2.storage(), &ldvr2, &work_temp, &lwork); if (result != 0) return result; lwork = (int) work_temp; traits::detail::array work(lwork); result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, wr.storage(), wi.storage(), vl2.storage(), &ldvl2, vr2.storage(), &ldvr2, work.storage(), &lwork); typedef typename V::value_type vec_value_type; vec_value_type* vl_stor = NULL; vec_value_type* vr_stor = NULL; int ldvl = 0, ldvr = 0; if (vl) { vl_stor = traits::matrix_storage(*vl); ldvl = traits::matrix_size2(*vl); } if (vr) { vr_stor = traits::matrix_storage(*vr); ldvr = traits::matrix_size2(*vr); } for (int i = 0; i < n; i++) { w[i] = std::complex(wr[i], wi[i]); if (wi[i] != 0) { assert(i+1 < n); assert(wr[i+1] == wr[i]); assert(wi[i+1] == -wi[i+1]); w[i+1] = std::complex(wr[i+1], wi[i+1]); for (int j = 0; j < n; j++) { if (vl) { vl_stor[i*ldvl+j] = std::complex(vl2[i*n+j], vl2[(i+1)*n+j]); vl_stor[(i+1)*ldvl+j] = std::complex(vl2[i*n+j], -vl2[(i+1)*n+j]); } if (vr) { vr_stor[i*ldvr+j] = std::complex(vr2[i*n+j], vr2[(i+1)*n+j]); vr_stor[(i+1)*ldvr+j] = std::complex(vr2[i*n+j], -vr2[(i+1)*n+j]); } } i++; } else { for (int j = 0; j < n; j++) { if (vl) vl_stor[i*ldvl+j] = vl2[i*n+j]; if (vr) vr_stor[i*ldvr+j] = vr2[i*n+j]; } } } return result; } // complex case template int geev(complex_case, const char jobvl, const char jobvr, A& a, W& w, V* vl, V *vr) { typedef typename A::value_type value_type; typedef typename traits::type_traits::real_type real_type; int const n = traits::matrix_size1(a); traits::detail::array rwork(2*n); traits::detail::array vl2(vl ? 0 : n); traits::detail::array vr2(vr ? 0 : n); value_type* vl_real = vl ? traits::matrix_storage(*vl) : vl2.storage(); const int ldvl = vl ? traits::matrix_size2(*vl) : 1; value_type* vr_real = vr ? traits::matrix_storage(*vr) : vr2.storage(); const int ldvr = vr ? traits::matrix_size2(*vr) : 1; // workspace query int lwork = -1; value_type work_temp; int result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, traits::vector_storage(w), vl_real, &ldvl, vr_real, &ldvr, &work_temp, &lwork, rwork.storage()); if (result != 0) return result; lwork = (int) std::real(work_temp); traits::detail::array work(lwork); result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, traits::vector_storage(w), vl_real, &ldvl, vr_real, &ldvr, work.storage(), &lwork, rwork.storage()); return result; } } // namespace detail // gateway / dispatch routine template int geev(A& a, W& w, V* vl, V* vr, optimal_workspace) { // input checking #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif #ifndef NDEBUG int const n = traits::matrix_size1(a); #endif assert(traits::matrix_size2(a)==n); assert(traits::vector_size(w)==n); assert(traits::vector_size(w)==n); assert(!vr || traits::matrix_size1(*vr)==n); assert(!vl || traits::matrix_size1(*vl)==n); // preparation typedef typename A::value_type value_type; typedef typename V::value_type vec_value_type; typedef typename traits::type_traits::real_type real_type; // dispatch return detail::geev(typename boost::mpl::if_< boost::is_same, typename boost::mpl::if_< boost::is_same, detail::real_case, detail::mixed_case>::type, detail::complex_case>::type(), vl != 0 ? 'V' : 'N', vr != 0 ? 'V' : 'N', a, w, vl, vr); } } }}} #endif boost-bindings/boost/numeric/bindings/lapack/geqrf.hpp0000644000175000017500000001350310776016571023264 0ustar andreasandreas/* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEQRF_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GEQRF_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // QR factorization of a general m x n matrix A = Q * R // /////////////////////////////////////////////////////////////////// /* * geqrf() computes the QR factorization of a rectangular matrix * A = Q * R, where Q is a M x min(M,N) matrix with orthogonal * and normalized column (i.e. herm(Q) $ Q = I) and R is a * min(M,N) x N upper triangular matrix. * * On return of geqrf, the elements on and above the diagonal of * A contain the min(M,N) x N upper trapezoidal matrix R (R is * upper triangular if m >= n); the elements below the diagonal, * with the array TAU, represent the orthogonal matrix Q as a product * of min(M,N) elementary reflectors. */ namespace detail { inline void geqrf (int const m, int const n, float* a, int const lda, float* tau, float* work, int const lwork, int& info) { LAPACK_SGEQRF (&m, &n, a, &lda, tau, work, &lwork, &info); } inline void geqrf (int const m, int const n, double* a, int const lda, double* tau, double* work, int const lwork, int& info) { LAPACK_DGEQRF (&m, &n, a, &lda, tau, work, &lwork, &info); } inline void geqrf (int const m, int const n, traits::complex_f* a, int const lda, traits::complex_f* tau, traits::complex_f* work, int const lwork, int& info) { LAPACK_CGEQRF (&m, &n, traits::complex_ptr (a), &lda, traits::complex_ptr (tau), traits::complex_ptr (work), &lwork, &info ); } inline void geqrf (int const m, int const n, traits::complex_d* a, int const lda, traits::complex_d* tau, traits::complex_d* work, int const lwork, int& info) { LAPACK_ZGEQRF (&m, &n, traits::complex_ptr (a), &lda, traits::complex_ptr (tau), traits::complex_ptr (work), &lwork, &info ); } } template inline int geqrf (A& a, Tau& tau, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (std::min(m,n) <= traits::vector_size (tau)); assert (n <= traits::vector_size (work)); int info; detail::geqrf (m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (tau), traits::vector_storage (work), traits::vector_size (work), info); return info; } // Computation of the QR factorization. // Workspace is allocated dynamically so that the optimization of // blas 3 calls is optimal. template inline int geqrf (A& a, Tau& tau, optimal_workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); traits::detail::array work(std::max(1, n*32)); return geqrf( a, tau, work ); } // Computation of the QR factorization. // Workspace is allocated dynamically to its minimum size. // Blas 3 calls are not optimal. template inline int geqrf (A& a, Tau& tau, minimal_workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); traits::detail::array work(std::max(1, n)); return geqrf( a, tau, work ); } // Computation of the QR factorization. // Workspace is taken from the array in workspace. // The calling sequence is // geqrf( a, tau, workspace( work ) ) where work is an array with the same value_type // as a. template inline int geqrf (A& a, Tau& tau, detail::workspace1 workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); traits::detail::array work(std::max(1, n)); return geqrf( a, tau, workspace.w_ ); } // Function without workarray as argument template inline int geqrf (A& a, Tau& tau) { return geqrf( a, tau, optimal_workspace() ); } } }}} #endif boost-bindings/boost/numeric/bindings/lapack/gesdd.hpp0000644000175000017500000006133110776161006023242 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESDD_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GESDD_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // singular value decomposition // /////////////////////////////////////////////////////////////////// /* * (divide and conquer driver) * gesdd() computes the singular value decomposition (SVD) of * M-by-N matrix A, optionally computing the left and/or right * singular vectors, by using divide-and-conquer method. * The SVD is written * * A = U * S * V^T or A = U * S * V^H * * where S is an M-by-N matrix which is zero except for its min(m,n) * diagonal elements, U is an M-by-M orthogonal/unitary matrix, and V * is an N-by-N orthogonal/unitary matrix. The diagonal elements of S * are the singular values of A; they are real and non-negative, and * are returnede in descending order. The first min(m,n) columns of * U and V are the left and right singular vectors of A. (Note that * the routine returns V^T or V^H, not V. */ namespace detail { inline void gesdd (char const jobz, int const m, int const n, float* a, int const lda, float* s, float* u, int const ldu, float* vt, int const ldvt, float* work, int const lwork, float* /* dummy */, int* iwork, int* info) { LAPACK_SGESDD (&jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, iwork, info); } inline void gesdd (char const jobz, int const m, int const n, double* a, int const lda, double* s, double* u, int const ldu, double* vt, int const ldvt, double* work, int const lwork, double* /* dummy */, int* iwork, int* info) { LAPACK_DGESDD (&jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, iwork, info); } inline void gesdd (char const jobz, int const m, int const n, traits::complex_f* a, int const lda, float* s, traits::complex_f* u, int const ldu, traits::complex_f* vt, int const ldvt, traits::complex_f* work, int const lwork, float* rwork, int* iwork, int* info) { LAPACK_CGESDD (&jobz, &m, &n, traits::complex_ptr (a), &lda, s, traits::complex_ptr (u), &ldu, traits::complex_ptr (vt), &ldvt, traits::complex_ptr (work), &lwork, rwork, iwork, info); } inline void gesdd (char const jobz, int const m, int const n, traits::complex_d* a, int const lda, double* s, traits::complex_d* u, int const ldu, traits::complex_d* vt, int const ldvt, traits::complex_d* work, int const lwork, double* rwork, int* iwork, int* info) { LAPACK_ZGESDD (&jobz, &m, &n, traits::complex_ptr (a), &lda, s, traits::complex_ptr (u), &ldu, traits::complex_ptr (vt), &ldvt, traits::complex_ptr (work), &lwork, rwork, iwork, info); } inline int gesdd_min_work (float, char jobz, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m3 = 3 * minmn; int m4 = 4 * minmn; int minw; if (jobz == 'N') { // leading comments: // LWORK >= 3*min(M,N) + max(max(M,N), 6*min(M,N)) // code: // LWORK >= 3*min(M,N) + max(max(M,N), 7*min(M,N)) int m7 = 7 * minmn; minw = maxmn < m7 ? m7 : maxmn; minw += m3; } if (jobz == 'O') { // LWORK >= 3*min(M,N)*min(M,N) // + max(max(M,N), 5*min(M,N)*min(M,N)+4*min(M,N)) int m5 = 5 * minmn * minmn + m4; minw = maxmn < m5 ? m5 : maxmn; minw += m3 * minmn; } if (jobz == 'S' || jobz == 'A') { // LWORK >= 3*min(M,N)*min(M,N) // + max(max(M,N), 4*min(M,N)*min(M,N)+4*min(M,N)). int m44 = m4 * minmn + m4; minw = maxmn < m44 ? m44 : maxmn; minw += m3 * minmn; } return minw; } inline int gesdd_min_work (double, char jobz, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m3 = 3 * minmn; int m4 = 4 * minmn; int minw; if (jobz == 'N') { // leading comments: // LWORK >= 3*min(M,N) + max(max(M,N), 6*min(M,N)) // code: // LWORK >= 3*min(M,N) + max(max(M,N), 7*min(M,N)) int m7 = 7 * minmn; minw = maxmn < m7 ? m7 : maxmn; minw += m3; } else if (jobz == 'O') { // LWORK >= 3*min(M,N)*min(M,N) // + max(max(M,N), 5*min(M,N)*min(M,N)+4*min(M,N)) int m5 = 5 * minmn * minmn + m4; minw = maxmn < m5 ? m5 : maxmn; minw += m3 * minmn; } else if (jobz == 'S' || jobz == 'A') { // LWORK >= 3*min(M,N)*min(M,N) // + max(max(M,N), 4*min(M,N)*min(M,N)+4*min(M,N)). int m44 = m4 * minmn + m4; minw = maxmn < m44 ? m44 : maxmn; minw += m3 * minmn; } else { std::cerr << "Invalid option passed to gesdd" << std::endl ; return 0 ; } return minw; } inline int gesdd_min_work (traits::complex_f, char jobz, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m2 = 2 * minmn; int minw = m2 + maxmn; if (jobz == 'N') // LWORK >= 2*min(M,N)+max(M,N) ; if (jobz == 'O') // LWORK >= 2*min(M,N)*min(M,N) + 2*min(M,N) + max(M,N) minw += m2 * minmn; if (jobz == 'S' || jobz == 'A') // LWORK >= min(M,N)*min(M,N) + 2*min(M,N) + max(M,N) minw += minmn * minmn; return minw; } inline int gesdd_min_work (traits::complex_d, char jobz, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m2 = 2 * minmn; int minw = m2 + maxmn; if (jobz == 'N') // LWORK >= 2*min(M,N)+max(M,N) ; if (jobz == 'O') // LWORK >= 2*min(M,N)*min(M,N) + 2*min(M,N) + max(M,N) minw += m2 * minmn; if (jobz == 'S' || jobz == 'A') // LWORK >= min(M,N)*min(M,N) + 2*min(M,N) + max(M,N) minw += minmn * minmn; return minw; } inline int gesdd_rwork (float, char, int, int) { return 1; } inline int gesdd_rwork (double, char, int, int) { return 1; } inline int gesdd_rwork (traits::complex_f, char jobz, int m, int n) { int minmn = m < n ? m : n; int minw; if (jobz == 'N') // LWORK >= 7*min(M,N) minw = 7 * minmn; else // LRWORK >= 5*min(M,N)*min(M,N) + 5*min(M,N) minw = 5 * (minmn * minmn + minmn); return minw; } inline int gesdd_rwork (traits::complex_d, char jobz, int m, int n) { int minmn = m < n ? m : n; int minw; if (jobz == 'N') // LWORK >= 7*min(M,N) minw = 7 * minmn; else // LRWORK >= 5*min(M,N)*min(M,N) + 5*min(M,N) minw = 5 * (minmn * minmn + minmn); return minw; } inline int gesdd_iwork (int m, int n) { int minmn = m < n ? m : n; return 8 * minmn; } } // detail template inline int gesdd_work (char const q, char const jobz, MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif #ifdef BOOST_NUMERIC_BINDINGS_LAPACK_2 assert (q == 'M'); #else assert (q == 'M' || q == 'O'); #endif assert (jobz == 'N' || jobz == 'O' || jobz == 'A' || jobz == 'S'); int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int lw = -13; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif if (q == 'M') lw = detail::gesdd_min_work (val_t(), jobz, m, n); #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 MatrA& a2 = const_cast (a); if (q == 'O') { // traits::detail::array w (1); val_t w; int info; detail::gesdd (jobz, m, n, traits::matrix_storage (a2), traits::leading_dimension (a2), 0, // traits::vector_storage (s), 0, // traits::matrix_storage (u), m, // traits::leading_dimension (u), 0, // traits::matrix_storage (vt), n, // traits::leading_dimension (vt), &w, // traits::vector_storage (w), -1, // traits::vector_size (w), 0, // traits::vector_storage (rw), 0, // traits::vector_storage (iw), &info); assert (info == 0); lw = traits::detail::to_int (w); // // lw = traits::detail::to_int (w[0]); /* * is there a bug in LAPACK? or in Mandrake's .rpm? * if m == 3, n == 4 and jobz == 'N' (real A), * gesdd() returns optimal size == 1 while minimum size == 27 */ // int lwo = traits::detail::to_int (w); // int lwmin = detail::gesdd_min_work (val_t(), jobz, m, n); // lw = lwo < lwmin ? lwmin : lwo; } #endif return lw; } template inline int gesdd_rwork (char jobz, MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (jobz == 'N' || jobz == 'O' || jobz == 'A' || jobz == 'S'); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif return detail::gesdd_rwork (val_t(), jobz, traits::matrix_size1 (a), traits::matrix_size2 (a)); } template inline int gesdd_iwork (MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::gesdd_iwork (traits::matrix_size1 (a), traits::matrix_size2 (a)); } template inline int gesdd (char const jobz, MatrA& a, VecS& s, MatrU& u, MatrV& vt, VecW& w, VecIW& iw) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits::value_type, float >::value || boost::is_same< typename traits::matrix_traits::value_type, double >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert ((jobz == 'N') || ((jobz == 'O' || jobz == 'A') && m >= n) || ((jobz == 'O' || jobz == 'A') && m < n && m == traits::matrix_size2 (u)) || (jobz == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobz == 'N' && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (u) >= m) || (jobz == 'A' && traits::leading_dimension (u) >= m) || (jobz == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobz == 'N' && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (vt) >= n) || (jobz == 'A' && traits::leading_dimension (vt) >= n) || (jobz == 'S' && traits::leading_dimension (vt) >= minmn)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif assert (traits::vector_size (w) >= detail::gesdd_min_work (val_t(), jobz, m, n)); assert (traits::vector_size (iw) >= detail::gesdd_iwork (m, n)); int info; detail::gesdd (jobz, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), 0, // dummy argument traits::vector_storage (iw), &info); return info; } template inline int gesdd (char const jobz, MatrA& a, VecS& s, MatrU& u, MatrV& vt, VecW& w, VecRW& rw, VecIW& iw) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert ((jobz == 'N') || ((jobz == 'O' || jobz == 'A') && m >= n) || ((jobz == 'O' || jobz == 'A') && m < n && m == traits::matrix_size2 (u)) || (jobz == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobz == 'N' && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (u) >= m) || (jobz == 'A' && traits::leading_dimension (u) >= m) || (jobz == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobz == 'N' && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (vt) >= n) || (jobz == 'A' && traits::leading_dimension (vt) >= n) || (jobz == 'S' && traits::leading_dimension (vt) >= minmn)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif assert (traits::vector_size (w) >= detail::gesdd_min_work (val_t(), jobz, m, n)); assert (traits::vector_size (rw) >= detail::gesdd_rwork (val_t(), jobz, m, n)); assert (traits::vector_size (iw) >= detail::gesdd_iwork (m, n)); int info; detail::gesdd (jobz, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), traits::vector_storage (iw), &info); return info; } template inline int gesdd (char const opt, char const jobz, MatrA& a, VecS& s, MatrU& u, MatrV& vt) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); #ifndef NDEBUG int const minmn = m < n ? m : n; #endif // NDEBUG assert (minmn == traits::vector_size (s)); assert ((jobz == 'N') || ((jobz == 'O' || jobz == 'A') && m >= n) || ((jobz == 'O' || jobz == 'A') && m < n && m == traits::matrix_size2 (u)) || (jobz == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobz == 'N' && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (u) >= m) || (jobz == 'A' && traits::leading_dimension (u) >= m) || (jobz == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobz == 'N' && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (vt) >= n) || (jobz == 'A' && traits::leading_dimension (vt) >= n) || (jobz == 'S' && traits::leading_dimension (vt) >= minmn)); #ifdef BOOST_NUMERIC_BINDINGS_LAPACK_2 assert (opt == 'M'); #else assert (opt == 'M' || opt == 'O'); #endif #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; int const lw = gesdd_work (opt, jobz, a); traits::detail::array w (lw); if (!w.valid()) return -101; int const lrw = gesdd_rwork (jobz, a); traits::detail::array rw (lrw); if (!rw.valid()) return -102; int const liw = gesdd_iwork (a); traits::detail::array iw (liw); if (!iw.valid()) return -103; int info; detail::gesdd (jobz, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), lw, //traits::vector_size (w), traits::vector_storage (rw), traits::vector_storage (iw), &info); return info; } #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 template inline int gesdd (char const jobz, MatrA& a, VecS& s, MatrU& u, MatrV& vt) { return gesdd ('O', jobz, a, s, u, vt); } template inline int gesdd (MatrA& a, VecS& s, MatrU& u, MatrV& vt) { return gesdd ('O', 'S', a, s, u, vt); } template inline int gesdd (MatrA& a, VecS& s) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; int const lw = gesdd_work ('O', 'N', a); traits::detail::array w (lw); if (!w.valid()) return -101; int const lrw = gesdd_rwork ('N', a); traits::detail::array rw (lrw); if (!rw.valid()) return -102; int const liw = gesdd_iwork (a); traits::detail::array iw (liw); if (!iw.valid()) return -103; int info; detail::gesdd ('N', m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), 0, // traits::matrix_storage (u), 1, // traits::leading_dimension (u), 0, // traits::matrix_storage (vt), 1, // traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), traits::vector_storage (iw), &info); return info; } #endif } // namespace lapack }}} #endif boost-bindings/boost/numeric/bindings/lapack/gesv.hpp0000644000175000017500000002341710414673431023122 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GESV_HPP #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // general system of linear equations A * X = B // /////////////////////////////////////////////////////////////////// /* * gesv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS * matrices. * * The LU decomposition with partial pivoting and row interchanges * is used to factor A as A = P * L * U, where P is a permutation * matrix, L is unit lower triangular, and U is upper triangular. * The factored form of A is then used to solve the system of * equations A * X = B. */ namespace detail { inline void gesv (int const n, int const nrhs, float* a, int const lda, int* ipiv, float* b, int const ldb, int* info) { LAPACK_SGESV (&n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void gesv (int const n, int const nrhs, double* a, int const lda, int* ipiv, double* b, int const ldb, int* info) { LAPACK_DGESV (&n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void gesv (int const n, int const nrhs, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CGESV (&n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } inline void gesv (int const n, int const nrhs, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZGESV (&n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } } template inline int gesv (MatrA& a, IVec& ipiv, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (ipiv)); int info; detail::gesv (n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (ipiv), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } template inline int gesv (MatrA& a, MatrB& b) { // with 'internal' pivot vector // gesv() errors: // if (info == 0), successful // if (info < 0), the -info argument had an illegal value // -- we will use -101 if allocation fails // if (info > 0), U(i-1,i-1) is exactly zero int info = -101; traits::detail::array ipiv (traits::matrix_size1 (a)); if (ipiv.valid()) info = gesv (a, ipiv, b); return info; } /* * getrf() computes an LU factorization of a general M-by-N matrix A * using partial pivoting with row interchanges. The factorization * has the form A = P * L * U, where P is a permutation matrix, * L is lower triangular with unit diagonal elements (lower * trapezoidal if M > N), and U is upper triangular (upper * trapezoidal if M < N). */ namespace detail { inline void getrf (int const n, int const m, float* a, int const lda, int* ipiv, int* info) { LAPACK_SGETRF (&n, &m, a, &lda, ipiv, info); } inline void getrf (int const n, int const m, double* a, int const lda, int* ipiv, int* info) { LAPACK_DGETRF (&n, &m, a, &lda, ipiv, info); } inline void getrf (int const n, int const m, traits::complex_f* a, int const lda, int* ipiv, int* info) { LAPACK_CGETRF (&n, &m, traits::complex_ptr (a), &lda, ipiv, info); } inline void getrf (int const n, int const m, traits::complex_d* a, int const lda, int* ipiv, int* info) { LAPACK_ZGETRF (&n, &m, traits::complex_ptr (a), &lda, ipiv, info); } } template inline int getrf (MatrA& a, IVec& ipiv) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); int const m = traits::matrix_size2 (a); assert (traits::vector_size (ipiv) == (m < n ? m : n)); int info; detail::getrf (n, m, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (ipiv), &info); return info; } /* * getrs() solves a system of linear equations A * X = B * or A^T * X = B with a general N-by-N matrix A using * the LU factorization computed by getrf(). */ namespace detail { inline void getrs (char const trans, int const n, int const nrhs, float const* a, int const lda, int const* ipiv, float* b, int const ldb, int* info) { LAPACK_SGETRS (&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void getrs (char const trans, int const n, int const nrhs, double const* a, int const lda, int const* ipiv, double* b, int const ldb, int* info) { LAPACK_DGETRS (&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void getrs (char const trans, int const n, int const nrhs, traits::complex_f const* a, int const lda, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CGETRS (&trans, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } inline void getrs (char const trans, int const n, int const nrhs, traits::complex_d const* a, int const lda, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZGETRS (&trans, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } } template inline int getrs (char const trans, MatrA const& a, IVec const& ipiv, MatrB& b) { assert (trans == 'N' || trans == 'T' || trans == 'C'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (ipiv)); int info; detail::getrs (trans, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (ipiv), #else traits::vector_storage_const (ipiv), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } template inline int getrs (MatrA const& a, IVec const& ipiv, MatrB& b) { char const no_transpose = 'N'; return getrs (no_transpose, a, ipiv, b); } // TO DO: getri() } }}} #endif boost-bindings/boost/numeric/bindings/lapack/gesvd.hpp0000644000175000017500000004573110776161006023272 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESVD_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GESVD_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // singular value decomposition // /////////////////////////////////////////////////////////////////// /* * (simple driver) * gesvd() computes the singular value decomposition (SVD) of * M-by-N matrix A, optionally computing the left and/or right * singular vectors. The SVD is written * * A = U * S * V^T or A = U * S * V^H * * where S is an M-by-N matrix which is zero except for its min(m,n) * diagonal elements, U is an M-by-M orthogonal/unitary matrix, and V * is an N-by-N orthogonal/unitary matrix. The diagonal elements of S * are the singular values of A; they are real and non-negative, and * are returnede in descending order. The first min(m,n) columns of * U and V are the left and right singular vectors of A. (Note that * the routine returns V^T or V^H, not V. */ namespace detail { inline void gesvd (char const jobu, char const jobvt, int const m, int const n, float* a, int const lda, float* s, float* u, int const ldu, float* vt, int const ldvt, float* work, int const lwork, float* /* dummy */, int* info) { LAPACK_SGESVD (&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, info); } inline void gesvd (char const jobu, char const jobvt, int const m, int const n, double* a, int const lda, double* s, double* u, int const ldu, double* vt, int const ldvt, double* work, int const lwork, double* /* dummy */, int* info) { LAPACK_DGESVD (&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, info); } inline void gesvd (char const jobu, char const jobvt, int const m, int const n, traits::complex_f* a, int const lda, float* s, traits::complex_f* u, int const ldu, traits::complex_f* vt, int const ldvt, traits::complex_f* work, int const lwork, float* rwork, int* info) { LAPACK_CGESVD (&jobu, &jobvt, &m, &n, traits::complex_ptr (a), &lda, s, traits::complex_ptr (u), &ldu, traits::complex_ptr (vt), &ldvt, traits::complex_ptr (work), &lwork, rwork, info); } inline void gesvd (char const jobu, char const jobvt, int const m, int const n, traits::complex_d* a, int const lda, double* s, traits::complex_d* u, int const ldu, traits::complex_d* vt, int const ldvt, traits::complex_d* work, int const lwork, double* rwork, int* info) { LAPACK_ZGESVD (&jobu, &jobvt, &m, &n, traits::complex_ptr (a), &lda, s, traits::complex_ptr (u), &ldu, traits::complex_ptr (vt), &ldvt, traits::complex_ptr (work), &lwork, rwork, info); } inline int gesvd_min_work (float, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m3x = 3 * minmn + maxmn; int m5 = 5 * minmn; return m3x < m5 ? m5 : m3x; } inline int gesvd_min_work (double, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m3x = 3 * minmn + maxmn; int m5 = 5 * minmn; return m3x < m5 ? m5 : m3x; } inline int gesvd_min_work (traits::complex_f, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; return 2 * minmn + maxmn; } inline int gesvd_min_work (traits::complex_d, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; return 2 * minmn + maxmn; } inline int gesvd_rwork (float, int, int) { return 1; } inline int gesvd_rwork (double, int, int) { return 1; } inline int gesvd_rwork (traits::complex_f, int m, int n) { return 5 * (m < n ? m : n); } inline int gesvd_rwork (traits::complex_d, int m, int n) { return 5 * (m < n ? m : n); } } // detail template inline int gesvd_work (char const q, char const jobu, char const jobvt, MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif #ifdef BOOST_NUMERIC_BINDINGS_LAPACK_2 assert (q == 'M'); #else assert (q == 'M' || q == 'O'); #endif assert (jobu == 'N' || jobu == 'O' || jobu == 'A' || jobu == 'S'); assert (jobvt == 'N' || jobvt == 'O' || jobvt == 'A' || jobvt == 'S'); assert (!(jobu == 'O' && jobvt == 'O')); int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int lw = -13; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif if (q == 'M') lw = detail::gesvd_min_work (val_t(), m, n); #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 MatrA& a2 = const_cast (a); if (q == 'O') { // traits::detail::array w (0); val_t w; int info; detail::gesvd (jobu, jobvt, m, n, traits::matrix_storage (a2), traits::leading_dimension (a2), 0, // traits::vector_storage (s), 0, // traits::matrix_storage (u), m, // traits::leading_dimension (u), 0, // traits::matrix_storage (vt), n, // traits::leading_dimension (vt), &w, // traits::vector_storage (w), -1, // traits::vector_size (w), 0, // traits::vector_storage (rw), &info); assert (info == 0); lw = traits::detail::to_int (w); // (w[0]); } #endif return lw; } template inline int gesvd_rwork (MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif return detail::gesvd_rwork (val_t(), traits::matrix_size1 (a), traits::matrix_size2 (a)); } template inline int gesvd (char const jobu, char const jobvt, MatrA& a, VecS& s, MatrU& u, MatrV& vt, VecW& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits::value_type, float >::value || boost::is_same< typename traits::matrix_traits::value_type, double >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); assert ((jobu == 'N') || (jobu == 'O') || (jobu == 'A' && m == traits::matrix_size2 (u)) || (jobu == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobu == 'N' && traits::leading_dimension (u) >= 1) || (jobu == 'O' && traits::leading_dimension (u) >= 1) || (jobu == 'A' && traits::leading_dimension (u) >= m) || (jobu == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobvt == 'N' && traits::leading_dimension (vt) >= 1) || (jobvt == 'O' && traits::leading_dimension (vt) >= 1) || (jobvt == 'A' && traits::leading_dimension (vt) >= n) || (jobvt == 'S' && traits::leading_dimension (vt) >= minmn)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif assert (traits::vector_size(w) >= detail::gesvd_min_work(val_t(),m,n)); int info; detail::gesvd (jobu, jobvt, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), 0, // dummy argument &info); return info; } template inline int gesvd (char const jobu, char const jobvt, MatrA& a, VecS& s, MatrU& u, MatrV& vt, VecW& w, VecRW& rw) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); assert ((jobu == 'N') || (jobu == 'O') || (jobu == 'A' && m == traits::matrix_size2 (u)) || (jobu == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobu == 'N' && traits::leading_dimension (u) >= 1) || (jobu == 'O' && traits::leading_dimension (u) >= 1) || (jobu == 'A' && traits::leading_dimension (u) >= m) || (jobu == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobvt == 'N' && traits::leading_dimension (vt) >= 1) || (jobvt == 'O' && traits::leading_dimension (vt) >= 1) || (jobvt == 'A' && traits::leading_dimension (vt) >= n) || (jobvt == 'S' && traits::leading_dimension (vt) >= minmn)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif assert (traits::vector_size(w) >= detail::gesvd_min_work(val_t(),m,n)); assert (traits::vector_size(rw) >= detail::gesvd_rwork(val_t(),m,n)); int info; detail::gesvd (jobu, jobvt, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), &info); return info; } template inline int gesvd (char const opt, char const jobu, char const jobvt, MatrA& a, VecS& s, MatrU& u, MatrV& vt) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); assert ((jobu == 'N') || (jobu == 'O') || (jobu == 'A' && m == traits::matrix_size2 (u)) || (jobu == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobu == 'N' && traits::leading_dimension (u) >= 1) || (jobu == 'O' && traits::leading_dimension (u) >= 1) || (jobu == 'A' && traits::leading_dimension (u) >= m) || (jobu == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobvt == 'N' && traits::leading_dimension (vt) >= 1) || (jobvt == 'O' && traits::leading_dimension (vt) >= 1) || (jobvt == 'A' && traits::leading_dimension (vt) >= n) || (jobvt == 'S' && traits::leading_dimension (vt) >= minmn)); #ifdef BOOST_NUMERIC_BINDINGS_LAPACK_2 assert (opt == 'M'); #else assert (opt == 'M' || opt == 'O'); #endif #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; int const lw = gesvd_work (opt, jobu, jobvt, a); traits::detail::array w (lw); if (!w.valid()) return -101; int const lrw = gesvd_rwork (a); traits::detail::array rw (lrw); if (!rw.valid()) return -102; int info; detail::gesvd (jobu, jobvt, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), &info); return info; } #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 template inline int gesvd (char const jobu, char const jobvt, MatrA& a, VecS& s, MatrU& u, MatrV& vt) { return gesvd ('O', jobu, jobvt, a, s, u, vt); } template inline int gesvd (MatrA& a, VecS& s, MatrU& u, MatrV& vt) { return gesvd ('O', 'S', 'S', a, s, u, vt); } template inline int gesvd (MatrA& a, VecS& s) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; int const lw = gesvd_work ('O', 'N', 'N', a); traits::detail::array w (lw); if (!w.valid()) return -101; int const lrw = gesvd_rwork (a); traits::detail::array rw (lrw); if (!rw.valid()) return -102; int info; detail::gesvd ('N', 'N', m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), 0, // traits::matrix_storage (u), 1, // traits::leading_dimension (u), 0, // traits::matrix_storage (vt), 1, // traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), &info); return info; } #endif } // namespace lapack }}} #endif boost-bindings/boost/numeric/bindings/lapack/hbev.hpp0000644000175000017500000002713007752726113023105 0ustar andreasandreas/* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBEV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_HBEV_HPP #include #include #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Eigendecomposition of a banded Hermitian matrix. // /////////////////////////////////////////////////////////////////// /* * hbev() computes the eigenvalues and optionally the associated * eigenvectors of a banded Hermitian matrix A. A matrix is Hermitian * when herm( A ) == A. When A is real, a Hermitian matrix is also * called symmetric. * * The eigen decomposition is A = U S * herm(U) where U is a * unitary matrix and S is a diagonal matrix. The eigenvalues of A * are on the main diagonal of S. The eigenvalues are real. * * Workspace is organized following the arguments in the calling sequence. * optimal_workspace() : for optimizing use of blas 3 kernels * minimal_workspace() : minimum size of workarrays, but does not allow for optimization * of blas 3 kernels * workspace( work ) for real matrices where work is a real array with * vector_size( work ) >= 3*matrix_size1( a ) - 2 * workspace( work, rwork ) for complex matrices where work is a complex * array with vector_size( work ) >= matrix_size1( a ) * and rwork is a real array with * vector_size( rwork ) >= 3 * matrix_size1( a ) - 2. */ /* * If uplo=='L' only the lower triangular part is stored. * If uplo=='U' only the upper triangular part is stored. * * The matrix is assumed to be stored in LAPACK band format, i.e. * matrices are stored columnwise, in a compressed format so that when e.g. uplo=='U' * the (i,j) element with j>=i is in position (i-j) + j * (KD+1) + KD where KD is the * half bandwidth of the matrix. For a triadiagonal matrix, KD=1, for a diagonal matrix * KD=0. * When uplo=='L', the (i,j) element with j>=i is in position (i-j) + j * (KD+1). * * The matrix A is thus a rectangular matrix with KD+1 rows and N columns. */ namespace detail { inline void hbev (char const jobz, char const uplo, int const n, int const kd, float* ab, int const ldab, float* w, float* z, int const ldz, float* work, int& info) { //for (int i=0; i struct Hbev{}; /// Handling of workspace in the case of one workarray. template <> struct Hbev< 1 > { template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, minimal_workspace , int& info ) const { traits::detail::array work( 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work ), info ); } template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, optimal_workspace , int& info ) const { traits::detail::array work( 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work ), info ); } template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, detail::workspace1 work, int& info ) const { assert( traits::vector_size( work.w_ ) >= 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work.w_ ), info ); } }; // Hbev< 1 > /// Handling of workspace in the case of two workarrays. template <> struct Hbev< 2 > { template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, minimal_workspace , int& info ) const { traits::detail::array work( n ); traits::detail::array rwork( 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work ), traits::vector_storage( rwork ), info ); } template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, optimal_workspace , int& info ) const { traits::detail::array work( n ); traits::detail::array rwork( 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work ), traits::vector_storage( rwork ), info ); } template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, detail::workspace2 work, int& info ) const { assert( traits::vector_size( work.wr_ ) >= 3*n-2 ); assert( traits::vector_size( work.w_ ) >= n ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work.w_ ), traits::vector_storage( work.wr_ ), info ); } }; // Hbev< 2 > /// Compute eigendecomposition of the banded Hermitian matrix ab. /// if jobz=='N' only the eigenvalues are computed. /// if jobz=='V' compute the eigenvalues a and the eigenvectors. /// /// Workspace is organized following the arguments in the calling sequence. /// optimal_workspace() : for optimizing use of blas 3 kernels /// minimal_workspace() : minimum size of workarrays, but does not allow for optimization /// of blas 3 kernels /// workspace( work ) for real matrices where work is a real array with /// vector_size( work ) >= 3*matrix_size1( a )-2 /// workspace( work, rwork ) for complex matrices where work is a complex /// array with vector_size( work ) >= matrix_size1( a ) /// and rwork is a real array with /// vector_size( rwork ) >= 3*matrix_size1( a )-2. template int hbev( char const jobz, AB& ab, W& w, Z& z, Work work ) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif typedef typename AB::value_type value_type ; int const n = traits::matrix_size2 (ab); assert (n == traits::matrix_size1 (z)); assert (n == traits::vector_size (w)); assert ( jobz=='N' || jobz=='V' ); int info ; detail::Hbev< n_workspace_args::value >() (jobz, traits::matrix_uplo_tag( ab ), n, traits::matrix_upper_bandwidth(ab), traits::matrix_storage (ab), traits::leading_dimension (ab), traits::vector_storage (w), traits::matrix_storage (z), traits::leading_dimension (z), work, info); return info ; } // hbev() } // namespace detail /// Compute eigendecomposition without eigenvectors template inline int hbev (AB& ab, W& w, Work work) { return detail::hbev( 'N', ab, w, ab, work ); } // hbev() /// Compute eigendecomposition with eigenvectors template inline int hbev (AB& ab, W& w, Z& z, Work work) { BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); int const n = traits::matrix_size2 (ab); assert (n == traits::matrix_size1 (z)); assert (n == traits::matrix_size2 (z)); return detail::hbev( 'V', ab, w, z, work ); } // hbev() } }}} #endif boost-bindings/boost/numeric/bindings/lapack/heev.hpp0000644000175000017500000001322410040710666023075 0ustar andreasandreas/* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEEV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_HEEV_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Eigendecomposition of a complex Hermitian matrix A = Q * D * Q' // /////////////////////////////////////////////////////////////////// /* * heev() computes the eigendecomposition of a N x N matrix * A = Q * D * Q', where Q is a N x N unitary matrix and * D is a diagonal matrix. The diagonal element D(i,i) is an * eigenvalue of A and Q(:,i) is a corresponding eigenvector. * The eigenvalues are stored in ascending order. * * On return of heev, A is overwritten by Q and w contains the main * diagonal of D. * * int heev (char jobz, char uplo, A& a, W& w, minimal_workspace ) ; * jobz : 'V' : compute eigenvectors * 'N' : do not compute eigenvectors * uplo : 'U' : only the upper triangular part of A is used on input. * 'L' : only the lower triangular part of A is used on input. */ namespace detail { inline void heev (char const jobz, char const uplo, int const n, traits::complex_f* a, int const lda, float* w, traits::complex_f* work, int const lwork, float* rwork, int& info) { LAPACK_CHEEV (&jobz, &uplo, &n, reinterpret_cast(a), &lda, w, reinterpret_cast(work), &lwork, rwork, &info); } inline void heev (char const jobz, char const uplo, int const n, traits::complex_d* a, int const lda, double* w, traits::complex_d* work, int const lwork, double* rwork, int& info) { LAPACK_ZHEEV (&jobz, &uplo, &n, reinterpret_cast(a), &lda, w, reinterpret_cast(work), &lwork, rwork, &info); } template inline int heev (char jobz, char uplo, A& a, W& w, Work& work, RWork& rwork) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (traits::matrix_size2 (a)==n); assert (traits::vector_size (w)==n); assert (2*n-1 <= traits::vector_size (work)); assert (3*n-2 <= traits::vector_size (rwork)); assert ( uplo=='U' || uplo=='L' ); assert ( jobz=='N' || jobz=='V' ); int info; detail::heev (jobz, uplo, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (w), traits::vector_storage (work), traits::vector_size (work), traits::vector_storage (rwork), info); return info; } } // namespace detail // Function that allocates temporary arrays template int heev (char jobz, char uplo, A& a, W& w, minimal_workspace ) { typedef typename A::value_type value_type ; typedef typename traits::type_traits::real_type real_type ; int const n = traits::matrix_size1 (a); traits::detail::array work( std::max(1,2*n-1) ); traits::detail::array rwork( std::max(3*n-1,1) ); return detail::heev( jobz, uplo, a, w, work, rwork ); } // Function that allocates temporary arrays template int heev (char jobz, char uplo, A& a, W& w, optimal_workspace ) { typedef typename A::value_type value_type ; typedef typename traits::type_traits::real_type real_type ; int const n = traits::matrix_size1 (a); traits::detail::array work( std::max(1,33*n) ); traits::detail::array rwork( std::max(3*n-1,1) ); return detail::heev( jobz, uplo, a, w, work, rwork ); } // Function that uses given workarrays template int heev (char jobz, char uplo, A& a, W& w, detail::workspace2 workspace ) { typedef typename A::value_type value_type ; typedef typename traits::type_traits::real_type real_type ; return detail::heev( jobz, uplo, a, w, workspace.w_, workspace.wr_ ); } } }}} #endif boost-bindings/boost/numeric/bindings/lapack/hesv.hpp0000644000175000017500000004521210603223732023113 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HESV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_HESV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A Hermitian indefinite matrix // ///////////////////////////////////////////////////////////////////// namespace detail { inline int hetrf_block (traits::complex_f, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "CHETRF", ul2, n); } inline int hetrf_block (traits::complex_d, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "ZHETRF", ul2, n); } } template inline int hetrf_block (char const q, char const ul, HermA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (q == 'O' || q == 'M'); assert (ul == 'U' || ul == 'L'); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif int ispec = (q == 'O' ? 1 : 2); return detail::hetrf_block (val_t(), ispec, ul, n); } template inline int hetrf_block (char const q, HermA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif assert (q == 'O' || q == 'M'); char ul = traits::matrix_uplo_tag (a); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif int ispec = (q == 'O' ? 1 : 2); return detail::hetrf_block (val_t(), ispec, ul, n); } template inline int hetrf_work (char const q, char const ul, HermA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (q == 'O' || q == 'M'); assert (ul == 'U' || ul == 'L'); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif int lw = -13; if (q == 'M') lw = 1; if (q == 'O') lw = n * detail::hetrf_block (val_t(), 1, ul, n); return lw; } template inline int hetrf_work (char const q, HermA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif assert (q == 'O' || q == 'M'); char ul = traits::matrix_uplo_tag (a); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif int lw = -13; if (q == 'M') lw = 1; if (q == 'O') lw = n * detail::hetrf_block (val_t(), 1, ul, n); return lw; } template inline int hesv_work (char const q, char const ul, HermA const& a) { return hetrf_work (q, ul, a); } template inline int hesv_work (char const q, HermA const& a) { return hetrf_work (q, a); } /* * hesv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N Hermitian matrix and X and B * are N-by-NRHS matrices. * * The diagonal pivoting method is used to factor A as * A = U * D * U^H, if UPLO = 'U', * A = L * D * L^H, if UPLO = 'L', * where U (or L) is a product of permutation and unit upper * (lower) triangular matrices, and D is Hermitian and block * diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored * form of A is then used to solve the system of equations A * X = B. */ namespace detail { inline void hesv (char const uplo, int const n, int const nrhs, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* b, int const ldb, traits::complex_f* w, int const lw, int* info) { LAPACK_CHESV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, traits::complex_ptr (w), &lw, info); } inline void hesv (char const uplo, int const n, int const nrhs, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* b, int const ldb, traits::complex_d* w, int const lw, int* info) { LAPACK_ZHESV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, traits::complex_ptr (w), &lw, info); } template inline int hesv (char const ul, HermA& a, IVec& i, MatrB& b, Work& w) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); int info; hesv (ul, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (i), traits::matrix_storage (b), traits::leading_dimension (b), traits::vector_storage (w), traits::vector_size (w), &info); return info; } } template inline int hesv (char const ul, HermA& a, IVec& i, MatrB& b, Work& w) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const lw = traits::vector_size (w); assert (lw >= 1); return detail::hesv (ul, a, i, b, w); } template inline int hesv (HermA& a, IVec& i, MatrB& b, Work& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const lw = traits::vector_size (w); assert (lw >= 1); char uplo = traits::matrix_uplo_tag (a); return detail::hesv (uplo, a, i, b, w); } template inline int hesv (char const ul, HermA& a, MatrB& b) { // with 'internal' pivot and work vectors assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); int info = -101; traits::detail::array i (n); if (i.valid()) { info = -102; int lw = hetrf_work ('O', ul, a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::hesv (ul, a, i, b, w); } return info; } template inline int hesv (HermA& a, MatrB& b) { // with 'internal' pivot and work vectors #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); char uplo = traits::matrix_uplo_tag (a); int info = -101; traits::detail::array i (n); if (i.valid()) { info = -102; int lw = hetrf_work ('O', a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif traits::detail::array w (lw); w.resize (lw); if (w.valid()) info = detail::hesv (uplo, a, i, b, w); } return info; } /* * hetrf() computes the factorization of a Hermitian matrix A using * the Bunch-Kaufman diagonal pivoting method. The form of the * factorization is * A = U * D * U^H or A = L * D * L^H * where U (or L) is a product of permutation and unit upper (lower) * triangular matrices, and D is Hermitian and block diagonal with * 1-by-1 and 2-by-2 diagonal blocks. */ namespace detail { inline void hetrf (char const uplo, int const n, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* w, int const lw, int* info) { LAPACK_CHETRF (&uplo, &n, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (w), &lw, info); } inline void hetrf (char const uplo, int const n, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* w, int const lw, int* info) { LAPACK_ZHETRF (&uplo, &n, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (w), &lw, info); } template inline int hetrf (char const ul, HermA& a, IVec& i, Work& w) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::vector_size (i)); int info; hetrf (ul, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (i), traits::vector_storage (w), traits::vector_size (w), &info); return info; } } template inline int hetrf (char const ul, HermA& a, IVec& i, Work& w) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const lw = traits::vector_size (w); assert (lw >= 1); return detail::hetrf (ul, a, i, w); } template inline int hetrf (HermA& a, IVec& i, Work& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const lw = traits::vector_size (w); assert (lw >= 1); char uplo = traits::matrix_uplo_tag (a); return detail::hetrf (uplo, a, i, w); } template inline int hetrf (char const ul, HermA& a, Ivec& i) { // with 'internal' work vector assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int info = -101; int lw = hetrf_work ('O', ul, a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::hetrf (ul, a, i, w); return info; } template inline int hetrf (HermA& a, Ivec& i) { // with 'internal' work vector #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); int info = -101; int lw = hetrf_work ('O', a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::hetrf (uplo, a, i, w); return info; } /* * hetrs() solves a system of linear equations A*X = B with * a Hermitian matrix A using the factorization * A = U * D * U^H or A = L * D * L^H * computed by hetrf(). */ namespace detail { inline void hetrs (char const uplo, int const n, int const nrhs, traits::complex_f const* a, int const lda, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CHETRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } inline void hetrs (char const uplo, int const n, int const nrhs, traits::complex_d const* a, int const lda, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZHETRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } template inline int hetrs (char const ul, HermA const& a, IVec const& i, MatrB& b) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); int info; hetrs (ul, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (i), #else traits::vector_storage_const (i), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int hetrs (char const ul, HermA const& a, IVec const& i, MatrB& b) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::hetrs (ul, a, i, b); } template inline int hetrs (HermA const& a, IVec const& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::hetrs (uplo, a, i, b); } // TO DO: hetri } }}} #endif boost-bindings/boost/numeric/bindings/lapack/hpsv.hpp0000644000175000017500000002030610776161006023131 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_HPSV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A Hermitian indefinite matrix stored in packed format // ///////////////////////////////////////////////////////////////////// /* * hpsv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N Hermitian matrix in packed * storage and X and B are N-by-NRHS matrices. * * The diagonal pivoting method is used to factor A as * A = U * D * U^H, if UPLO = 'U', * A = L * D * L^H, if UPLO = 'L', * where U (or L) is a product of permutation and unit upper * (lower) triangular matrices, and D is Hermitian and block * diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored * form of A is then used to solve the system of equations A * X = B. */ namespace detail { inline void hpsv (char const uplo, int const n, int const nrhs, traits::complex_f* ap, int* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CHPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } inline void hpsv (char const uplo, int const n, int const nrhs, traits::complex_d* ap, int* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZHPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } template inline int hpsv (HermA& a, IVec& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); char uplo = traits::matrix_uplo_tag (a); int info; hpsv (uplo, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::vector_storage (i), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int hpsv (HermA& a, IVec& i, MatrB& b) { assert (traits::matrix_size1 (a) == traits::vector_size (i)); return detail::hpsv (a, i, b); } template inline int hpsv (HermA& a, MatrB& b) { // with 'internal' pivot vector int info = -101; traits::detail::array i (traits::matrix_size1 (a)); if (i.valid()) info = detail::hpsv (a, i, b); return info; } /* * hptrf() computes the factorization of a Hermitian matrix A * in packed storage using the Bunch-Kaufman diagonal pivoting * method. The form of the factorization is * A = U * D * U^H or A = L * D * L^H * where U (or L) is a product of permutation and unit upper (lower) * triangular matrices, and D is Hermitian and block diagonal with * 1-by-1 and 2-by-2 diagonal blocks. */ namespace detail { inline void hptrf (char const uplo, int const n, traits::complex_f* ap, int* ipiv, int* info) { LAPACK_CHPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info); } inline void hptrf (char const uplo, int const n, traits::complex_d* ap, int* ipiv, int* info) { LAPACK_ZHPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info); } template inline int hptrf (char const ul, HermA& a, IVec& i, Work& w, int const lw) { } } template inline int hptrf (HermA& a, IVec& i) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::vector_size (i)); char uplo = traits::matrix_uplo_tag (a); int info; detail::hptrf (uplo, n, traits::matrix_storage (a), traits::vector_storage (i), &info); return info; } /* * hptrs() solves a system of linear equations A*X = B with * a Hermitian matrix A in packed storage using the factorization * A = U * D * U^H or A = L * D * L^H * computed by hptrf(). */ namespace detail { inline void hptrs (char const uplo, int const n, int const nrhs, traits::complex_f const* ap, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CHPTRS (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } inline void hptrs (char const uplo, int const n, int const nrhs, traits::complex_d const* ap, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZHPTRS (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } } template inline int hptrs (HermA const& a, IVec const& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); char uplo = traits::matrix_uplo_tag (a); int info; detail::hptrs (uplo, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), traits::vector_storage (i), #else traits::matrix_storage_const (a), traits::vector_storage_const (i), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } // TO DO: hptri } }}} #endif boost-bindings/boost/numeric/bindings/lapack/ilaenv.hpp0000644000175000017500000000240610037760525023431 0ustar andreasandreas/* * * Copyright (c) Toon Knapen, Kresimir Fresl and Matthias Troyer 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ILAENV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_ILAENV_HPP #include #include namespace boost { namespace numeric { namespace bindings { namespace lapack { /* * ilaenv() is called from the LAPACK routines to choose * problem-dependent parameters such as the block sizes * for the local environment. */ inline int ilaenv (int const ispec, const char* name, const char* opts, int const n1 = -1, int const n2 = -1, int const n3 = -1, int const n4 = -1) { return ::LAPACK_ILAENV (&ispec, name, opts, &n1, &n2, &n3, &n4, std::strlen (name), std::strlen (opts)); } }}}} #endif boost-bindings/boost/numeric/bindings/lapack/lapack.h0000644000175000017500000007271610776015706023065 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_H #define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_H #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # define BOOST_NUMERIC_BINDINGS_FORTRAN #endif extern "C" { /********************************************************************/ /* linear systems */ /********************************************************************/ /* general */ void LAPACK_SGESV (int const* n, int const* nrhs, float* a, int const* lda, int* ipiv, float* b, int const* ldb, int* info); void LAPACK_DGESV (int const* n, int const* nrhs, double* a, int const* lda, int* ipiv, double* b, int const* ldb, int* info); void LAPACK_CGESV (int const* n, int const* nrhs, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZGESV (int const* n, int const* nrhs, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_SGETRF (int const* n, int const* nrhs, float* a, int const* lda, int* ipiv, int* info); void LAPACK_DGETRF (int const* n, int const* nrhs, double* a, int const* lda, int* ipiv, int* info); void LAPACK_CGETRF (int const* n, int const* nrhs, fcomplex_t* a, int const* lda, int* ipiv, int* info); void LAPACK_ZGETRF (int const* n, int const* nrhs, dcomplex_t* a, int const* lda, int* ipiv, int* info); void LAPACK_SGETRS (char const* trans, int const* n, int const* nrhs, float const* a, int const* lda, int const* ipiv, float* b, int const* ldb, int* info); void LAPACK_DGETRS (char const* trans, int const* n, int const* nrhs, double const* a, int const* lda, int const* ipiv, double* b, int const* ldb, int* info); void LAPACK_CGETRS (char const* trans, int const* n, int const* nrhs, fcomplex_t const* a, int const* lda, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZGETRS (char const* trans, int const* n, int const* nrhs, dcomplex_t const* a, int const* lda, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); /* symmetric/Hermitian positive definite */ void LAPACK_SPOSV (char const* uplo, int const* n, int const* nrhs, float* a, int const* lda, float* b, int const* ldb, int* info); void LAPACK_DPOSV (char const* uplo, int const* n, int const* nrhs, double* a, int const* lda, double* b, int const* ldb, int* info); void LAPACK_CPOSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* a, int const* lda, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZPOSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* a, int const* lda, dcomplex_t* b, int const* ldb, int* info); void LAPACK_SPOTRF (char const* uplo, int const* n, float* a, int const* lda, int* info); void LAPACK_DPOTRF (char const* uplo, int const* n, double* a, int const* lda, int* info); void LAPACK_CPOTRF (char const* uplo, int const* n, fcomplex_t* a, int const* lda, int* info); void LAPACK_ZPOTRF (char const* uplo, int const* n, dcomplex_t* a, int const* lda, int* info); void LAPACK_SPOTRS (char const* uplo, int const* n, int const* nrhs, float const* a, int const* lda, float* b, int const* ldb, int* info); void LAPACK_DPOTRS (char const* uplo, int const* n, int const* nrhs, double const* a, int const* lda, double* b, int const* ldb, int* info); void LAPACK_CPOTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* a, int const* lda, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZPOTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* a, int const* lda, dcomplex_t* b, int const* ldb, int* info); /* symmetric/Hermitian positive definite in packed storage */ void LAPACK_SPPSV (char const* uplo, int const* n, int const* nrhs, float* ap, float* b, int const* ldb, int* info); void LAPACK_DPPSV (char const* uplo, int const* n, int const* nrhs, double* ap, double* b, int const* ldb, int* info); void LAPACK_CPPSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* ap, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZPPSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* ap, dcomplex_t* b, int const* ldb, int* info); void LAPACK_SPPTRF (char const* uplo, int const* n, float* ap, int* info); void LAPACK_DPPTRF (char const* uplo, int const* n, double* ap, int* info); void LAPACK_CPPTRF (char const* uplo, int const* n, fcomplex_t* ap, int* info); void LAPACK_ZPPTRF (char const* uplo, int const* n, dcomplex_t* ap, int* info); void LAPACK_SPPTRS (char const* uplo, int const* n, int const* nrhs, float const* ap, float* b, int const* ldb, int* info); void LAPACK_DPPTRS (char const* uplo, int const* n, int const* nrhs, double const* ap, double* b, int const* ldb, int* info); void LAPACK_CPPTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* ap, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZPPTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* ap, dcomplex_t* b, int const* ldb, int* info); /* symmetric/Hermitian indefinite and complex symmetric */ void LAPACK_SSYSV (char const* uplo, int const* n, int const* nrhs, float* a, int const* lda, int* ipiv, float* b, int const* ldb, float* w, int const* lw, int* info); void LAPACK_DSYSV (char const* uplo, int const* n, int const* nrhs, double* a, int const* lda, int* ipiv, double* b, int const* ldb, double* w, int const* lw, int* info); void LAPACK_CSYSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* b, int const* ldb, fcomplex_t* w, int const* lw, int* info); void LAPACK_ZSYSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* b, int const* ldb, dcomplex_t* w, int const* lw, int* info); void LAPACK_CHESV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* b, int const* ldb, fcomplex_t* w, int const* lw, int* info); void LAPACK_ZHESV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* b, int const* ldb, dcomplex_t* w, int const* lw, int* info); void LAPACK_SSYTRF (char const* uplo, int const* n, float* a, int const* lda, int* ipiv, float* w, int const* lw, int* info); void LAPACK_DSYTRF (char const* uplo, int const* n, double* a, int const* lda, int* ipiv, double* w, int const* lw, int* info); void LAPACK_CSYTRF (char const* uplo, int const* n, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* w, int const* lw, int* info); void LAPACK_ZSYTRF (char const* uplo, int const* n, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* w, int const* lw, int* info); void LAPACK_CHETRF (char const* uplo, int const* n, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* w, int const* lw, int* info); void LAPACK_ZHETRF (char const* uplo, int const* n, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* w, int const* lw, int* info); void LAPACK_SSYTRS (char const* uplo, int const* n, int const* nrhs, float const* a, int const* lda, int const* ipiv, float* b, int const* ldb, int* info); void LAPACK_DSYTRS (char const* uplo, int const* n, int const* nrhs, double const* a, int const* lda, int const* ipiv, double* b, int const* ldb, int* info); void LAPACK_CSYTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* a, int const* lda, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZSYTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* a, int const* lda, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_CHETRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* a, int const* lda, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZHETRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* a, int const* lda, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); /* symmetric/Hermitian indefinite and complex symmetric in packed storage */ void LAPACK_SSPSV (char const* uplo, int const* n, int const* nrhs, float* ap, int* ipiv, float* b, int const* ldb, int* info); void LAPACK_DSPSV (char const* uplo, int const* n, int const* nrhs, double* ap, int* ipiv, double* b, int const* ldb, int* info); void LAPACK_CSPSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* ap, int* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZSPSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* ap, int* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_CHPSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* ap, int* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZHPSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* ap, int* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_SSPTRF (char const* uplo, int const* n, float* ap, int* ipiv, int* info); void LAPACK_DSPTRF (char const* uplo, int const* n, double* ap, int* ipiv, int* info); void LAPACK_CSPTRF (char const* uplo, int const* n, fcomplex_t* ap, int* ipiv, int* info); void LAPACK_ZSPTRF (char const* uplo, int const* n, dcomplex_t* ap, int* ipiv, int* info); void LAPACK_CHPTRF (char const* uplo, int const* n, fcomplex_t* ap, int* ipiv, int* info); void LAPACK_ZHPTRF (char const* uplo, int const* n, dcomplex_t* ap, int* ipiv, int* info); void LAPACK_SSPTRS (char const* uplo, int const* n, int const* nrhs, float const* ap, int const* ipiv, float* b, int const* ldb, int* info); void LAPACK_DSPTRS (char const* uplo, int const* n, int const* nrhs, double const* ap, int const* ipiv, double* b, int const* ldb, int* info); void LAPACK_CSPTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* ap, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZSPTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* ap, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_CHPTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* ap, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZHPTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* ap, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); /* banded */ void LAPACK_DGBTRF (int const* n, int const* m, int const* kl, int const* ku, double* ab, int const* ldab, int* ipiv, int* info); void LAPACK_DGBTRS (char const* trans, int const* n, int const* kl, int const* ku, int const* nrhs, double const* ab, int const* ldab, int const* ipiv, double* b, int const* ldb, int* info); /**********************************************************************/ /* eigenproblems */ /**********************************************************************/ void LAPACK_SGEES (const char* jobvs, const char* sort, logical_t* select, const int* n, float* a, const int * lda, const int* sdim, float* wr, float* wi, float* vs, const int * ldvs, float* work, const int * lwork, bool* bwork, int* info); void LAPACK_DGEES (const char* jobvs, const char* sort, logical_t* select, const int* n, double* a, const int * lda, const int* sdim, double* wr, double* wi, double* vs, const int * ldvs, double* work, const int * lwork, bool* bwork, int* info); void LAPACK_CGEES( const char* jobvs, const char* sort, logical_t* select, const int *n, fcomplex_t* a, const int * lda, int * sdim, fcomplex_t* w, fcomplex_t* vs, const int * ldvs, fcomplex_t* work, const int * lwork, float* rwork, bool* bwork, int* info ); void LAPACK_ZGEES( const char* jobvs, const char* sort, const logical_t* select, const int *n, dcomplex_t* a, const int * lda, int * sdim, dcomplex_t* w, dcomplex_t* vs, const int * ldvs, dcomplex_t* work, const int * lwork, double* rwork, bool* bwork, int* info ); void LAPACK_SGEEV( const char* jobvl, const char* jobvr, const int* n, float* a, const int* lda, float* wr, float* wi, float* vl, const int* ldvl, float* vr, const int* ldvr, float* work, const int* lwork, int* info ); void LAPACK_DGEEV( const char* jobvl, const char* jobvr, const int* n, double* a, const int* lda, double* wr, double* wi, double* vl, const int* ldvl, double* vr, const int* ldvr, double* work, const int* lwork, int* info ); void LAPACK_CGEEV( const char* jobvl, const char* jobvr, const int* n, fcomplex_t* a, const int* lda, fcomplex_t* w, fcomplex_t* vl, const int* ldvl, fcomplex_t* vr, const int* ldvr, fcomplex_t* work, const int* lwork, float* rwork, int* info ); void LAPACK_ZGEEV( const char* jobvl, const char* jobvr, const int* n, dcomplex_t* a, const int* lda, dcomplex_t* w, dcomplex_t* vl, const int* ldvl, dcomplex_t* vr, const int* ldvr, dcomplex_t* work, const int* lwork, double* rwork, int* info ); void LAPACK_SSYEV( const char* jobz, const char* uplo, const int *n, float* a, const int * lda, float* w, float* work, const int * lwork, int* info ); void LAPACK_DSYEV( const char* jobz, const char* uplo, const int *n, double* a, const int * lda, double* w, double* work, const int * lwork, int* info ); void LAPACK_CHEEV( const char* jobz, const char* uplo, const int *n, fcomplex_t* a, const int * lda, float* w, fcomplex_t* work, const int * lwork, float* rwork, int* info ); void LAPACK_ZHEEV( const char* jobz, const char* uplo, const int *n, dcomplex_t* a, const int * lda, double* w, dcomplex_t* work, const int * lwork, double* rwork, int* info ); void LAPACK_CTREVC( const char* side, const char* howmny, const logical_t* select, const int *n, fcomplex_t* t, const int * ldt, fcomplex_t* vl, const int* ldvl, fcomplex_t* vr, const int * ldvr, const int * nm, int* m, fcomplex_t* work, float* rwork, int* info ); void LAPACK_ZTREVC( const char* side, const char* howmny, const logical_t* select, const int *n, dcomplex_t* t, const int * ldt, dcomplex_t* vl, const int* ldvl, dcomplex_t* vr, const int * ldvr, const int * nm, int* m, dcomplex_t* work, double* rwork, int* info ); void LAPACK_STREVC( const char* side, const char* howmny, const logical_t* select, const int *n, float* t, const int * ldt, float* vl, const int* ldvl, float* vr, const int * ldvr, const int * nm, int* m, float* work, int* info ); void LAPACK_DTREVC( const char* side, const char* howmny, const logical_t* select, const int *n, double* t, const int * ldt, double* vl, const int* ldvl, double* vr, const int * ldvr, const int * nm, int* m, double* work, int* info ); void LAPACK_STREXC( const char* compq, const int *n, float* t, const int * ldt, float* q, const int* ldq, int* ifst, const int * ilst, float* work, int* info ); void LAPACK_DTREXC( const char* compq, const int *n, double* t, const int * ldt, double* q, const int* ldq, int* ifst, const int * ilst, double* work, int* info ); void LAPACK_CTREXC( const char* compq, const int *n, fcomplex_t* t, const int * ldt, fcomplex_t* q, const int* ldq, int* ifst, const int * ilst, int* info ); void LAPACK_ZTREXC( const char* compq, const int *n, dcomplex_t* t, const int * ldt, dcomplex_t* q, const int* ldq, int* ifst, const int * ilst, int* info ); /* Hermitian tridiagonal matrices */ void LAPACK_SSTEQR( char const* compz, int const* n, float* d, float* E, float* z, int const* ldz, float* work, int* info ) ; void LAPACK_DSTEQR( char const* compz, int const* n, double* d, double* E, double* z, int const* ldz, double* work, int* info ) ; /* Hermitian banded matrices */ void LAPACK_SSBEV( char const* jobz, char const* uplo, int const* n, int const* kd, float* ab, int const* ldab, float* w, float* z, int const* ldz, float* work, int* info ); void LAPACK_DSBEV( char const* jobz, char const* uplo, int const* n, int const* kd, double* ab, int const* ldab, double* w, double* z, int const* ldz, double* work, int* info ); void LAPACK_CHBEV( char const* jobz, char const* uplo, int const* n, int const* kd, fcomplex_t* ab, int const* ldab, float* w, fcomplex_t* z, int const* ldz, fcomplex_t* work, float* rwork, int* info ); void LAPACK_ZHBEV( char const* jobz, char const* uplo, int const* n, int const* kd, dcomplex_t* ab, int const* ldab, double* w, dcomplex_t* z, int const* ldz, dcomplex_t* work, double* rwork, int* info ); /*********************************************************************/ /* Auxiliary routines for eigenvalue problems */ /*********************************************************************/ void LAPACK_SSYTRD( char const* uplo, int const* n, float* a, int const* lda, float* d, float* e, float* tau, float* work, int const* lwork, int* INFO ) ; void LAPACK_DSYTRD( char const* uplo, int const* n, double* a, int const* lda, double* d, double* e, double* tau, double* work, int const* lwork, int* INFO ) ; /*********************************************************************/ /* SVD */ /*********************************************************************/ void LAPACK_SGESVD (char const* jobu, char const* jobvt, int const* m, int const* n, float* a, int const* lda, float* s, float* u, int const* ldu, float* vt, int const* ldvt, float* work, int const* lwork, int* info); void LAPACK_DGESVD (char const* jobu, char const* jobvt, int const* m, int const* n, double* a, int const* lda, double* s, double* u, int const* ldu, double* vt, int const* ldvt, double* work, int const* lwork, int* info); void LAPACK_CGESVD (char const* jobu, char const* jobvt, int const* m, int const* n, fcomplex_t* a, int const* lda, float* s, fcomplex_t* u, int const* ldu, fcomplex_t* vt, int const* ldvt, fcomplex_t* work, int const* lwork, float* rwork, int* info); void LAPACK_ZGESVD (char const* jobu, char const* jobvt, int const* m, int const* n, dcomplex_t* a, int const* lda, double* s, dcomplex_t* u, int const* ldu, dcomplex_t* vt, int const* ldvt, dcomplex_t* work, int const* lwork, double* rwork, int* info); void LAPACK_SGESDD (char const* jobz, int const* m, int const* n, float* a, int const* lda, float* s, float* u, int const* ldu, float* vt, int const* ldvt, float* work, int const* lwork, int* iwork, int* info); void LAPACK_DGESDD (char const* jobz, int const* m, int const* n, double* a, int const* lda, double* s, double* u, int const* ldu, double* vt, int const* ldvt, double* work, int const* lwork, int* iwork, int* info); void LAPACK_CGESDD (char const* jobz, int const* m, int const* n, fcomplex_t* a, int const* lda, float* s, fcomplex_t* u, int const* ldu, fcomplex_t* vt, int const* ldvt, fcomplex_t* work, int const* lwork, float* rwork, int* iwork, int* info); void LAPACK_ZGESDD (char const* jobz, int const* m, int const* n, dcomplex_t* a, int const* lda, double* s, dcomplex_t* u, int const* ldu, dcomplex_t* vt, int const* ldvt, dcomplex_t* work, int const* lwork, double* rwork, int* iwork, int* info); /*********************************************************************/ /* QR factorization */ /*********************************************************************/ void LAPACK_SGEQRF( const int* m, const int* n, float* a, const int* lda, float* tau, float* work, const int* lwork, int* info ); void LAPACK_DGEQRF( const int* m, const int* n, double* a, const int* lda, double* tau, double* work, const int* lwork, int* info ); void LAPACK_CGEQRF( const int* m, const int* n, fcomplex_t* a, const int* lda, fcomplex_t* tau, fcomplex_t* work, const int* lwork, int* info ); void LAPACK_ZGEQRF( const int* m, const int* n, dcomplex_t* a, const int* lda, dcomplex_t* tau, dcomplex_t* work, const int* lwork, int* info ); void LAPACK_SORMQR( const char* side, const char* trans, const int* m, const int* n, const int* k, const float* a, const int* lda, const float* tau, float* c, const int* ldc, float* work, const int* lwork, int* info ); void LAPACK_DORMQR( const char* side, const char* trans, const int* m, const int* n, const int* k, const double* a, const int* lda, const double* tau, double* c, const int* ldc, double* work, const int* lwork, int* info ); void LAPACK_CUNMQR( const char* side, const char* trans, const int* m, const int* n, const int* k, const fcomplex_t* a, const int* lda, const fcomplex_t* tau, fcomplex_t* c, const int* ldc, fcomplex_t* work, const int* lwork, int* info ); void LAPACK_ZUNMQR( const char* side, const char* trans, const int* m, const int* n, const int* k, const dcomplex_t* a, const int* lda, const dcomplex_t* tau, dcomplex_t* c, const int* ldc, dcomplex_t* work, const int* lwork, int* info ); /********************************************************************/ /* Least Squares */ /********************************************************************/ void LAPACK_SGELS(const char* trans, const int* m, const int* n, const int *nrhs, float* a, const int* lda, float* b, const int* ldb, float* work, const int* lwork, int* info); void LAPACK_DGELS(const char* trans, const int* m, const int* n, const int *nrhs, double* a, const int* lda, double* b, const int* ldb, double* work, const int* lwork, int* info); void LAPACK_CGELS(const char* trans, const int* m, const int* n, const int *nrhs, fcomplex_t* a, const int* lda, fcomplex_t* b, const int* ldb, fcomplex_t* work, const int* lwork, int* info); void LAPACK_ZGELS(const char* trans, const int* m, const int* n, const int *nrhs, dcomplex_t* a, const int* lda, dcomplex_t* b, const int* ldb, dcomplex_t* work, const int* lwork, int* info); void LAPACK_SGELSS(const int *m, const int *n, const int *nrhs, float *a, const int *lda, float *b, const int *ldb, float *s, const float *rcond, int *rank, float *work, const int *lwork, int *info); void LAPACK_DGELSS(const int *m, const int *n, const int *nrhs, double *a, const int *lda, double *b, const int *ldb, double *s, const double *rcond, int *rank, double *work, const int *lwork, int *info); void LAPACK_CGELSS(const int *m, const int *n, const int *nrhs, fcomplex_t *a, const int *lda, fcomplex_t *b, const int *ldb, float *s, const float *rcond, int *rank, fcomplex_t *work, const int *lwork, float *rwork, int *info); void LAPACK_ZGELSS(const int *m, const int *n, const int *nrhs, dcomplex_t *a, const int *lda, dcomplex_t *b, const int *ldb, double *s, const double *rcond, int *rank, dcomplex_t *work, const int *lwork, double *rwork, int *info); void LAPACK_SGELSD(const int *m, const int *n, const int *nrhs, float *a, const int *lda, float *b, const int *ldb, float *s, const float *rcond, int *rank, float *work, const int *lwork, int *iwork, int *info); void LAPACK_DGELSD(const int *m, const int *n, const int *nrhs, double *a, const int *lda, double *b, const int *ldb, double *s, const double *rcond, int *rank, double *work, const int *lwork, int *iwork, int *info); void LAPACK_CGELSD(const int *m, const int *n, const int *nrhs, fcomplex_t *a, const int *lda, fcomplex_t *b, const int *ldb, float *s, const float *rcond, int *rank, fcomplex_t *work, const int *lwork, float *rwork, int *iwork, int *info); void LAPACK_ZGELSD(const int *m, const int *n, const int *nrhs, dcomplex_t *a, const int *lda, dcomplex_t *b, const int *ldb, double *s, const double *rcond, int *rank, dcomplex_t *work, const int *lwork, double *rwork, int *iwork, int *info); /********************************************************************/ /* auxiliary */ /********************************************************************/ int LAPACK_ILAENV (int const* ispec, const char* name, const char* opt, int const* n1, int const* n2, int const* n3, int const* n4, int, int); } #endif boost-bindings/boost/numeric/bindings/lapack/lapack.hpp0000644000175000017500000000272607752726113023420 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_HPP // linear systems #include #include #include #include #include #include #include // eigenproblems #include #include #include #include // SVD #include #include // Miscellaneous #include #include #endif // BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_HPP boost-bindings/boost/numeric/bindings/lapack/lapack_names.h0000644000175000017500000001707210776015652024242 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_NAMES_H #define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_NAMES_H #ifndef BOOST_NUMERIC_BINDINGS_USE_CLAPACK # include #else # define FORTRAN_ID( id ) id##_ #endif /* linear systems */ /* general */ #define LAPACK_SGESV FORTRAN_ID( sgesv ) #define LAPACK_DGESV FORTRAN_ID( dgesv ) #define LAPACK_CGESV FORTRAN_ID( cgesv ) #define LAPACK_ZGESV FORTRAN_ID( zgesv ) #define LAPACK_SGETRF FORTRAN_ID( sgetrf ) #define LAPACK_DGETRF FORTRAN_ID( dgetrf ) #define LAPACK_CGETRF FORTRAN_ID( cgetrf ) #define LAPACK_ZGETRF FORTRAN_ID( zgetrf ) #define LAPACK_SGETRS FORTRAN_ID( sgetrs ) #define LAPACK_DGETRS FORTRAN_ID( dgetrs ) #define LAPACK_CGETRS FORTRAN_ID( cgetrs ) #define LAPACK_ZGETRS FORTRAN_ID( zgetrs ) #define LAPACK_SGETRI FORTRAN_ID( sgetri ) #define LAPACK_DGETRI FORTRAN_ID( dgetri ) #define LAPACK_CGETRI FORTRAN_ID( cgetri ) #define LAPACK_ZGETRI FORTRAN_ID( zgetri ) /* symmetric/Hermitian positive definite */ #define LAPACK_SPOSV FORTRAN_ID( sposv ) #define LAPACK_DPOSV FORTRAN_ID( dposv ) #define LAPACK_CPOSV FORTRAN_ID( cposv ) #define LAPACK_ZPOSV FORTRAN_ID( zposv ) #define LAPACK_SPOTRF FORTRAN_ID( spotrf ) #define LAPACK_DPOTRF FORTRAN_ID( dpotrf ) #define LAPACK_CPOTRF FORTRAN_ID( cpotrf ) #define LAPACK_ZPOTRF FORTRAN_ID( zpotrf ) #define LAPACK_SPOTRS FORTRAN_ID( spotrs ) #define LAPACK_DPOTRS FORTRAN_ID( dpotrs ) #define LAPACK_CPOTRS FORTRAN_ID( cpotrs ) #define LAPACK_ZPOTRS FORTRAN_ID( zpotrs ) #define LAPACK_SPOTRI FORTRAN_ID( spotri ) #define LAPACK_DPOTRI FORTRAN_ID( dpotri ) #define LAPACK_CPOTRI FORTRAN_ID( cpotri ) #define LAPACK_ZPOTRI FORTRAN_ID( zpotri ) /* symmetric/Hermitian positive definite in packed storage */ #define LAPACK_SPPSV FORTRAN_ID( sppsv ) #define LAPACK_DPPSV FORTRAN_ID( dppsv ) #define LAPACK_CPPSV FORTRAN_ID( cppsv ) #define LAPACK_ZPPSV FORTRAN_ID( zppsv ) #define LAPACK_SPPTRF FORTRAN_ID( spptrf ) #define LAPACK_DPPTRF FORTRAN_ID( dpptrf ) #define LAPACK_CPPTRF FORTRAN_ID( cpptrf ) #define LAPACK_ZPPTRF FORTRAN_ID( zpptrf ) #define LAPACK_SPPTRS FORTRAN_ID( spptrs ) #define LAPACK_DPPTRS FORTRAN_ID( dpptrs ) #define LAPACK_CPPTRS FORTRAN_ID( cpptrs ) #define LAPACK_ZPPTRS FORTRAN_ID( zpptrs ) #define LAPACK_SPPTRI FORTRAN_ID( spptri ) #define LAPACK_DPPTRI FORTRAN_ID( dpptri ) #define LAPACK_CPPTRI FORTRAN_ID( cpptri ) #define LAPACK_ZPPTRI FORTRAN_ID( zpptri ) /* symmetric/Hermitian indefinite and complex symmetric */ #define LAPACK_SSYSV FORTRAN_ID( ssysv ) #define LAPACK_DSYSV FORTRAN_ID( dsysv ) #define LAPACK_CSYSV FORTRAN_ID( csysv ) #define LAPACK_ZSYSV FORTRAN_ID( zsysv ) #define LAPACK_CHESV FORTRAN_ID( chesv ) #define LAPACK_ZHESV FORTRAN_ID( zhesv ) #define LAPACK_SSYTRF FORTRAN_ID( ssytrf ) #define LAPACK_DSYTRF FORTRAN_ID( dsytrf ) #define LAPACK_CSYTRF FORTRAN_ID( csytrf ) #define LAPACK_ZSYTRF FORTRAN_ID( zsytrf ) #define LAPACK_CHETRF FORTRAN_ID( chetrf ) #define LAPACK_ZHETRF FORTRAN_ID( zhetrf ) #define LAPACK_SSYTRS FORTRAN_ID( ssytrs ) #define LAPACK_DSYTRS FORTRAN_ID( dsytrs ) #define LAPACK_CSYTRS FORTRAN_ID( csytrs ) #define LAPACK_ZSYTRS FORTRAN_ID( zsytrs ) #define LAPACK_CHETRS FORTRAN_ID( chetrs ) #define LAPACK_ZHETRS FORTRAN_ID( zhetrs ) /* symmetric/Hermitian indefinite and complex symmetric in packed storage */ #define LAPACK_SSPSV FORTRAN_ID( sspsv ) #define LAPACK_DSPSV FORTRAN_ID( dspsv ) #define LAPACK_CSPSV FORTRAN_ID( cspsv ) #define LAPACK_ZSPSV FORTRAN_ID( zspsv ) #define LAPACK_CHPSV FORTRAN_ID( chpsv ) #define LAPACK_ZHPSV FORTRAN_ID( zhpsv ) #define LAPACK_SSPTRF FORTRAN_ID( ssptrf ) #define LAPACK_DSPTRF FORTRAN_ID( dsptrf ) #define LAPACK_CSPTRF FORTRAN_ID( csptrf ) #define LAPACK_ZSPTRF FORTRAN_ID( zsptrf ) #define LAPACK_CHPTRF FORTRAN_ID( chptrf ) #define LAPACK_ZHPTRF FORTRAN_ID( zhptrf ) #define LAPACK_SSPTRS FORTRAN_ID( ssptrs ) #define LAPACK_DSPTRS FORTRAN_ID( dsptrs ) #define LAPACK_CSPTRS FORTRAN_ID( csptrs ) #define LAPACK_ZSPTRS FORTRAN_ID( zsptrs ) #define LAPACK_CHPTRS FORTRAN_ID( chptrs ) #define LAPACK_ZHPTRS FORTRAN_ID( zhptrs ) /* banded solve */ #define LAPACK_DGBTRF FORTRAN_ID( dgbtrf ) #define LAPACK_DGBTRS FORTRAN_ID( dgbtrs ) /********************************************/ /* eigenproblems */ #define LAPACK_SGEES FORTRAN_ID( sgees ) #define LAPACK_DGEES FORTRAN_ID( dgees ) #define LAPACK_CGEES FORTRAN_ID( cgees ) #define LAPACK_ZGEES FORTRAN_ID( zgees ) #define LAPACK_SGEEV FORTRAN_ID( sgeev ) #define LAPACK_DGEEV FORTRAN_ID( dgeev ) #define LAPACK_CGEEV FORTRAN_ID( cgeev ) #define LAPACK_ZGEEV FORTRAN_ID( zgeev ) #define LAPACK_SSYEV FORTRAN_ID( ssyev ) #define LAPACK_DSYEV FORTRAN_ID( dsyev ) #define LAPACK_CHEEV FORTRAN_ID( cheev ) #define LAPACK_ZHEEV FORTRAN_ID( zheev ) #define LAPACK_STREVC FORTRAN_ID( strevc ) #define LAPACK_DTREVC FORTRAN_ID( dtrevc ) #define LAPACK_CTREVC FORTRAN_ID( ctrevc ) #define LAPACK_ZTREVC FORTRAN_ID( ztrevc ) #define LAPACK_STREXC FORTRAN_ID( strexc ) #define LAPACK_DTREXC FORTRAN_ID( dtrexc ) #define LAPACK_CTREXC FORTRAN_ID( ctrexc ) #define LAPACK_ZTREXC FORTRAN_ID( ztrexc ) /********************************************/ /* eigenproblems for banded matrices */ #define LAPACK_SSBEV FORTRAN_ID( ssbev ) #define LAPACK_DSBEV FORTRAN_ID( dsbev ) #define LAPACK_CHBEV FORTRAN_ID( chbev ) #define LAPACK_ZHBEV FORTRAN_ID( zhbev ) /********************************************/ /* eigenproblems for tridiagonal matrices */ #define LAPACK_SSTEQR FORTRAN_ID( ssteqr ) #define LAPACK_DSTEQR FORTRAN_ID( dsteqr ) /********************************************/ /* QR factorization */ #define LAPACK_SGEQRF FORTRAN_ID( sgeqrf ) #define LAPACK_DGEQRF FORTRAN_ID( dgeqrf ) #define LAPACK_CGEQRF FORTRAN_ID( cgeqrf ) #define LAPACK_ZGEQRF FORTRAN_ID( zgeqrf ) // Apply orthogonal transformation #define LAPACK_SORMQR FORTRAN_ID( sormqr ) #define LAPACK_DORMQR FORTRAN_ID( dormqr ) #define LAPACK_CUNMQR FORTRAN_ID( cunmqr ) #define LAPACK_ZUNMQR FORTRAN_ID( zunmqr ) #define LAPACK_SSYTRD FORTRAN_ID( ssytrd ) #define LAPACK_DSYTRD FORTRAN_ID( dsytrd ) /********************************************/ /* SVD */ #define LAPACK_SGESVD FORTRAN_ID( sgesvd ) #define LAPACK_DGESVD FORTRAN_ID( dgesvd ) #define LAPACK_CGESVD FORTRAN_ID( cgesvd ) #define LAPACK_ZGESVD FORTRAN_ID( zgesvd ) #define LAPACK_SGESDD FORTRAN_ID( sgesdd ) #define LAPACK_DGESDD FORTRAN_ID( dgesdd ) #define LAPACK_CGESDD FORTRAN_ID( cgesdd ) #define LAPACK_ZGESDD FORTRAN_ID( zgesdd ) /********************************************/ /* Least Squares */ #define LAPACK_SGELS FORTRAN_ID( sgels ) #define LAPACK_DGELS FORTRAN_ID( dgels ) #define LAPACK_CGELS FORTRAN_ID( cgels ) #define LAPACK_ZGELS FORTRAN_ID( zgels ) #define LAPACK_SGELSS FORTRAN_ID( sgelss ) #define LAPACK_DGELSS FORTRAN_ID( dgelss ) #define LAPACK_CGELSS FORTRAN_ID( cgelss ) #define LAPACK_ZGELSS FORTRAN_ID( zgelss ) #define LAPACK_SGELSD FORTRAN_ID( sgelsd ) #define LAPACK_DGELSD FORTRAN_ID( dgelsd ) #define LAPACK_CGELSD FORTRAN_ID( cgelsd ) #define LAPACK_ZGELSD FORTRAN_ID( zgelsd ) /********************************************/ /* auxiliary */ #define LAPACK_ILAENV FORTRAN_ID( ilaenv ) #endif boost-bindings/boost/numeric/bindings/lapack/ormqr.hpp0000644000175000017500000001720210776016571023320 0ustar andreasandreas/* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMQR_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMQR_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Apply the orthogonal transformation abtained by geqrf() to // a general matrix. // /////////////////////////////////////////////////////////////////// /* * ormqr() overwrites the general M by N matrix C with * * SIDE = 'L' SIDE = 'R' * TRANS = 'N': Q * C C * Q * TRANS = 'C' || 'T': Q**H * C C * Q**H * * where Q is a complex unitary matrix defined as the product of k * elementary reflectors * * Q = H(1) H(2) . . . H(k) * * as returned by geqrf(). Q is of order M if SIDE = 'L' and of order N * if SIDE = 'R'. * * Workspace is organized following the arguments in the calling sequence. * optimal_workspace() : for optimizing use of blas 3 kernels * minimal_workspace() : minimum size of workarrays, but does not allow for optimization * of blas 3 kernels * workspace( work ) where is an array that is used as auxiliary memory with the same value_type * as C. * We must have that vector_size( work ) >= matrix_size2( c ) * if SIDE=='L' otherwise vector_size( work ) >= matrix_size1( c ) */ namespace detail { inline void ormqr (char const side, char const trans, int const m, int const n, int const k, const float* a, int const lda, const float* tau, float* c, int const ldc, float* work, int const lwork, int& info) { LAPACK_SORMQR (&side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, &info); } inline void ormqr (char const side, char const trans, int const m, int const n, int const k, const double* a, int const lda, const double* tau, double* c, int const ldc, double* work, int const lwork, int& info) { LAPACK_DORMQR (&side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, &info); } inline void ormqr (char const side, char const trans, int const m, int const n, int const k, const traits::complex_f* a, int const lda, const traits::complex_f* tau, traits::complex_f* c, int const ldc, traits::complex_f* work, int const lwork, int& info) { LAPACK_CUNMQR (&side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc, traits::complex_ptr(work), &lwork, &info); } inline void ormqr (char const side, char const trans, int const m, int const n, int const k, const traits::complex_d* a, int const lda, const traits::complex_d* tau, traits::complex_d* c, int const ldc, traits::complex_d* work, int const lwork, int& info) { LAPACK_ZUNMQR (&side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc, traits::complex_ptr(work), &lwork, &info); } template inline int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); int const k = traits::vector_size (tau); int const lwork = traits::vector_size (work); assert ( side=='L' || side=='R' ); assert ( trans=='N' || trans=='C' || trans=='T' ); assert ( (side=='L' ? m >= k : n >= k ) ); assert ( (side=='L' ? m == traits::matrix_size1 (a) : n == traits::matrix_size1 (a) ) ); assert (traits::matrix_size2 (a)==k); assert ( (side=='L' ? lwork >= n : lwork >= m ) ); int info; ormqr (side, trans, m, n, k, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (tau), traits::matrix_storage (c), traits::leading_dimension (c), traits::vector_storage (work), lwork, info); return info; } } // namespace detail // Function that allocates temporary arrays for optimal execution time. template inline int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, optimal_workspace ) { typedef typename A::value_type value_type ; int const n_w = (side=='L' ? traits::matrix_size2 (c) : traits::matrix_size1 (c) ); traits::detail::array work( std::max(1,n_w*32) ); return detail::ormqr( side, trans, a, tau, c, work ); } // Function that allocates temporary arrays with minimal size template inline int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, minimal_workspace ) { typedef typename A::value_type value_type ; int const n_w = (side=='L' ? traits::matrix_size2 (c) : traits::matrix_size1 (c) ); traits::detail::array work( std::max(1,n_w) ); return detail::ormqr( side, trans, a, tau, c, work ); } // Function that uses auxiliary array in workspace // The calling sequence is ormqr(side, trans, a, tau, c, workspace( work_array ) ) // where work_array is an array with the same value_type as a and c . template inline int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, detail::workspace1 workspace ) { typedef typename A::value_type value_type ; return detail::ormqr( side, trans, a, tau, c, workspace.w_ ); } } }}} #endif boost-bindings/boost/numeric/bindings/lapack/posv.hpp0000644000175000017500000002621510776161006023145 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_POSV_HPP #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A symmetric or Hermitian positive definite matrix // ///////////////////////////////////////////////////////////////////// /* * posv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N symmetric or Hermitian positive * definite matrix and X and B are N-by-NRHS matrices. * * The Cholesky decomposition is used to factor A as * A = U^T * U or A = U^H * U, if UPLO = 'U', * A = L * L^T or A = L * L^H, if UPLO = 'L', * where U is an upper triangular matrix and L is a lower triangular * matrix. The factored form of A is then used to solve the system of * equations A * X = B. * * If UPLO = 'U', the leading N-by-N upper triangular part of A * contains the upper triangular part of the matrix A, and the * strictly lower triangular part of A is not referenced. * If UPLO = 'L', the leading N-by-N lower triangular part of A * contains the lower triangular part of the matrix A, and the * strictly upper triangular part of A is not referenced. */ namespace detail { inline void posv (char const uplo, int const n, int const nrhs, float* a, int const lda, float* b, int const ldb, int* info) { LAPACK_SPOSV (&uplo, &n, &nrhs, a, &lda, b, &ldb, info); } inline void posv (char const uplo, int const n, int const nrhs, double* a, int const lda, double* b, int const ldb, int* info) { LAPACK_DPOSV (&uplo, &n, &nrhs, a, &lda, b, &ldb, info); } inline void posv (char const uplo, int const n, int const nrhs, traits::complex_f* a, int const lda, traits::complex_f* b, int const ldb, int* info) { LAPACK_CPOSV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, traits::complex_ptr (b), &ldb, info); } inline void posv (char const uplo, int const n, int const nrhs, traits::complex_d* a, int const lda, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZPOSV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, traits::complex_ptr (b), &ldb, info); } template inline int posv (char const uplo, SymmMatrA& a, MatrB& b) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); int info; posv (uplo, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int posv (char const uplo, SymmMatrA& a, MatrB& b) { assert (uplo == 'U' || uplo == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::posv (uplo, a, b); } template inline int posv (SymmMatrA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef traits::matrix_traits matraits; typedef typename matraits::value_type val_t; BOOST_STATIC_ASSERT( (traits::detail::symm_herm_compatible< val_t, typename matraits::matrix_structure >::value ) ) ; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::posv (uplo, a, b); } /* * potrf() computes the Cholesky factorization of a symmetric * or Hermitian positive definite matrix A. The factorization has * the form * A = U^T * U or A = U^H * U, if UPLO = 'U', * A = L * L^T or A = L * L^H, if UPLO = 'L', * where U is an upper triangular matrix and L is lower triangular. */ namespace detail { inline void potrf (char const uplo, int const n, float* a, int const lda, int* info) { LAPACK_SPOTRF (&uplo, &n, a, &lda, info); } inline void potrf (char const uplo, int const n, double* a, int const lda, int* info) { LAPACK_DPOTRF (&uplo, &n, a, &lda, info); } inline void potrf (char const uplo, int const n, traits::complex_f* a, int const lda, int* info) { LAPACK_CPOTRF (&uplo, &n, traits::complex_ptr (a), &lda, info); } inline void potrf (char const uplo, int const n, traits::complex_d* a, int const lda, int* info) { LAPACK_ZPOTRF (&uplo, &n, traits::complex_ptr (a), &lda, info); } template inline int potrf (char const uplo, SymmMatrA& a) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); int info; potrf (uplo, n, traits::matrix_storage (a), traits::leading_dimension (a), &info); return info; } } template inline int potrf (char const uplo, SymmMatrA& a) { assert (uplo == 'U' || uplo == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::potrf (uplo, a); } template inline int potrf (SymmMatrA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef traits::matrix_traits matraits; typedef typename matraits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename matraits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::potrf (uplo, a); } /* * potrs() solves a system of linear equations A*X = B with * a symmetric or Hermitian positive definite matrix A using * the Cholesky factorization computed by potrf(). */ namespace detail { inline void potrs (char const uplo, int const n, int const nrhs, float const* a, int const lda, float* b, int const ldb, int* info) { LAPACK_SPOTRS (&uplo, &n, &nrhs, a, &lda, b, &ldb, info); } inline void potrs (char const uplo, int const n, int const nrhs, double const* a, int const lda, double* b, int const ldb, int* info) { LAPACK_DPOTRS (&uplo, &n, &nrhs, a, &lda, b, &ldb, info); } inline void potrs (char const uplo, int const n, int const nrhs, traits::complex_f const* a, int const lda, traits::complex_f* b, int const ldb, int* info) { LAPACK_CPOTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, traits::complex_ptr (b), &ldb, info); } inline void potrs (char const uplo, int const n, int const nrhs, traits::complex_d const* a, int const lda, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZPOTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, traits::complex_ptr (b), &ldb, info); } template inline int potrs (char const uplo, SymmMatrA const& a, MatrB& b) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); int info; potrs (uplo, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int potrs (char const uplo, SymmMatrA const& a, MatrB& b) { assert (uplo == 'U' || uplo == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::potrs (uplo, a, b); } template inline int potrs (SymmMatrA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef traits::matrix_traits matraits; typedef traits::matrix_traits mbtraits; typedef typename matraits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename matraits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename mbtraits::matrix_structure, traits::general_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::potrs (uplo, a, b); } // TO DO: potri() } }}} #endif boost-bindings/boost/numeric/bindings/lapack/ppsv.hpp0000644000175000017500000002076310776161006023150 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl Toon Knapen 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PPSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_PPSV_HPP #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A symmetric or Hermitian positive definite matrix // stored in packed format // ///////////////////////////////////////////////////////////////////// /* * ppsv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N symmetric or Hermitian positive * definite matrix stored in packed format and X and B are N-by-NRHS * matrices. * * The Cholesky decomposition is used to factor A as * A = U^T * U or A = U^H * U, if UPLO = 'U', * A = L * L^T or A = L * L^H, if UPLO = 'L', * where U is an upper triangular matrix and L is a lower triangular * matrix. The factored form of A is then used to solve the system of * equations A * X = B. * * Only upper or lower triangle of the symmetric matrix A is stored, * packed columnwise in a linear array AP. */ namespace detail { inline void ppsv (char const uplo, int const n, int const nrhs, float* ap, float* b, int const ldb, int* info) { LAPACK_SPPSV (&uplo, &n, &nrhs, ap, b, &ldb, info); } inline void ppsv (char const uplo, int const n, int const nrhs, double* ap, double* b, int const ldb, int* info) { LAPACK_DPPSV (&uplo, &n, &nrhs, ap, b, &ldb, info); } inline void ppsv (char const uplo, int const n, int const nrhs, traits::complex_f* ap, traits::complex_f* b, int const ldb, int* info) { LAPACK_CPPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), traits::complex_ptr (b), &ldb, info); } inline void ppsv (char const uplo, int const n, int const nrhs, traits::complex_d* ap, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZPPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), traits::complex_ptr (b), &ldb, info); } } template inline int ppsv (SymmMatrA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_pack_t< typename traits::matrix_traits::value_type >::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); char uplo = traits::matrix_uplo_tag (a); int info; detail::ppsv (uplo, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } /* * pptrf() computes the Cholesky factorization of a symmetric * or Hermitian positive definite matrix A in packed storage. * The factorization has the form * A = U^T * U or A = U^H * U, if UPLO = 'U', * A = L * L^T or A = L * L^H, if UPLO = 'L', * where U is an upper triangular matrix and L is lower triangular. */ namespace detail { inline void pptrf (char const uplo, int const n, float* ap, int* info) { LAPACK_SPPTRF (&uplo, &n, ap, info); } inline void pptrf (char const uplo, int const n, double* ap, int* info) { LAPACK_DPPTRF (&uplo, &n, ap, info); } inline void pptrf (char const uplo, int const n, traits::complex_f* ap, int* info) { LAPACK_CPPTRF (&uplo, &n, traits::complex_ptr (ap), info); } inline void pptrf (char const uplo, int const n, traits::complex_d* ap, int* info) { LAPACK_ZPPTRF (&uplo, &n, traits::complex_ptr (ap), info); } } template inline int pptrf (SymmMatrA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_pack_t< typename traits::matrix_traits::value_type >::type >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); char uplo = traits::matrix_uplo_tag (a); int info; detail::pptrf (uplo, n, traits::matrix_storage (a), &info); return info; } /* * pptrs() solves a system of linear equations A*X = B with * a symmetric or Hermitian positive definite matrix A in packed * storage using the Cholesky factorization computed by pptrf(). */ namespace detail { inline void pptrs (char const uplo, int const n, int const nrhs, float const* ap, float* b, int const ldb, int* info) { LAPACK_SPPTRS (&uplo, &n, &nrhs, ap, b, &ldb, info); } inline void pptrs (char const uplo, int const n, int const nrhs, double const* ap, double* b, int const ldb, int* info) { LAPACK_DPPTRS (&uplo, &n, &nrhs, ap, b, &ldb, info); } inline void pptrs (char const uplo, int const n, int const nrhs, traits::complex_f const* ap, traits::complex_f* b, int const ldb, int* info) { LAPACK_CPPTRS (&uplo, &n, &nrhs, traits::complex_ptr (ap), traits::complex_ptr (b), &ldb, info); } inline void pptrs (char const uplo, int const n, int const nrhs, traits::complex_d const* ap, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZPPTRS (&uplo, &n, &nrhs, traits::complex_ptr (ap), traits::complex_ptr (b), &ldb, info); } } template inline int pptrs (SymmMatrA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_pack_t< typename traits::matrix_traits::value_type >::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); char uplo = traits::matrix_uplo_tag (a); int info; detail::pptrs (uplo, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } // TO DO: pptri() } }}} #endif boost-bindings/boost/numeric/bindings/lapack/spsv.hpp0000644000175000017500000002265110776161006023151 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl & Toon Knapen 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_SPSV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B with A symmetric matrix // stored in packed format // ///////////////////////////////////////////////////////////////////// /* * spsv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N symmetric matrix stored in packed * format and X and B are N-by-NRHS matrices. * * The diagonal pivoting method is used to factor A as * A = U * D * U^T, if UPLO = 'U', * A = L * D * L^T, if UPLO = 'L', * where U (or L) is a product of permutation and unit upper * (lower) triangular matrices, and D is symmetric and block * diagonal with 1-by-1 and 2-by-2 diagonal blocks. * The factored form of A is then used to solve the system * of equations A * X = B. */ namespace detail { inline void spsv (char const uplo, int const n, int const nrhs, float* ap, int* ipiv, float* b, int const ldb, int* info) { LAPACK_SSPSV (&uplo, &n, &nrhs, ap, ipiv, b, &ldb, info); } inline void spsv (char const uplo, int const n, int const nrhs, double* ap, int* ipiv, double* b, int const ldb, int* info) { LAPACK_DSPSV (&uplo, &n, &nrhs, ap, ipiv, b, &ldb, info); } inline void spsv (char const uplo, int const n, int const nrhs, traits::complex_f* ap, int* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CSPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } inline void spsv (char const uplo, int const n, int const nrhs, traits::complex_d* ap, int* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZSPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } template inline int spsv (SymmA& a, IVec& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); char uplo = traits::matrix_uplo_tag (a); int info; spsv (uplo, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::vector_storage (i), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int spsv (SymmA& a, IVec& i, MatrB& b) { assert (traits::matrix_size1 (a) == traits::vector_size (i)); return detail::spsv (a, i, b); } template inline int spsv (SymmA& a, MatrB& b) { // with 'internal' pivot vector int info = -101; traits::detail::array i (traits::matrix_size1 (a)); if (i.valid()) info = detail::spsv (a, i, b); return info; } /* * sptrf() computes the factorization of a symmetric matrix A * in packed storage using the Bunch-Kaufman diagonal pivoting * method. The form of the factorization is * A = U * D * U^T or A = L * D * L^T * where U (or L) is a product of permutation and unit upper (lower) * triangular matrices, and D is symmetric and block diagonal with * 1-by-1 and 2-by-2 diagonal blocks. */ namespace detail { inline void sptrf (char const uplo, int const n, float* ap, int* ipiv, int* info) { LAPACK_SSPTRF (&uplo, &n, ap, ipiv, info); } inline void sptrf (char const uplo, int const n, double* ap, int* ipiv, int* info) { LAPACK_DSPTRF (&uplo, &n, ap, ipiv, info); } inline void sptrf (char const uplo, int const n, traits::complex_f* ap, int* ipiv, int* info) { LAPACK_CSPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info); } inline void sptrf (char const uplo, int const n, traits::complex_d* ap, int* ipiv, int* info) { LAPACK_ZSPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info); } } template inline int sptrf (SymmA& a, IVec& i) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::vector_size (i)); char uplo = traits::matrix_uplo_tag (a); int info; detail::sptrf (uplo, n, traits::matrix_storage (a), traits::vector_storage (i), &info); return info; } /* * sptrs() solves a system of linear equations A*X = B with * a symmetric matrix A in packed storage using the factorization * A = U * D * U^T or A = L * D * L^T * computed by sptrf(). */ namespace detail { inline void sptrs (char const uplo, int const n, int const nrhs, float const* a, int const* ipiv, float* b, int const ldb, int* info) { LAPACK_SSPTRS (&uplo, &n, &nrhs, a, ipiv, b, &ldb, info); } inline void sptrs (char const uplo, int const n, int const nrhs, double const* a, int const* ipiv, double* b, int const ldb, int* info) { LAPACK_DSPTRS (&uplo, &n, &nrhs, a, ipiv, b, &ldb, info); } inline void sptrs (char const uplo, int const n, int const nrhs, traits::complex_f const* a, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CSPTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), ipiv, traits::complex_ptr (b), &ldb, info); } inline void sptrs (char const uplo, int const n, int const nrhs, traits::complex_d const* a, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZSPTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), ipiv, traits::complex_ptr (b), &ldb, info); } } template inline int sptrs (SymmA const& a, IVec const& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); char uplo = traits::matrix_uplo_tag (a); int info; detail::sptrs (uplo, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), traits::vector_storage (i), #else traits::matrix_storage_const (a), traits::vector_storage_const (i), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } // TO DO: sptri } }}} #endif boost-bindings/boost/numeric/bindings/lapack/syev.hpp0000644000175000017500000001146010215335074023134 0ustar andreasandreas/* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYEV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_SYEV_HPP #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Eigendecomposition of a real symmetric matrix A = Q * D * Q' // /////////////////////////////////////////////////////////////////// /* * syev() computes the eigendecomposition of a N x N matrix * A = Q * D * Q', where Q is a N x N orthogonal matrix and * D is a diagonal matrix. The diagonal elements D(i,i) is an * eigenvalue of A and Q(:,i) is a corresponding eigenvector. * * On return of syev, A is overwritten by Q and w contains the main * diagonal of D. * * int syev (char jobz, char uplo, A& a, W& w, minimal_workspace ) ; * jobz : 'V' : compute eigenvectors * 'N' : do not compute eigenvectors * uplo : 'U' : only the upper triangular part of A is used on input. * 'L' : only the lower triangular part of A is used on input. */ namespace detail { inline void syev (char const jobz, char const uplo, int const n, float* a, int const lda, float* w, float* work, int const lwork, int& info) { LAPACK_SSYEV (&jobz, &uplo, &n, a, &lda, w, work, &lwork, &info); } inline void syev (char const jobz, char const uplo, int const n, double* a, int const lda, double* w, double* work, int const lwork, int& info) { LAPACK_DSYEV (&jobz, &uplo, &n, a, &lda, w, work, &lwork, &info); } template inline int syev (char jobz, char uplo, A& a, W& w, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert ( n>0 ); assert (traits::matrix_size2 (a)==n); assert (traits::leading_dimension (a)>=n); assert (traits::vector_size (w)==n); assert (3*n-1 <= traits::vector_size (work)); assert ( uplo=='U' || uplo=='L' ); assert ( jobz=='N' || jobz=='V' ); int info; detail::syev (jobz, uplo, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (w), traits::vector_storage (work), traits::vector_size (work), info); return info; } } // namespace detail // Function that allocates work arrays template inline int syev (char jobz, char uplo, A& a, W& w, optimal_workspace ) { typedef typename A::value_type value_type ; int const n = traits::matrix_size1 (a); traits::detail::array work( std::max(1,34*n) ); return detail::syev(jobz, uplo, a, w, work); } // syev() // Function that allocates work arrays template inline int syev (char jobz, char uplo, A& a, W& w, minimal_workspace ) { typedef typename A::value_type value_type ; int const n = traits::matrix_size1 (a); traits::detail::array work( std::max(1,3*n-1) ); return detail::syev(jobz, uplo, a, w, work); } // syev() // Function that allocates work arrays template inline int syev (char jobz, char uplo, A& a, W& w, detail::workspace1 workspace ) { typedef typename A::value_type value_type ; return detail::syev(jobz, uplo, a, w, workspace.w_); } // syev() } }}} #endif boost-bindings/boost/numeric/bindings/lapack/sysv.hpp0000644000175000017500000005111110776161006023153 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_SYSV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B with A symmetric matrix // ///////////////////////////////////////////////////////////////////// namespace detail { inline int sytrf_block (float, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "SSYTRF", ul2, n); } inline int sytrf_block (double, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "DSYTRF", ul2, n); } inline int sytrf_block (traits::complex_f, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "CSYTRF", ul2, n); } inline int sytrf_block (traits::complex_d, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "ZSYTRF", ul2, n); } } template inline int sytrf_block (char const q, char const ul, SymmA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (q == 'O' || q == 'M'); assert (ul == 'U' || ul == 'L'); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif int ispec = (q == 'O' ? 1 : 2); return detail::sytrf_block (val_t(), ispec, ul, n); } template inline int sytrf_block (char const q, SymmA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif assert (q == 'O' || q == 'M'); char ul = traits::matrix_uplo_tag (a); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif int ispec = (q == 'O' ? 1 : 2); return detail::sytrf_block (val_t(), ispec, ul, n); } template inline int sytrf_work (char const q, char const ul, SymmA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (q == 'O' || q == 'M'); assert (ul == 'U' || ul == 'L'); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif int lw = -13; if (q == 'M') lw = 1; if (q == 'O') lw = n * detail::sytrf_block (val_t(), 1, ul, n); return lw; } template inline int sytrf_work (char const q, SymmA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif assert (q == 'O' || q == 'M'); char ul = traits::matrix_uplo_tag (a); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif int lw = -13; if (q == 'M') lw = 1; if (q == 'O') lw = n * detail::sytrf_block (val_t(), 1, ul, n); return lw; } template inline int sysv_work (char const q, char const ul, SymmA const& a) { return sytrf_work (q, ul, a); } template inline int sysv_work (char const q, SymmA const& a) { return sytrf_work (q, a); } /* * sysv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N symmetric matrix and X and B * are N-by-NRHS matrices. * * The diagonal pivoting method is used to factor A as * A = U * D * U^T, if UPLO = 'U', * A = L * D * L^T, if UPLO = 'L', * where U (or L) is a product of permutation and unit upper * (lower) triangular matrices, and D is symmetric and block * diagonal with 1-by-1 and 2-by-2 diagonal blocks. * The factored form of A is then used to solve the system * of equations A * X = B. */ namespace detail { inline void sysv (char const uplo, int const n, int const nrhs, float* a, int const lda, int* ipiv, float* b, int const ldb, float* w, int const lw, int* info) { LAPACK_SSYSV (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, w, &lw, info); } inline void sysv (char const uplo, int const n, int const nrhs, double* a, int const lda, int* ipiv, double* b, int const ldb, double* w, int const lw, int* info) { LAPACK_DSYSV (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, w, &lw, info); } inline void sysv (char const uplo, int const n, int const nrhs, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* b, int const ldb, traits::complex_f* w, int const lw, int* info) { LAPACK_CSYSV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, traits::complex_ptr (w), &lw, info); } inline void sysv (char const uplo, int const n, int const nrhs, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* b, int const ldb, traits::complex_d* w, int const lw, int* info) { LAPACK_ZSYSV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, traits::complex_ptr (w), &lw, info); } template inline int sysv (char const ul, SymmA& a, IVec& i, MatrB& b, Work& w) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); int info; sysv (ul, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (i), traits::matrix_storage (b), traits::leading_dimension (b), traits::vector_storage (w), traits::vector_size (w), &info); return info; } } template inline int sysv (char const ul, SymmA& a, IVec& i, MatrB& b, Work& w) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (traits::vector_size (w) >= 1); return detail::sysv (ul, a, i, b, w); } template inline int sysv (SymmA& a, IVec& i, MatrB& b, Work& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (traits::vector_size (w) >= 1); char uplo = traits::matrix_uplo_tag (a); return detail::sysv (uplo, a, i, b, w); } template inline int sysv (char const ul, SymmA& a, MatrB& b) { // with 'internal' pivot and work vectors assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); int info = -101; traits::detail::array i (n); if (i.valid()) { info = -102; int lw = sytrf_work ('O', ul, a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::sysv (ul, a, i, b, w); } return info; } template inline int sysv (SymmA& a, MatrB& b) { // with 'internal' pivot and work vectors #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); char uplo = traits::matrix_uplo_tag (a); int info = -101; traits::detail::array i (n); if (i.valid()) { info = -102; int lw = sytrf_work ('O', a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::sysv (uplo, a, i, b, w); } return info; } /* * sytrf() computes the factorization of a symmetric matrix A using * the Bunch-Kaufman diagonal pivoting method. The form of the * factorization is * A = U * D * U^T or A = L * D * L^T * where U (or L) is a product of permutation and unit upper (lower) * triangular matrices, and D is symmetric and block diagonal with * 1-by-1 and 2-by-2 diagonal blocks. */ namespace detail { inline void sytrf (char const uplo, int const n, float* a, int const lda, int* ipiv, float* w, int const lw, int* info) { LAPACK_SSYTRF (&uplo, &n, a, &lda, ipiv, w, &lw, info); } inline void sytrf (char const uplo, int const n, double* a, int const lda, int* ipiv, double* w, int const lw, int* info) { LAPACK_DSYTRF (&uplo, &n, a, &lda, ipiv, w, &lw, info); } inline void sytrf (char const uplo, int const n, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* w, int const lw, int* info) { LAPACK_CSYTRF (&uplo, &n, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (w), &lw, info); } inline void sytrf (char const uplo, int const n, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* w, int const lw, int* info) { LAPACK_ZSYTRF (&uplo, &n, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (w), &lw, info); } template inline int sytrf (char const ul, SymmA& a, IVec& i, Work& w) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::vector_size (i)); int info; sytrf (ul, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (i), traits::vector_storage (w), traits::vector_size (w), &info); return info; } } template inline int sytrf (char const ul, SymmA& a, IVec& i, Work& w) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (traits::vector_size (w) >= 1); return detail::sytrf (ul, a, i, w); } template inline int sytrf (SymmA& a, IVec& i, Work& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif assert (traits::vector_size (w) >= 1); char uplo = traits::matrix_uplo_tag (a); return detail::sytrf (uplo, a, i, w); } template inline int sytrf (char const ul, SymmA& a, Ivec& i) { // with 'internal' work vector assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int info = -101; int lw = sytrf_work ('O', ul, a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::sytrf (ul, a, i, w); return info; } template inline int sytrf (SymmA& a, Ivec& i) { // with 'internal' work vector #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); int info = -101; int lw = sytrf_work ('O', a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::sytrf (uplo, a, i, w); return info; } /* * sytrs() solves a system of linear equations A*X = B with * a symmetric matrix A using the factorization * A = U * D * U^T or A = L * D * L^T * computed by sytrf(). */ namespace detail { inline void sytrs (char const uplo, int const n, int const nrhs, float const* a, int const lda, int const* ipiv, float* b, int const ldb, int* info) { LAPACK_SSYTRS (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void sytrs (char const uplo, int const n, int const nrhs, double const* a, int const lda, int const* ipiv, double* b, int const ldb, int* info) { LAPACK_DSYTRS (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void sytrs (char const uplo, int const n, int const nrhs, traits::complex_f const* a, int const lda, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CSYTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } inline void sytrs (char const uplo, int const n, int const nrhs, traits::complex_d const* a, int const lda, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZSYTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } template inline int sytrs (char const ul, SymmA const& a, IVec const& i, MatrB& b) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); int info; sytrs (ul, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (i), #else traits::vector_storage_const (i), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int sytrs (char const ul, SymmA const& a, IVec const& i, MatrB& b) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::sytrs (ul, a, i, b); } template inline int sytrs (SymmA const& a, IVec const& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::sytrs (uplo, a, i, b); } // TO DO: sytri } }}} #endif boost-bindings/boost/numeric/bindings/lapack/trevc.hpp0000644000175000017500000001206410776016571023304 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TREVC_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_TREVC_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Compute eigenvectors of Schur matrix (computed by gees). // /////////////////////////////////////////////////////////////////// /* * trevc() computes the eigenvectors using the Schur factorization * * Let A = U * S * herm(U), then trecv computes the eigenvectors of * S, and may optionally apply them to U. * * To compute the Schur factorization, see gees. */ namespace detail { inline void trevc (char const side, char const howmny, const logical_t* select, int const n, float* t, int const ldt, float* vl, int const ldvl, float* vr, int const ldvr, int const mm, int& m, float* work, int& info) { LAPACK_STREVC (&side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info); } inline void trevc (char const side, char const howmny, const logical_t* select, int const n, double* t, int const ldt, double* vl, int const ldvl, double* vr, int const ldvr, int const mm, int& m, double* work, int& info) { LAPACK_DTREVC (&side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info); } inline void trevc (char const side, char const howmny, const logical_t* select, int const n, traits::complex_f* t, int const ldt, traits::complex_f* vl, int const ldvl, traits::complex_f* vr, int const ldvr, int const mm, int& m, traits::complex_f* work, int& info) { LAPACK_CTREVC (&side, &howmny, select, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr, &mm, &m, traits::complex_ptr(work+n), traits::complex_ptr(work), &info); } inline void trevc (char const side, char const howmny, const logical_t* select, int const n, traits::complex_d* t, int const ldt, traits::complex_d* vl, int const ldvl, traits::complex_d* vr, int const ldvr, int const mm, int& m, traits::complex_d* work, int& info) { LAPACK_ZTREVC (&side, &howmny, select, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr, &mm, &m, traits::complex_ptr(work+n), traits::complex_ptr(work), &info); } } // Compute Schur factorization with Schur vectors template inline int trevc (char const side, char const howmny, MatrT& t, VL& vl, VR& vr, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (t); assert (n == traits::matrix_size2 (t)); assert (n == traits::matrix_size1 (vl)); assert (n == traits::matrix_size2 (vl)); assert (n == traits::matrix_size1 (vr)); assert (n == traits::matrix_size2 (vr)); assert (3*n <= traits::vector_size (work)); logical_t* select=0; int mm=n; int m; int info; detail::trevc (side, howmny, select, n, traits::matrix_storage (t), traits::leading_dimension (t), traits::matrix_storage (vl), traits::leading_dimension (vl), traits::matrix_storage (vr), traits::leading_dimension (vr), mm, m, traits::vector_storage (work), info); return info; } } }}} #endif boost-bindings/boost/numeric/bindings/lapack/trexc.hpp0000644000175000017500000001074210776016571023307 0ustar andreasandreas/* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TREXC_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_TREXC_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Reorder the Schur factorization of a matrix. // /////////////////////////////////////////////////////////////////// /* * trexc() reorders the Schur factorization of a matrix * A = Q*T*Q**T, so that the diagonal block of T with row * index IFST is moved to row ILST. */ namespace detail { inline int trexc_work_size( int const n, float ) {return n;} inline int trexc_work_size( int const n, double ) {return n;} inline int trexc_work_size( int const n, traits::complex_f ) {return 0;} inline int trexc_work_size( int const n, traits::complex_d ) {return 0;} } // Get the minimum size of the work array. template int trexc_work_size(const MatrT& t) { return detail::trexc_work_size( traits::matrix_size1(t), typename MatrT::value_type() ); } namespace detail { inline void trexc (char const compq, int const n, float* t, int const ldt, float* q, int const ldq, int& ifst, int& ilst, float* work, int& info) { LAPACK_STREXC (&compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info); } inline void trexc (char const compq, int const n, double* t, int const ldt, double* q, int const ldq, int& ifst, int& ilst, double* work, int& info) { LAPACK_DTREXC (&compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info); } inline void trexc (char const compq, int const n, traits::complex_f* t, int const ldt, traits::complex_f* q, int const ldq, int& ifst, int& ilst, float* work, int& info) { LAPACK_CTREXC (&compq, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(q), &ldq, &ifst, &ilst, &info); } inline void trexc (char const compq, int const n, traits::complex_d* t, int const ldt, traits::complex_d* q, int const ldq, int& ifst, int& ilst, double* work, int& info) { LAPACK_ZTREXC (&compq, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(q), &ldq, &ifst, &ilst, &info); } } // Reorder Schur factorization with Schur vectors template inline int trexc (char const compq, MatrT& t, Q& q, int& ifst, int& ilst, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (t); assert (n == traits::matrix_size2 (t)); assert (n == traits::matrix_size1 (q)); assert (n == traits::matrix_size2 (q)); assert (trexc_work_size(t) <= traits::vector_size (work)); int info; detail::trexc (compq, n, traits::matrix_storage (t), traits::leading_dimension (t), traits::matrix_storage (q), traits::leading_dimension (q), ifst, ilst, traits::vector_storage (work), info); return info; } } }}} #endif boost-bindings/boost/numeric/bindings/lapack/workspace.hpp0000644000175000017500000000613607752726043024164 0ustar andreasandreas/* * * Copyright (c) Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_WORKSPACE_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_WORKSPACE_HPP #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { /* * Organization of workspace in Lapack. * We allow one of the following arguments in a number of Lapack functions * - minimal_workspace() : the function allocates the minimum workspace required for the function * - optimal_workspace() : the function allocates the amount of workspace that allows optimal * execution. * - workspace( work ) : the function uses the workspace array in work. * - workspace( rwork, work ) : the function uses a real array rwork and a compolex array work as * workspace. (There are Lapack functions for complex matrices * that require two workarrays) * */ namespace lapack { // Four classes are introduced to distinguish between the different type of memory allocations struct minimal_workspace {} ; struct optimal_workspace {} ; namespace detail { template struct workspace1 { W& w_ ; workspace1(W& w) : w_( w ) {} }; // struct workspace1 template struct workspace2 { W& w_ ; WR& wr_ ; workspace2(W& w, WR& wr) : w_(w) , wr_(wr) {} }; // struct workspace2 } template detail::workspace1 workspace(W& w) { return detail::workspace1(w) ; } // workspace() template detail::workspace2 workspace(W& w, WR& wr) { return detail::workspace2(w, wr) ; } // workspace() /// Select the number of workspaces depending on the value_type template struct n_workspace_args { }; template <> struct n_workspace_args< float > { static const int value = 1 ; }; template <> struct n_workspace_args< double > { static const int value = 1 ; }; template <> struct n_workspace_args< traits::complex_f > { static const int value = 2 ; }; template <> struct n_workspace_args< traits::complex_d > { static const int value = 2 ; }; } }}} #endif boost-bindings/boost/numeric/bindings/lapack/sytrd.hpp0000644000175000017500000000736210776012644023330 0ustar andreasandreas// // Copyright Karl Meerbergen 2007 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYTRD_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_SYTRD_HPP #include #include #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif /********************************************************************/ /* eigenvalue problems */ /********************************************************************/ /* tridiagonal symmetric */ namespace boost { namespace numeric { namespace bindings { namespace lapack { namespace detail { inline void sytrd ( char uplo, int n, float* a, int lda, float* d, float* e, float* tau, float* work, int lwork, int& info ) { LAPACK_SSYTRD( &uplo, &n, a, &lda, d, e, tau, work, &lwork, &info ) ; } inline void sytrd ( char uplo, int n, double* a, int lda, double* d, double* e, double* tau, double* work, int lwork, int& info ) { LAPACK_DSYTRD( &uplo, &n, a, &lda, d, e, tau, work, &lwork, &info ) ; } } // namespace detail template inline int sytrd( char uplo, A& a, D& d, E& e, Tau& tau, W& work ) { int const n = traits::matrix_size1 (a); assert( traits::matrix_size2 (a) == n ); assert( traits::vector_size (d) == n ); assert( traits::vector_size (e) == n-1 ); assert( traits::vector_size (tau) == n-1 ); assert( uplo=='U' || uplo=='L' ); int lwork = traits::vector_size( work ) ; assert( lwork >= 1 ); int info; detail::sytrd( uplo, n, traits::matrix_storage( a ), traits::leading_dimension( a ), traits::vector_storage( d ), traits::vector_storage( e ), traits::vector_storage( tau ), traits::vector_storage( work ), lwork, info ) ; return info; } // sytrd() template inline int sytrd( char uplo, A& a, D& d, E& e, Tau& tau, optimal_workspace=optimal_workspace() ) { int info; detail::sytrd( uplo, traits::matrix_size1( a ), traits::matrix_storage( a ), traits::leading_dimension( a ), traits::vector_storage( d ), traits::vector_storage( e ), traits::vector_storage( tau ), traits::vector_storage( tau ), -1, info ) ; if (info) return info ; int lwork = * traits::vector_storage( tau ) ; traits::detail::array::value_type> work( lwork ); return sytrd( uplo, a, d, e, tau, work ) ; } template inline int sytrd( char uplo, A& a, D& d, E& e, Tau& tau, minimal_workspace ) { int lwork = 1 ; traits::detail::array::value_type> work( lwork ); return sytrd( uplo, a, d, e, tau, work ) ; } }}}} #endif // BOOST_NUMERIC_BINDINGS_LAPACK_GBSV_HPP boost-bindings/boost/numeric/bindings/lapack/gels.patch0000644000175000017500000000655110776014376023430 0ustar andreasandreas--- lapack.h 2008-04-05 20:11:50.000000000 -0400 +++ /home/andreas/tmp/bindings_extensions/lapack/lapack.h 2007-08-24 10:50:24.000000000 -0400 @@ -493,6 +478,65 @@ /********************************************************************/ + /* Least Squares */ + /********************************************************************/ + + void LAPACK_SGELS(const char* trans, const int* m, const int* n, + const int *nrhs, float* a, const int* lda, + float* b, const int* ldb, float* work, + const int* lwork, int* info); + void LAPACK_DGELS(const char* trans, const int* m, const int* n, + const int *nrhs, double* a, const int* lda, + double* b, const int* ldb, double* work, + const int* lwork, int* info); + void LAPACK_CGELS(const char* trans, const int* m, const int* n, + const int *nrhs, fcomplex_t* a, const int* lda, + fcomplex_t* b, const int* ldb, fcomplex_t* work, + const int* lwork, int* info); + void LAPACK_ZGELS(const char* trans, const int* m, const int* n, + const int *nrhs, dcomplex_t* a, const int* lda, + dcomplex_t* b, const int* ldb, dcomplex_t* work, + const int* lwork, int* info); + + + void LAPACK_SGELSS(const int *m, const int *n, const int *nrhs, + float *a, const int *lda, float *b, const int *ldb, + float *s, const float *rcond, int *rank, float *work, + const int *lwork, int *info); + void LAPACK_DGELSS(const int *m, const int *n, const int *nrhs, + double *a, const int *lda, double *b, const int *ldb, + double *s, const double *rcond, int *rank, double *work, + const int *lwork, int *info); + void LAPACK_CGELSS(const int *m, const int *n, const int *nrhs, + fcomplex_t *a, const int *lda, fcomplex_t *b, const int *ldb, + float *s, const float *rcond, int *rank, fcomplex_t *work, + const int *lwork, float *rwork, int *info); + void LAPACK_ZGELSS(const int *m, const int *n, const int *nrhs, + dcomplex_t *a, const int *lda, dcomplex_t *b, const int *ldb, + double *s, const double *rcond, int *rank, dcomplex_t *work, + const int *lwork, double *rwork, int *info); + + + void LAPACK_SGELSD(const int *m, const int *n, const int *nrhs, + float *a, const int *lda, float *b, const int *ldb, + float *s, const float *rcond, int *rank, float *work, + const int *lwork, int *iwork, int *info); + void LAPACK_DGELSD(const int *m, const int *n, const int *nrhs, + double *a, const int *lda, double *b, const int *ldb, + double *s, const double *rcond, int *rank, double *work, + const int *lwork, int *iwork, int *info); + void LAPACK_CGELSD(const int *m, const int *n, const int *nrhs, + fcomplex_t *a, const int *lda, fcomplex_t *b, const int *ldb, + float *s, const float *rcond, int *rank, fcomplex_t *work, + const int *lwork, float *rwork, int *iwork, int *info); + void LAPACK_ZGELSD(const int *m, const int *n, const int *nrhs, + dcomplex_t *a, const int *lda, dcomplex_t *b, const int *ldb, + double *s, const double *rcond, int *rank, dcomplex_t *work, + const int *lwork, double *rwork, int *iwork, int *info); + + + + /********************************************************************/ /* auxiliary */ /********************************************************************/ boost-bindings/boost/numeric/bindings/lapack/gelsd.hpp0000644000175000017500000003326610664567006023266 0ustar andreasandreas#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELSD_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GELSD_HPP #include #include #include #include #include #include #include #include #include // included to implicitly convert a vector to an nx1 matrix // so that it is compatible with lapack binding #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { namespace detail { inline void gelsd(const int m, const int n, const int nrhs, float *a, const int lda, float *b, const int ldb, float *s, const float rcond, int *rank, float *work, const int lwork, int *iwork, int *info) { LAPACK_SGELSD(&m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, iwork, info); } inline void gelsd(const int m, const int n, const int nrhs, double *a, const int lda, double *b, const int ldb, double *s, const double rcond, int *rank, double *work, const int lwork, int *iwork, int *info) { LAPACK_DGELSD(&m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, iwork, info); } inline void gelsd(const int m, const int n, const int nrhs, traits::complex_f *a, const int lda, traits::complex_f *b, const int ldb, float *s, const float rcond, int *rank, traits::complex_f *work, const int lwork, float *rwork, int *iwork, int *info) { LAPACK_CGELSD(&m, &n, &nrhs, traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, s, &rcond, rank, traits::complex_ptr(work), &lwork, rwork, iwork, info); } inline void gelsd(const int m, const int n, const int nrhs, traits::complex_d *a, const int lda, traits::complex_d *b, const int ldb, double *s, const double rcond, int *rank, traits::complex_d *work, const int lwork, double *rwork, int *iwork, int *info) { LAPACK_ZGELSD(&m, &n, &nrhs, traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, s, &rcond, rank, traits::complex_ptr(work), &lwork, rwork, iwork, info); } // gelsd for real type template inline int gelsd(MatrA& A, MatrB& B, VecS& s, Work& work) { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int maxmn = std::max(m, n); const int minmn = std::min(m, n); // sanity checks assert(m >= 0 && n >= 0); assert(nrhs >= 0); assert(traits::leading_dimension(A) >= std::max(1, m)); assert(traits::leading_dimension(B) >= std::max(1, maxmn)); assert(traits::vector_size(work) >= 1); assert(traits::vector_size(s) >= std::max(1, minmn)); int info; const real_t rcond = -1; // use machine precision int rank; // query for maximum size of subproblems const int smlsiz = ilaenv(9, "GELSD", ""); const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); traits::detail::array iwork(3*minmn*nlvl + 11*minmn); detail::gelsd(traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(B), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(B), traits::leading_dimension(B), traits::vector_storage(s), rcond, &rank, traits::vector_storage(work), traits::vector_size(work), traits::vector_storage(iwork), &info); return info; } // gelsd for complex type template inline int gelsd(MatrA& A, MatrB& B, VecS& s, Work& work, RWork& rwork) { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int maxmn = std::max(m, n); const int minmn = std::min(m, n); // sanity checks assert(m >= 0 && n >= 0); assert(nrhs >= 0); assert(traits::leading_dimension(A) >= std::max(1, m)); assert(traits::leading_dimension(B) >= std::max(1, maxmn)); assert(traits::vector_size(work) >= 1); assert(traits::vector_size(s) >= std::max(1, minmn)); int info; const real_t rcond = -1; // use machine precision int rank; // query for maximum size of subproblems const int smlsiz = ilaenv(9, "GELSD", ""); const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); traits::detail::array iwork(3*minmn*nlvl + 11*minmn); detail::gelsd(traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(B), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(B), traits::leading_dimension(B), traits::vector_storage(s), rcond, &rank, traits::vector_storage(work), traits::vector_size(work), traits::vector_storage(rwork), traits::vector_storage(iwork), &info); return info; } template struct Gelsd { }; // specialization for gelsd real flavors (sgelsd, dgelsd) template <> struct Gelsd<1> { template inline int operator() (MatrA& A, MatrB& B, VecS& s, minimal_workspace) const { typedef typename MatrA::value_type val_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs // query for maximum size of subproblems const int smlsiz = ilaenv(9, "GELSD", ""); const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); const int lwork = 12*minmn + 2*minmn*smlsiz + 8*minmn*nlvl + minmn*nrhs + (smlsiz+1)*(smlsiz+1); traits::detail::array work(lwork); return gelsd(A, B, s, work); } template inline int operator() (MatrA& A, MatrB& B, VecS& s, optimal_workspace) const { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs val_t temp_work; int temp_iwork; const real_t rcond = -1; int rank; int info; // query for optimal workspace size detail::gelsd(traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(B), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(B), traits::leading_dimension(B), traits::vector_storage(s), rcond, &rank, &temp_work, //traits::vector_storage(work), -1, //traits::vector_size(work), &temp_iwork, &info); assert(info == 0); const int lwork = traits::detail::to_int(temp_work); traits::detail::array work(lwork); return gelsd(A, B, s, work); } template inline int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace1& workspace) const { const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs return gelsd(A, B, s, workspace.w_); } }; // specialization for gelsd (cgelsd, zgelsd) template <> struct Gelsd<2> { template inline int operator() (MatrA& A, MatrB& B, VecS& s, minimal_workspace) const { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs // query for maximum size of subproblems const int smlsiz = ilaenv(9, "GELSD", ""); const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); traits::detail::array work(2*minmn + minmn*nrhs); const int rwork_size = 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl + 3*smlsiz*nrhs + (smlsiz+1)*(smlsiz+1); traits::detail::array rwork(std::max(1, rwork_size)); return gelsd(A, B, s, work, rwork); } template inline int operator() (MatrA& A, MatrB& B, VecS& s, optimal_workspace) const { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs val_t temp_work; real_t temp_rwork; int temp_iwork; const real_t rcond = -1; int rank; int info; // query for optimal workspace size detail::gelsd(traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(B), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(B), traits::leading_dimension(B), traits::vector_storage(s), rcond, &rank, &temp_work, //traits::vector_storage(work), -1, //traits::vector_size(work), &temp_rwork, &temp_iwork, &info); assert(info == 0); const int lwork = traits::detail::to_int(temp_work); traits::detail::array work(lwork); // query for maximum size of subproblems const int smlsiz = ilaenv(9, "GELSD", ""); const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); const int rwork_size = 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl + 3*smlsiz*nrhs + (smlsiz+1)*(smlsiz+1); traits::detail::array rwork(std::max(1, rwork_size)); return gelsd(A, B, s, work, rwork); } template inline int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace2& workspace) const { const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs return gelsd(A, B, s, workspace.w_, workspace.wr_); } }; } // detail // gelsd // Parameters: // A: matrix of coefficients // B: matrix of solutions (stored column-wise) // s: vector to store singular values on output, length >= max(1, min(m,n)) // workspace: either optimal, minimal, or user supplied // template inline int gelsd(MatrA& A, MatrB& B, VecS& s, Work& workspace) { typedef typename MatrA::value_type val_t; return detail::Gelsd::value>() (A, B, s, workspace); } // gelsd, no singular values are returned // Parameters: // A: matrix of coefficients // B: matrix of solutions (stored column-wise) // workspace: either optimal, minimal, or user supplied // template inline int gelsd(MatrA& A, MatrB& B, Work& workspace) { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int s_size = std::max(1, std::min(m,n)); traits::detail::array s(s_size); return detail::Gelsd::value>() (A, B, s, workspace); } } // lapack }}} #endifboost-bindings/boost/numeric/bindings/lapack/gelss.hpp0000644000175000017500000002640610664567510023303 0ustar andreasandreas#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELSS_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GELSS_HPP #include #include #include #include #include #include #include #include // included to implicitly convert a vector to an nx1 matrix // so that it is compatible with lapack binding #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { namespace detail { inline void gelss(const int m, const int n, const int nrhs, float *a, const int lda, float *b, const int ldb, float *s, const float rcond, int *rank, float *work, const int lwork, int *info) { LAPACK_SGELSS(&m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, info); } inline void gelss(const int m, const int n, const int nrhs, double *a, const int lda, double *b, const int ldb, double *s, const double rcond, int *rank, double *work, const int lwork, int *info) { LAPACK_DGELSS(&m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, info); } inline void gelss(const int m, const int n, const int nrhs, traits::complex_f *a, const int lda, traits::complex_f *b, const int ldb, float *s, const float rcond, int *rank, traits::complex_f *work, const int lwork, float *rwork, int *info) { LAPACK_CGELSS(&m, &n, &nrhs, traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, s, &rcond, rank, traits::complex_ptr(work), &lwork, rwork, info); } inline void gelss(const int m, const int n, const int nrhs, traits::complex_d *a, const int lda, traits::complex_d *b, const int ldb, double *s, const double rcond, int *rank, traits::complex_d *work, const int lwork, double *rwork, int *info) { LAPACK_ZGELSS(&m, &n, &nrhs, traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, s, &rcond, rank, traits::complex_ptr(work), &lwork, rwork, info); } // gelss for real type template inline int gelss(MatrA& A, MatrB& B, VecS& s, Work& work) { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int maxmn = std::max(m, n); const int minmn = std::min(m, n); // sanity checks assert(m >= 0 && n >= 0); assert(nrhs >= 0); assert(traits::leading_dimension(A) >= std::max(1, m)); assert(traits::leading_dimension(B) >= std::max(1, maxmn)); assert(traits::vector_size(work) >= 1); assert(traits::vector_size(s) >= std::max(1, minmn)); int info; const real_t rcond = -1; // use machine precision int rank; detail::gelss(traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(B), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(B), traits::leading_dimension(B), traits::vector_storage(s), rcond, &rank, traits::vector_storage(work), traits::vector_size(work), &info); return info; } // gelss for complex type template inline int gelss(MatrA& A, MatrB& B, VecS& s, Work& work, RWork& rwork) { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int nrhs = traits::matrix_size2(B); const int maxmn = std::max(m, n); const int minmn = std::min(m, n); // sanity checks assert(m >= 0 && n >= 0); assert(nrhs >= 0); assert(traits::leading_dimension(A) >= std::max(1, m)); assert(traits::leading_dimension(B) >= std::max(1, maxmn)); assert(traits::vector_size(work) >= 1); assert(traits::vector_size(s) >= std::max(1, minmn)); int info; const real_t rcond = -1; // use machine precision int rank; detail::gelss(traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(B), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(B), traits::leading_dimension(B), traits::vector_storage(s), rcond, &rank, traits::vector_storage(work), traits::vector_size(work), traits::vector_storage(rwork), &info); return info; } // default minimal workspace functor template struct Gelss { }; // specialization for gelss (sgelss, dgelss) template <> struct Gelss<1> { template inline int operator() (MatrA& A, MatrB& B, VecS& s, minimal_workspace) const { typedef typename MatrA::value_type val_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int rhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs traits::detail::array work(3*minmn + std::max(2*minmn, maxmnr)); return gelss(A, B, s, work); } template inline int operator() (MatrA& A, MatrB& B, VecS& s, optimal_workspace) const { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int rhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs val_t temp_work; const real_t rcond = -1; int rank; int info; // query for optimal workspace size detail::gelss(traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(B), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(B), traits::leading_dimension(B), traits::vector_storage(s), rcond, &rank, &temp_work, //traits::vector_storage(work), -1, //traits::vector_size(work), &info); assert(info == 0); const int lwork = traits::detail::to_int(temp_work); traits::detail::array work(lwork); return gelss(A, B, s, work); } template inline int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace1& workspace) const { return gelss(A, B, s, workspace.w_); } }; // specialization for gelss (cgelss, zgelss) template <> struct Gelss<2> { template inline int operator() (MatrA& A, MatrB& B, VecS& s, minimal_workspace) const { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int rhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs traits::detail::array work(2*minmn + maxmnr); traits::detail::array rwork(std::max(1, (5*minmn))); return gelss(A, B, s, work, rwork); } template inline int operator() (MatrA& A, MatrB& B, VecS& s, optimal_workspace) const { typedef typename MatrA::value_type val_t; typedef traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int rhs = traits::matrix_size2(B); const int minmn = std::min(m, n); // minmn = m < n ? m : n const int maxmn = std::max(m, n); // maxmn = m > n ? m : n const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs val_t temp_work; real_t temp_rwork; const real_t rcond = -1; int rank; int info; // query for optimal workspace size detail::gelss(traits::matrix_size1(A), traits::matrix_size2(A), traits::matrix_size2(B), traits::matrix_storage(A), traits::leading_dimension(A), traits::matrix_storage(B), traits::leading_dimension(B), traits::vector_storage(s), rcond, &rank, &temp_work, //traits::vector_storage(work), -1, //traits::vector_size(work), &temp_rwork, &info); assert(info == 0); const int lwork = traits::detail::to_int(temp_work); traits::detail::array work(lwork); traits::detail::array rwork(std::max(1, (5*minmn))); return gelss(A, B, s, work, rwork); } template inline int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace2& workspace) const { return gelss(A, B, s, workspace.w_, workspace.wr); } }; } // detail // gelss // Parameters: // A: matrix of coefficients // B: matrix of solutions (stored column-wise) // s: vector to store singular values on output, length >= max(1, min(m,n)) // workspace: either optimal, minimal, or user supplied // template inline int gelss(MatrA& A, MatrB& B, VecS& s, Work& workspace) { typedef typename MatrA::value_type val_t; return detail::Gelss::value>() (A, B, s, workspace); } // gelss, no singular values are returned // Parameters: // A: matrix of coefficients // B: matrix of solutions (stored column-wise) // workspace: either optimal, minimal, or user supplied // template inline int gelss(MatrA& A, MatrB& B, Work& workspace) { typedef typename MatrA::value_type val_t; typedef typename traits::type_traits::real_type real_t; const int m = traits::matrix_size1(A); const int n = traits::matrix_size2(A); const int s_size = std::max(1, std::min(m,n)); traits::detail::array s(s_size); return detail::Gelss::value>() (A, B, s, workspace); } } // namespace lapack }}} #endifboost-bindings/boost/numeric/bindings/lapack/gbsv.hpp0000644000175000017500000001006510776015713023116 0ustar andreasandreas// // Copyright Vardan Akopian 2007 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GBSV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { namespace detail { inline void gbtrf (int const n, int const m, int const kl, int const ku, double* ab, int const ldab, int* ipiv, int* info) { LAPACK_DGBTRF (&n, &m, &kl, &ku, ab, &ldab, ipiv, info); } } template inline int gbtrf (MatrA& a, IVec& ipiv) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::banded_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, traits::row_major_t >::value)); #endif int const n = traits::matrix_size1 (a); int const m = traits::matrix_size2 (a); assert (traits::vector_size (ipiv) == (m < n ? m : n)); // if the matrix has kl lower and ku upper diagonals, then we should have // allocated kl lower and kl+ku upper diagonals int const kl = traits::matrix_lower_bandwidth (a); int const ku = traits::matrix_upper_bandwidth (a) - kl; int const ld = traits::leading_dimension (a); assert(ku > 0); int info; detail::gbtrf (n, m, kl, ku, traits::matrix_storage (a), ld, traits::vector_storage (ipiv), &info); return info; } namespace detail { inline void gbtrs (char const trans, int const n, int const kl, int const ku, int const m, double const* ab, int const ldab, int const* ipiv, double* b, int const ldb, int* info) { LAPACK_DGBTRS (&trans, &n, &kl, &ku, &m, ab, &ldab, ipiv, b, &ldb, info); } } template inline int gbtrs (char const trans, MatrA const& a, IVec const& ipiv, MatrB& b) { assert (trans == 'N' || trans == 'T' || trans == 'C'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::banded_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (ipiv)); // if the matrix has kl lower and ku upper diagonals, then we should have // allocated kl lower and kl+ku upper diagonals int const kl = traits::matrix_lower_bandwidth (a); int const ku = traits::matrix_upper_bandwidth (a) - kl; int const ld = traits::leading_dimension (a); assert(ku > 0); int info; detail::gbtrs (trans, n, kl, ku, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif ld, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (ipiv), #else traits::vector_storage_const (ipiv), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } }}} #endif boost-bindings/boost/numeric/bindings/traits/0000755000175000017500000000000010776011453021512 5ustar andreasandreasboost-bindings/boost/numeric/bindings/traits/detail/0000755000175000017500000000000010776011453022754 5ustar andreasandreasboost-bindings/boost/numeric/bindings/traits/detail/array.hpp0000644000175000017500000000234507725614060024612 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_HPP #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include namespace boost { namespace numeric { namespace bindings { namespace traits { template struct vector_traits > { typedef T value_type; typedef T* pointer; static pointer storage (detail::array& a) { return a.storage(); } static int size (detail::array& a) { return a.size(); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_HPP boost-bindings/boost/numeric/bindings/traits/detail/array_impl.hpp0000644000175000017500000000466107725614060025636 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_IMPL_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_IMPL_HPP /* very simple dynamic array class which is used in `higher level' bindings functions for pivot and work arrays Namely, there are (at least) two versions of all bindings functions where called LAPACK function expects work and/or pivot array, e.g. `lower' level (user should provide work and pivot arrays): int sysv (SymmA& a, IVec& i, MatrB& b, Work& w); `higher' level (with `internal' work and pivot arrays): int sysv (SymmA& a, MatrB& b); Probably you ask why I didn't use std::vector. There are two reasons. First is efficiency -- std::vector's constructor initialises vector elements. Second is consistency. LAPACK functions use `info' parameter as an error indicator. On the other hand, std::vector's allocator can throw an exception if memory allocation fails. detail::array's constructor uses `new (nothrow)' which returns 0 if allocation fails. So I can check whether array::storage == 0 and return appropriate error in `info'. */ #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { template class array : private noncopyable { public: array (int n) { stg = new (std::nothrow) T[n]; sz = (stg != 0) ? n : 0; } ~array() { delete[] stg; } int size() const { return sz; } bool valid() const { return stg != 0; } void resize (int n) { delete[] stg; stg = new (std::nothrow) T[n]; sz = (stg != 0) ? n : 0; } T* storage() { return stg; } T const* storage() const { return stg; } T& operator[] (int i) { return stg[i]; } T const& operator[] (int i) const { return stg[i]; } private: int sz; T* stg; }; }} }}} #endif boost-bindings/boost/numeric/bindings/traits/detail/generate_const.hpp0000644000175000017500000000252407707720121026467 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * First author acknowledges the support of the Faculty of Civil * Engineering, University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_GENERATE_CONST_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_GENERATE_CONST_HPP #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { /// Copy const from V to X if present template struct generate_const { typedef X type; }; template struct generate_const< const V, X > { typedef X const type; }; template struct generate_const< V const, X const > { typedef X const type; }; }}}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_GENERATE_CONST_HPP boost-bindings/boost/numeric/bindings/traits/detail/symm_herm_traits.hpp0000644000175000017500000000472310204421116027044 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_TRAITS_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_TRAITS_HPP #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { // select symmetric or hermitian matrix structure template struct symm_herm_t {}; template<> struct symm_herm_t { typedef symmetric_t type; }; template<> struct symm_herm_t { typedef symmetric_t type; }; template<> struct symm_herm_t { typedef hermitian_t type; }; template<> struct symm_herm_t { typedef hermitian_t type; }; template struct symm_herm_pack_t {}; template<> struct symm_herm_pack_t { typedef symmetric_packed_t type; }; template<> struct symm_herm_pack_t { typedef symmetric_packed_t type; }; template<> struct symm_herm_pack_t { typedef hermitian_packed_t type; }; template<> struct symm_herm_pack_t { typedef hermitian_packed_t type; }; template struct symm_herm_compatible { BOOST_STATIC_CONSTANT( bool, value=false ) ; }; template struct symm_herm_compatible< T, hermitian_t > { BOOST_STATIC_CONSTANT( bool, value=true ) ; }; template struct symm_herm_compatible< T, symmetric_t > { BOOST_STATIC_CONSTANT( bool, value=true ) ; }; template struct symm_herm_compatible< std::complex, symmetric_t > { BOOST_STATIC_CONSTANT( bool, value=false ) ; }; } }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_TRAITS_HPP boost-bindings/boost/numeric/bindings/traits/detail/ublas_ordering.hpp0000644000175000017500000000553010776160175026475 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_UBLAS_ORDERING_H #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_UBLAS_ORDERING_H #include namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { template struct ublas_ordering {}; template<> struct ublas_ordering { typedef row_major_t type; typedef boost::numeric::ublas::row_major functor_type; template static int leading_dimension( M const& m ) { return m.size2() ; } template static int stride1( M const& m ) { return m.size2() ; } template static int stride2( M const& m ) { return 1 ; } }; template<> struct ublas_ordering { typedef column_major_t type; typedef boost::numeric::ublas::column_major functor_type; template static int leading_dimension( M const& m ) { return m.size1() ; } template static int stride1( M const& m ) { return 1 ; } template static int stride2( M const& m ) { return m.size1() ; } }; template struct ublas_banded_ordering {}; template<> struct ublas_banded_ordering { template static int leading_dimension( M const& m ) { return m.lower() + m.upper() + 1 ; } template static int stride1( M const& m ) { return 1 ; } template static int stride2( M const& m ) { return leading_dimension(m)-1 ; } }; template<> struct ublas_banded_ordering { template static int leading_dimension( M const& m ) { return m.lower() + m.upper() + 1 ; } template static int stride1( M const& m ) { return std::max(m.size1(), m.size2()) ; } template static int stride2( M const& m ) { return 1 ; } }; } }}}} #endif boost-bindings/boost/numeric/bindings/traits/detail/ublas_uplo.hpp0000644000175000017500000000203010142140556025617 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_UPLO_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_UPLO_H #include namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { template struct ublas_uplo {}; template<> struct ublas_uplo { typedef lower_t type; }; template<> struct ublas_uplo { typedef upper_t type; }; } }}}} #endif boost-bindings/boost/numeric/bindings/traits/detail/utils.hpp0000644000175000017500000000406607725614177024647 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_UTILS_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_UTILS_HPP // #include #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { // complex array => real & imaginary arrays template inline void disentangle (CIt c, CIt c_end, RIt rr, RIt ri) { for (; c != c_end; ++c, ++rr, ++ri) { *rr = traits::real (*c); *ri = traits::imag (*c); } } // real & imaginary arrays => complex array template inline void interlace (RIt r, RIt r_end, RIt ri, CIt c) { typedef typename std::iterator_traits::value_type cmplx_t; #ifdef BOOST_NUMERIC_BINDINGS_BY_THE_BOOK for (; r != r_end; ++r, ++ri, ++c) *c = cmplx_t (*r, *ri); #else typedef typename type_traits::real_type real_t; real_t *cp = reinterpret_cast (&*c); for (; r != r_end; ++r, ++ri) { *cp = *r; ++cp; *cp = *ri; ++cp; } #endif } // converts real/complex to int inline int to_int (float f) { return static_cast (f); } inline int to_int (double d) { return static_cast (d); } inline int to_int (traits::complex_f const& cf) { return static_cast (traits::real (cf)); } inline int to_int (traits::complex_d const& cd) { return static_cast (traits::real (cd)); } } }}}} #endif boost-bindings/boost/numeric/bindings/traits/algorithm.hpp0000644000175000017500000000167507707741602024230 0ustar andreasandreas#ifndef boost_numeric_bindings_traits_algorithm_hpp #define boost_numeric_bindings_traits_algorithm_hpp #include namespace boost { namespace numeric { namespace bindings { namespace traits { /// /// To be used instead of operator== for numeric types /// Implemented as functor instead of free function because of specialisation /// rationale: operator== on builtin types can not be overloaded. template < typename T > struct is_equal { is_equal(typename type_traits< T >::real_type tolerance) : tolerance_( tolerance ) {} bool operator()(const T& a, const T& b) { return std::abs( a - b ) < tolerance_ ; } // bool operator()(const T& a, const T& b, typename value_traits< T >::value_type tolerance) // { return std::abs( a - b ) < tolerance ; } typename type_traits< T >::real_type tolerance_ ; } ; }}}} #endif // boost_numeric_bindings_traits_algorithm_hpp boost-bindings/boost/numeric/bindings/traits/boost_array.hpp0000644000175000017500000000164307725612472024563 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_BOOST_ARRAY_H #define BOOST_NUMERIC_BINDINGS_TRAITS_BOOST_ARRAY_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include #else #error with your compiler boost::array<> cannot be used in bindings #endif #endif boost-bindings/boost/numeric/bindings/traits/c_array.hpp0000644000175000017500000000331607725612472023656 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_C_ARRAY_H #define BOOST_NUMERIC_BINDINGS_TRAITS_C_ARRAY_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include namespace boost { namespace numeric { namespace bindings { namespace traits { // built-in array template struct vector_detail_traits { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same::type>::value) ); #endif typedef T identifier_type [N]; // C++ syntax is amazing ;o) typedef V vector_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (vector_type& v) { return v; } static int size (vector_type&) { return N; } static int stride (vector_type&) { return 1; } }; }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler plain C array cannot be used in bindings #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_C_ARRAY_H boost-bindings/boost/numeric/bindings/traits/config.hpp0000644000175000017500000000242010117046442023461 0ustar andreasandreas// // Copyright (c) 2002-2003 // Toon Knapen, Kresimir Fresl, Joerg Walter // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. The authors make no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. // // #ifndef BOOST_NUMERIC_BINDINGS_CONFIG_HPP #define BOOST_NUMERIC_BINDINGS_CONFIG_HPP #include // Microsoft Visual C++ #if defined (BOOST_MSVC) // .. version 6.0 & 7.0 # if BOOST_MSVC <= 1300 # define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS # endif #elif defined(__ICC) #elif defined(__IBMCPP__) #elif defined(__GNUC__) #elif defined(__COMO__) #elif defined(__KCC) #elif defined(__sgi) #else #error bindings do not recognise compiler #endif #if defined (BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS) // structure checks require proper traits # define BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK // type checks require proper traits # define BOOST_NUMERIC_BINDINGS_NO_TYPE_CHECK #endif #endif boost-bindings/boost/numeric/bindings/traits/fortran.h0000644000175000017500000000260010776016207023336 0ustar andreasandreas// Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright (C) 2002, 2003 Si-Lab b.v.b.a., Toon Knapen and Kresimir Fresl #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_FORTRAN_H #define BOOST_NUMERIC_BINDINGS_TRAITS_FORTRAN_H #if defined(BIND_FORTRAN_LOWERCASE_UNDERSCORE) || defined(BIND_FORTRAN_LOWERCASE) // Allow manual override of the defaults, e.g. if you want to use a fortran // lib compiled with gcc from MSVC #else // First we need to know what the conventions for linking // C with Fortran is on this platform/toolset #if defined(__GNUC__) || defined(__ICC) || defined(__sgi) || defined(__COMO__) || defined(__KCC) #define BIND_FORTRAN_LOWERCASE_UNDERSCORE #elif defined(__IBMCPP__) || defined(_MSC_VER) #define BIND_FORTRAN_LOWERCASE #else #error do not know how to link with fortran for the given platform #endif #endif // Next we define macro's to convert our symbols to // the current convention #if defined(BIND_FORTRAN_LOWERCASE_UNDERSCORE) #define FORTRAN_ID( id ) id##_ #elif defined(BIND_FORTRAN_LOWERCASE) #define FORTRAN_ID( id ) id #else #error do not know how to bind to fortran calling convention #endif #endif // BOOST_NUMERIC_BINDINGS_TRAITS_FORTRAN_H boost-bindings/boost/numeric/bindings/traits/matrix_raw.hpp0000644000175000017500000002706307725612606024417 0ustar andreasandreas// // Copyright (c) 2002-2003 // Toon Knapen, Kresimir Fresl, Joerg Walter // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. The authors make no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. // // #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_RAW_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_RAW_HPP #include #include #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { namespace ublas = boost::numeric::ublas; // size: template BOOST_UBLAS_INLINE int matrix_size1 (const M &m) { return (int) m.size1(); } template BOOST_UBLAS_INLINE int matrix_size2 (const M &m) { return (int) m.size2(); } #if 0 // MSVC seems to dislike overloads if there is 'generic' template template BOOST_UBLAS_INLINE int matrix_size1 (const ublas::matrix_reference &m) { return matrix_size1 (m.expression()); } template BOOST_UBLAS_INLINE int matrix_size2 (const ublas::matrix_reference &m) { return matrix_size2 (m.expression()); } #endif // 0 template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::matrix& m) { return (int) (m.size1() * m.size2()); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::c_matrix &m) { return (int) (M * N); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix &m, ublas::row_major_tag) { return (int) m.size2(); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix &m, ublas::column_major_tag) { return (int) m.size1(); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix &m) { typedef ublas::matrix matrix_t; return bindings::traits::leading_dimension (m, BOOST_UBLAS_TYPENAME matrix_t::orientation_category()); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix_reference &m) { return bindings::traits::leading_dimension (m.expression()); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix_range &m) { return bindings::traits::leading_dimension (m.data()); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::c_matrix &m) { return (int) N; } // stride: #if 0 // MSVC seems to dislike overloads if there is 'generic' template template BOOST_UBLAS_INLINE int matrix_stride1 (const M &m) { typedef typename M::functor_type functor_type; return (int) functor_type::one1 (m.size1(), m.size2()); } template BOOST_UBLAS_INLINE int matrix_stride2 (const M &m) { typedef typename M::functor_type functor_type; return (int) functor_type::one2 (m.size1(), m.size2()); } #endif // 0 template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::matrix &m) { return (int) F::one1 (m.size1(), m.size2()); } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::matrix &m) { return (int) F::one2 (m.size1(), m.size2()); } template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::matrix_reference &m) { return matrix_stride1 (m.expression()); } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::matrix_reference &m) { return matrix_stride2 (m.expression()); } template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::c_matrix &m) { return (int) N; } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::c_matrix &m) { return 1; } template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::matrix_range &m) { return matrix_stride1 (m.data()); } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::matrix_range &m) { return matrix_stride2 (m.data()); } template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::matrix_slice &m) { return (int) (m.stride1() * matrix_stride1 (m.data())); } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::matrix_slice &m) { return (int) (m.stride2() * matrix_stride2 (m.data())); } template BOOST_UBLAS_INLINE int vector_stride (const ublas::matrix_row &v) { return matrix_stride2 (v.data()); } template BOOST_UBLAS_INLINE int vector_stride (const ublas::matrix_column &v) { return matrix_stride1 (v.data()); } // storage: #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::matrix::const_pointer matrix_storage (const ublas::matrix &m) { return &m.data().begin()[0]; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::matrix::const_pointer matrix_storage_const (const ublas::matrix &m) { return &m.data().begin()[0]; } template BOOST_UBLAS_INLINE typename ublas::matrix::pointer matrix_storage (ublas::matrix &m) { return &m.data().begin()[0]; } #if 0 // MSVC seems to dislike overloads if there is 'generic' template #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const M &m) { return &m.data().begin()[0]; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const M &m) { return &m.data().begin()[0]; } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (M &m) { return &m.data().begin()[0]; } #endif // 0 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::matrix_reference &m) { return matrix_storage (m.expression ()); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::matrix_reference &m) { return matrix_storage_const (m.expression ()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::matrix_reference &m) { return matrix_storage (m.expression ()); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::c_matrix::const_pointer matrix_storage (const ublas::c_matrix &m) { return m.data(); } #endif #ifndef BOOST_MSVC // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::c_matrix::const_pointer matrix_storage_const (const ublas::c_matrix &m) { return m.data(); } template BOOST_UBLAS_INLINE typename ublas::c_matrix::pointer matrix_storage (ublas::c_matrix &m) { return m.data(); } #endif #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::matrix_range &m) { return matrix_storage (m.data()) + m.start1() * matrix_stride1 (m.data()) + m.start2() * matrix_stride2 (m.data()); } template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::matrix_slice &m) { return matrix_storage (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::matrix_range &m) { return matrix_storage_const (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::matrix_slice &m) { return matrix_storage_const (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::matrix_range &m) { return matrix_storage (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::matrix_slice &m) { return matrix_storage (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer vector_storage (const ublas::matrix_row &v) { return matrix_storage (v.data()) + v.index() * matrix_stride1 (v.data()); } template BOOST_UBLAS_INLINE typename M::const_pointer vector_storage (const ublas::matrix_column &v) { return matrix_storage (v.data()) + v.index() * matrix_stride2 (v.data()); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer vector_storage_const (const ublas::matrix_row &v) { return matrix_storage_const (v.data()) + v.index() * matrix_stride1 (v.data()); } template BOOST_UBLAS_INLINE typename M::const_pointer vector_storage_const (const ublas::matrix_column &v) { return matrix_storage_const (v.data()) + v.index() * matrix_stride2 (v.data()); } template BOOST_UBLAS_INLINE typename M::pointer vector_storage (ublas::matrix_row &v) { return matrix_storage (v.data()) + v.index() * matrix_stride1 (v.data()); } template BOOST_UBLAS_INLINE typename M::pointer vector_storage (ublas::matrix_column &v) { return matrix_storage (v.data()) + v.index() * matrix_stride2 (v.data()); } }}}} #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_NO_SYMMETRIC_TRAITS #include #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_NO_SYMMETRIC_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_RAW_HPP boost-bindings/boost/numeric/bindings/traits/matrix_traits.hpp0000644000175000017500000001100307752725703025122 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_TRAITS_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_TRAITS_HPP #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { /// There is no default implementation since there is no reasonable default. /// Most matrix libraries provide totally different functions. /// Auxiliary traits class to reduce the number of specializations. /// MType is the actual matrix type. /// MIdentifier is used to specialize the traits for a specific matrix type, e.g. /// matrix_detail_traits< ublas::matrix, ublas::matrix const > /// matrix_detail_traits< ublas::matrix, ublas::matrix > /// Note that remove_const::type == MIdentifier template struct matrix_detail_traits { typedef MIdentifier identifier_type; typedef MType matrix_type; }; /// matrix_traits<> generic version: template struct matrix_traits : matrix_detail_traits< typename boost::remove_const::type, M> { // typedefs: // matrix_structure // ordering_type // value_type // pointer // symmetric/hermitian typedefs: // uplo_type // static functions: // pointer storage() // int size1() // int size2() // int lower_bandwidth() // only banded matrix types // int upper_bandwidth() // only banded matrix types // int storage_size() // not all matrix types // int leading_dimension() // not all matrix types }; // matrix structure tags: struct general_t {}; struct symmetric_t {}; struct symmetric_packed_t {}; struct hermitian_t {}; struct hermitian_packed_t {}; struct banded_t {}; // TO DO: add triangular, etc. struct unknown_structure_t {}; // storage ordering tags: struct row_major_t {}; struct column_major_t {}; // upper/lower triangular part tags: struct upper_t {}; struct lower_t {}; /////////////////////////// // // free accessor functions // /////////////////////////// template inline typename matrix_traits::pointer matrix_storage (M& m) { return matrix_traits::storage (m); } template inline int matrix_size1 (M& m) { return matrix_traits::size1 (m); } template inline int matrix_size2 (M& m) { return matrix_traits::size2 (m); } template inline int matrix_storage_size (M& m) { return matrix_traits::storage_size (m); } template inline int matrix_stride1 (M& m) { return matrix_traits::stride1 (m); } template inline int matrix_stride2 (M& m) { return matrix_traits::stride2 (m); } template inline int matrix_upper_bandwidth (M& m) { return matrix_traits::upper_bandwidth (m); } template inline int matrix_lower_bandwidth (M& m) { return matrix_traits::lower_bandwidth (m); } template inline int leading_dimension (M& m) { return matrix_traits::leading_dimension (m); } namespace detail { inline char matrix_uplo_tag (upper_t const&) { return 'U'; } inline char matrix_uplo_tag (lower_t const&) { return 'L'; } } template inline char matrix_uplo_tag (SymmM&) { typedef typename matrix_traits::uplo_type uplo_t; return detail::matrix_uplo_tag (uplo_t()); } }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_TRAITS_HPP boost-bindings/boost/numeric/bindings/traits/sparse_traits.hpp0000644000175000017500000000726007725613452025122 0ustar andreasandreas/* * * Copyright (c) 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_SPARSE_TRAITS_H #define BOOST_NUMERIC_BINDINGS_TRAITS_SPARSE_TRAITS_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include namespace boost { namespace numeric { namespace bindings { namespace traits { /// There is no default implementation since there is no reasonable default. /// Most matrix libraries provide totally different functions. /// Auxiliary traits class to reduce the number of specializations. template struct sparse_matrix_detail_traits { typedef MIdentifier identifier_type; typedef MType matrix_type; }; /// sparse_matrix_traits<> generic version: template struct sparse_matrix_traits : sparse_matrix_detail_traits ::type, M> { // typedefs: // matrix_structure // storage_format // ordering_type // value_type // value_pointer // index_pointer // enum (or static size_t const): // index_base // static functions: // index_pointer index1_storage() // - compressed column: array of column start locations // - compressed row: array of row start locations // - coordinate, column major: column indices of nonzeros // - coordinate, row major: row indices of nonzeros // index_pointer index2_storage() // - compressed column: array of row indices of nonzeros // - compressed row: array of column indices of nonzeros // - coordinate, column major: row indices of nonzeros // - coordinate, row major: column indices of nonzeros // value_pointer value_storage() // - array of nonzeros // int size1() // int size2() // int num_nonzeros() }; // storage format tags struct compressed_t {}; struct coordinate_t {}; /////////////////////////// // // free accessor functions // /////////////////////////// template inline typename sparse_matrix_traits::index_pointer spmatrix_index1_storage (M& m) { return sparse_matrix_traits::index1_storage (m); } template inline typename sparse_matrix_traits::index_pointer spmatrix_index2_storage (M& m) { return sparse_matrix_traits::index2_storage (m); } template inline typename sparse_matrix_traits::value_pointer spmatrix_value_storage (M& m) { return sparse_matrix_traits::value_storage (m); } template inline int spmatrix_size1 (M& m) { return sparse_matrix_traits::size1 (m); } template inline int spmatrix_size2 (M& m) { return sparse_matrix_traits::size2 (m); } template inline int spmatrix_num_nonzeros (M& m) { return sparse_matrix_traits::num_nonzeros (m); } }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler sparse matrices cannot be used in bindings #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_SPARSE_TRAITS_H boost-bindings/boost/numeric/bindings/traits/std_valarray.hpp0000644000175000017500000000337207725612473024734 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_STD_VALARRAY_H #define BOOST_NUMERIC_BINDINGS_TRAITS_STD_VALARRAY_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // std::valarray<> template struct vector_detail_traits, V> : default_vector_traits { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< std::valarray, typename boost::remove_const::type >::value) ); #endif typedef std::valarray identifier_type; typedef V vector_type; typedef typename default_vector_traits::pointer pointer; static pointer storage (vector_type& va) { std::valarray& ncva = const_cast&> (va); return &ncva[0]; } }; }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler std::valarray<> cannot be used in bindings #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_STD_VALARRAY_H boost-bindings/boost/numeric/bindings/traits/std_vector.hpp0000644000175000017500000000310107725612473024403 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_STD_VECTOR_H #define BOOST_NUMERIC_BINDINGS_TRAITS_STD_VECTOR_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include namespace boost { namespace numeric { namespace bindings { namespace traits { // std::vector<> template struct vector_detail_traits, V> : default_vector_traits< V, T > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< std::vector, typename boost::remove_const::type >::value) ); #endif typedef std::vector identifier_type; typedef V vector_type; typedef typename default_vector_traits< V, T >::pointer pointer; static pointer storage (vector_type& v) { return &v.front(); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_STD_VECTOR_H boost-bindings/boost/numeric/bindings/traits/symm_herm_raw.hpp0000644000175000017500000001316007725612606025104 0ustar andreasandreas// // Copyright (c) 2002-2003 // Toon Knapen, Kresimir Fresl, Joerg Walter // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. The authors make no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. // // #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_RAW_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_RAW_HPP #include #ifndef BOOST_UBLAS_HAVE_BINDINGS # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { namespace ublas = boost::numeric::ublas; template BOOST_UBLAS_INLINE int leading_dimension (const ublas::symmetric_adaptor &m) { return bindings::traits::leading_dimension (m.data()); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::hermitian_adaptor &m) { return bindings::traits::leading_dimension (m.data()); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::symmetric_adaptor &m) { return matrix_storage_size (m.data()); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::hermitian_adaptor &m) { return matrix_storage_size (m.data()); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::symmetric_matrix &m) { return (int) ((m.size1() * (m.size1() + 1)) / 2); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::hermitian_matrix &m) { return (int) ((m.size1() * (m.size1() + 1)) / 2); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::symmetric_matrix::const_pointer matrix_storage (const ublas::symmetric_matrix &m) { return &m.data().begin()[0]; } #endif // We need data_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::symmetric_matrix::const_pointer matrix_storage_const (const ublas::symmetric_matrix &m) { return &m.data().begin()[0]; } template BOOST_UBLAS_INLINE typename ublas::symmetric_matrix::pointer matrix_storage (ublas::symmetric_matrix &m) { return &m.data().begin()[0]; } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::symmetric_adaptor &m) { return matrix_storage (m.data()); } #endif // We need data_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::symmetric_adaptor &m) { return matrix_storage_const (m.data()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::symmetric_adaptor &m) { return matrix_storage (m.data()); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::hermitian_matrix::const_pointer matrix_storage (const ublas::hermitian_matrix &m) { return &m.data().begin()[0]; } #endif // We need data_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::hermitian_matrix::const_pointer matrix_storage_const (const ublas::hermitian_matrix &m) { return &m.data().begin()[0]; } template BOOST_UBLAS_INLINE typename ublas::hermitian_matrix::pointer matrix_storage (ublas::hermitian_matrix &m) { return &m.data().begin()[0]; } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::hermitian_adaptor &m) { return matrix_storage (m.data()); } #endif // We need data_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::hermitian_adaptor &m) { return matrix_storage_const (m.data()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::hermitian_adaptor &m) { return matrix_storage (m.data()); } namespace detail { inline char m_uplo_tag (ublas::upper_tag const&) { return 'U'; } inline char m_uplo_tag (ublas::lower_tag const&) { return 'L'; } } template inline char matrix_uplo_tag (SymmM&) { typedef typename SymmM::packed_category uplo_t; return detail::m_uplo_tag (uplo_t()); } }}}} #endif boost-bindings/boost/numeric/bindings/traits/tnt.hpp0000644000175000017500000001057607725612473023052 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_TNT_H #define BOOST_NUMERIC_BINDINGS_TRAITS_TNT_H // Roldan Pozo's TNT (Template Numerical Toolkit) // see: http://math.nist.gov/tnt/index.html #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // TNT::Array1D<> template struct vector_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< TNT::Array1D, typename boost::remove_const::type >::value) ); #endif typedef TNT::Array1D identifier_type; typedef V vector_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (vector_type& v) { return &v[0]; } static int size (vector_type& v) { return v.dim(); } static int stride (vector_type& v) { return 1; } }; // TNT::Fortran_Array1D<> template struct vector_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< TNT::Fortran_Array1D, typename boost::remove_const::type >::value) ); #endif typedef TNT::Fortran_Array1D identifier_type; typedef V vector_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (vector_type& v) { return &v(1); } static int size (vector_type& v) { return v.dim(); } static int stride (vector_type& v) { return 1; } }; // TNT::Array2D<> template struct matrix_detail_traits, M> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< TNT::Array2D, typename boost::remove_const::type >::value) ); #endif typedef TNT::Array2D identifier_type; typedef M matrix_type; typedef general_t matrix_structure; typedef row_major_t ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& m) { return m[0]; } static int size1 (matrix_type& m) { return m.dim1(); } static int size2 (matrix_type& m) { return m.dim2(); } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { return m.dim2(); } }; // TNT::Fortran_Array2D<> template struct matrix_detail_traits, M> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< TNT::Fortran_Array2D, typename boost::remove_const::type >::value) ); #endif typedef TNT::Fortran_Array2D identifier_type; typedef M matrix_type; typedef general_t matrix_structure; typedef column_major_t ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& m) { return &m(1, 1); } static int size1 (matrix_type& m) { return m.dim1(); } static int size2 (matrix_type& m) { return m.dim2(); } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { return m.dim1(); } }; }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler TNT cannot be used in bindings #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_TNT_H boost-bindings/boost/numeric/bindings/traits/traits.hpp0000644000175000017500000000135607725612771023550 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_H #define BOOST_NUMERIC_BINDINGS_TRAITS_H #include #include #endif boost-bindings/boost/numeric/bindings/traits/transpose.hpp0000644000175000017500000000041707563272065024253 0ustar andreasandreas#ifndef BOOST_BINDINGS_TRANSPOSE_HPP #define BOOST_BINDINGS_TRANSPOSE_HPP namespace boost { namespace numeric { namespace bindings { namespace traits { const char NO_TRANSPOSE = 'N' ; const char TRANSPOSE = 'T' ; const char CONJUGATE = 'C' ; }}}} #endif boost-bindings/boost/numeric/bindings/traits/type.h0000644000175000017500000000164410555120524022644 0ustar andreasandreas/* * Copyright (C) 2000,2001,2002,2003 Si-Lab b.v.b.a. and Toon Knapen * * License is hereby granted to use and modify this software * as long as this copyright notice is retained and modifications * are clearly marked. * This License does not permit you to redistribute this software. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H #define BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H /* * This header defines the C types that will be mapped to * COMPLEX and COMPLEX*16 of Fortran */ #ifndef BOOST_NUMERIC_BINDINGS_USE_COMPLEX_STRUCT typedef float fcomplex_t ; typedef double dcomplex_t ; #else typedef union { float cmplx[2] ; double align_struct_ ; } fcomplex_t ; typedef struct { double cmplx[2] ; } dcomplex_t ; #endif /* BOOST_NUMERIC_BINDINGS_USE_COMPLEX_STRUCT */ /* * Define a fortran LOGICAL as a void (for now). */ typedef void logical_t ; #endif /* BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H */ boost-bindings/boost/numeric/bindings/traits/type.hpp0000644000175000017500000000210510776016571023210 0ustar andreasandreas#ifndef boost_numeric_bindings_type_hpp #define boost_numeric_bindings_type_hpp // This header provides typedefs to float complex and double complex. // This makes it possible to redefine the complex class being used. #include namespace boost { namespace numeric { namespace bindings { namespace traits { /* The types for single and double precision complex numbers. * You can use your own types if you define * BOOST_NUMERIC_BINDINGS_USE_CUSTOM_COMPLEX_TYPE. * Note that these types must have the same memory layout as the * corresponding FORTRAN types. * For that reason you can even use a different type in each translation * unit and the resulting binary will still work! */ #ifndef BOOST_NUMERIC_BINDINGS_USE_CUSTOM_COMPLEX_TYPE typedef std::complex< float > complex_f ; typedef std::complex< double > complex_d ; #endif template T real (std::complex const& c) { return std::real (c); } template T imag (std::complex const& c) { return std::imag (c); } }}}} #endif // boost_numeric_bindings_type_hpp boost-bindings/boost/numeric/bindings/traits/type_traits.hpp0000644000175000017500000000372207725613237024606 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl and Toon Knapen 2002, 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * First author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_TRAITS_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_TRAITS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { template struct type_traits { #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef Real type; typedef Real real_type; #endif }; template<> struct type_traits { typedef float type; typedef float real_type; }; template<> struct type_traits { typedef double type; typedef double real_type; }; template<> struct type_traits { typedef complex_f type; typedef float real_type; }; template<> struct type_traits { typedef complex_d type; typedef double real_type; }; inline const fcomplex_t* complex_ptr(const complex_f* c) { return reinterpret_cast( c ) ; } inline const dcomplex_t* complex_ptr(const complex_d* c) { return reinterpret_cast( c ) ; } inline fcomplex_t* complex_ptr( complex_f* c) { return reinterpret_cast< fcomplex_t*>( c ) ; } inline dcomplex_t* complex_ptr( complex_d* c) { return reinterpret_cast< dcomplex_t*>( c ) ; } }}}} #endif // BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_TRAITS_HPP boost-bindings/boost/numeric/bindings/traits/ublas_banded.hpp0000644000175000017500000001104310776160175024633 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_BANDED_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_BANDED_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #if defined (BOOST_NUMERIC_BINDINGS_FORTRAN) || !defined (BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK) # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::matrix_banded<> // When orientation_category==row_major_tag then the ublas banded format corresponds to // the LAPACK band format. // Specialization using matrix_detail_traits so that we can specialize for // matrix_detail_traits< banded, banded > // matrix_detail_traits< banded, banded const > // at once. template struct matrix_detail_traits< boost::numeric::ublas::banded_matrix, M > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif #ifdef BOOST_NUMERIC_BINDINGS_FORTRAN BOOST_STATIC_ASSERT((boost::is_same< typename F::orientation_category, boost::numeric::ublas::row_major_tag >::value)); #endif typedef boost::numeric::ublas::banded_matrix identifier_type ; typedef M matrix_type; typedef banded_t matrix_structure; typedef typename detail::ublas_ordering< typename F::orientation_category >::type ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& m) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (m.data()); } static int size1 (matrix_type& m) { return m.size1(); } static int size2 (matrix_type& m) { return m.size2(); } static int lower_bandwidth (matrix_type& m) { return m.lower() ; } static int upper_bandwidth (matrix_type& m) { return m.upper() ; } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { // g++ 2.95.4 and 3.0.4 (with -pedantic) dislike // identifier_type::functor_type::size2() //return lower_bandwidth(m) + upper_bandwidth(m) + 1 ; typedef typename identifier_type::orientation_category orientation_category; return detail::ublas_banded_ordering::leading_dimension(m) ; } // stride1 == distance (m (i, j), m (i+1, j)) static int stride1 (matrix_type& m) { typedef typename identifier_type::orientation_category orientation_category; //typedef typename detail::ublas_ordering::functor_type functor_t ; //return functor_t::one2 ( std::max(m.size1(), m.size2()), leading_dimension(m)-1 ) ; return detail::ublas_banded_ordering::stride1(m) ; } // stride2 == distance (m (i, j), m (i, j+1)) static int stride2 (matrix_type& m) { typedef typename identifier_type::orientation_category orientation_category; //typedef typename detail::ublas_ordering::functor_type functor_t ; //return functor_t::one1 ( std::max(m.size1(), m.size2()), leading_dimension(m)-1 ) ; return detail::ublas_banded_ordering::stride2(m) ; } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_BANDED_H boost-bindings/boost/numeric/bindings/traits/ublas_hermitian.hpp0000644000175000017500000001152310142140555025364 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_HERMITIAN_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_HERMITIAN_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::hermitian_matrix<> template struct matrix_detail_traits, M> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif #ifdef BOOST_BINDINGS_FORTRAN BOOST_STATIC_ASSERT((boost::is_same< typename F2::orientation_category, boost::numeric::ublas::column_major_tag >::value)); #endif typedef boost::numeric::ublas::hermitian_matrix identifier_type; typedef M matrix_type; typedef hermitian_packed_t matrix_structure; typedef typename detail::ublas_ordering< typename F2::orientation_category >::type ordering_type; typedef typename detail::ublas_uplo< F1 >::type uplo_type; typedef T value_type ; typedef typename detail::generate_const::type* pointer ; static pointer storage (matrix_type& hm) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (hm.data()); } static int size1 (matrix_type& hm) { return hm.size1(); } static int size2 (matrix_type& hm) { return hm.size2(); } static int storage_size (matrix_type& hm) { return (size1 (hm) + 1) * size2 (hm) / 2; } }; namespace detail { template int matrix_bandwidth( M const& m, upper_t ) { return matrix_traits::upper_bandwidth( m ) ; } template int matrix_bandwidth( M const& m, lower_t ) { // When the lower triangular band matrix is stored the // upper bandwidth must be zero assert( 0 == matrix_traits::upper_bandwidth( m ) ) ; return matrix_traits::lower_bandwidth( m ) ; } } // namespace detail // ublas::hermitian_adaptor<> template struct matrix_detail_traits, MA> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif typedef boost::numeric::ublas::hermitian_adaptor identifier_type; typedef MA matrix_type; typedef hermitian_t matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; typedef typename detail::ublas_uplo< F1 >::type uplo_type; typedef typename M::value_type value_type; typedef typename detail::generate_const::type* pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (matrix_type& hm) { return matrix_traits::storage (hm.data()); } static int size1 (matrix_type& hm) { return hm.size1(); } static int size2 (matrix_type& hm) { return hm.size2(); } static int storage_size (matrix_type& hm) { return size1 (hm) * size2 (hm); } static int leading_dimension (matrix_type& hm) { return matrix_traits::leading_dimension (hm.data()); } // For banded M static int upper_bandwidth(matrix_type& hm) { return detail::matrix_bandwidth( hm.data(), uplo_type() ); } static int lower_bandwidth(matrix_type& hm) { return detail::matrix_bandwidth( hm.data(), uplo_type() ); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_HERMITIAN_H boost-bindings/boost/numeric/bindings/traits/ublas_matrix.hpp0000644000175000017500000003235210602750274024721 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_MATRIX_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_MATRIX_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #if defined (BOOST_NUMERIC_BINDINGS_FORTRAN) || !defined (BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK) # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::matrix<> // Specialization using matrix_detail_traits so that we can specialize for // matrix_detail_traits< matrix, matrix > // matrix_detail_traits< matrix, matrix const > // at once. template struct matrix_detail_traits< boost::numeric::ublas::matrix, M > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif #ifdef BOOST_NUMERIC_BINDINGS_FORTRAN BOOST_STATIC_ASSERT((boost::is_same< typename F::orientation_category, boost::numeric::ublas::column_major_tag >::value)); #endif typedef boost::numeric::ublas::matrix identifier_type ; typedef M matrix_type; typedef general_t matrix_structure; typedef typename detail::ublas_ordering< typename F::orientation_category >::type ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; typedef typename identifier_type::orientation_category orientation_category; typedef typename detail::ublas_ordering::functor_type functor_t ; static pointer storage (matrix_type& m) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (m.data()); } static int size1 (matrix_type& m) { return m.size1(); } static int size2 (matrix_type& m) { return m.size2(); } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { // g++ 2.95.4 and 3.0.4 (with -pedantic) dislike // identifier_type::functor_type::size2() //return functor_t::size_m (m.size1(), m.size2()); return detail::ublas_ordering::leading_dimension( m ) ; } // stride1 == distance (m (i, j), m (i+1, j)) static int stride1 (matrix_type& m) { //return functor_t::one1 (m.size1(), m.size2()); return detail::ublas_ordering::stride1( m ) ; } // stride2 == distance (m (i, j), m (i, j+1)) static int stride2 (matrix_type& m) { //return functor_t::one2 (m.size1(), m.size2()); return detail::ublas_ordering::stride2( m ) ; } }; // ublas::matrix_reference<> template struct matrix_detail_traits, MR > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_reference, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_reference identifier_type; typedef MR matrix_type; typedef typename matrix_traits::matrix_structure matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; typedef typename M::value_type value_type; typedef typename detail::generate_const::type* pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (matrix_type& mr) { return matrix_traits::storage (mr.expression()); } static int size1 (matrix_type& mr) { return mr.size1(); } static int size2 (matrix_type& mr) { return mr.size2(); } static int leading_dimension (matrix_type& mr) { return matrix_traits::leading_dimension (mr.expression()); } static int stride1 (matrix_type& mr) { return matrix_traits::stride1 (mr.expression()); } static int stride2 (matrix_type& mr) { return matrix_traits::stride2 (mr.expression()); } // Only for banded matrices static int upper_bandwidth(matrix_type& mr) { return matrix_traits::upper_bandwidth(mr.expression()); } static int lower_bandwidth(matrix_type& mr) { return matrix_traits::lower_bandwidth(mr.expression()); } }; // ublas::matrix_range<> template struct matrix_detail_traits, MR > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_range, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_range identifier_type; typedef MR matrix_type; typedef typename matrix_traits::matrix_structure matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; private: typedef typename detail::generate_const::type m_type; public: typedef typename matrix_traits::value_type value_type; typedef typename matrix_traits::pointer pointer ; public: static pointer storage (matrix_type& mr) { m_type& mt = mr.data(); pointer ptr = matrix_traits::storage (mt); ptr += mr.start1() * matrix_traits::stride1 (mt); ptr += mr.start2() * matrix_traits::stride2 (mt); return ptr; } static int size1 (matrix_type& mr) { return mr.size1(); } static int size2 (matrix_type& mr) { return mr.size2(); } static int leading_dimension (matrix_type& mr) { return matrix_traits::leading_dimension (mr.data()); } static int stride1 (matrix_type& mr) { return matrix_traits::stride1 (mr.data()); } static int stride2 (matrix_type& mr) { return matrix_traits::stride2 (mr.data()); } // For band matrices only static int upper_bandwidth (matrix_type& mr) { return matrix_traits::upper_bandwidth(mr.data()); } static int lower_bandwidth (matrix_type& mr) { return matrix_traits::lower_bandwidth(mr.data()); } }; // ublas::matrix_slice<> template struct matrix_detail_traits, MS > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_slice, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_slice identifier_type; typedef MS matrix_type; typedef unknown_structure_t matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; typedef typename M::value_type value_type; typedef typename detail::generate_const::type* pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (matrix_type& ms) { m_type& mt = ms.data(); pointer ptr = matrix_traits::storage (mt); ptr += ms.start1() * matrix_traits::stride1 (mt); ptr += ms.start2() * matrix_traits::stride2 (mt); return ptr; } static int size1 (matrix_type& ms) { return ms.size1(); } static int size2 (matrix_type& ms) { return ms.size2(); } private: static int ld (int s1, int s2, boost::numeric::ublas::row_major_tag) { return s1; } static int ld (int s1, int s2, boost::numeric::ublas::column_major_tag) { return s2; } public: static int leading_dimension (matrix_type& ms) { typedef typename identifier_type::orientation_category oc_t; return ld (ms.stride1(), ms.stride2(), oc_t()) * matrix_traits::leading_dimension (ms.data()); } static int stride1 (matrix_type& ms) { return ms.stride1() * matrix_traits::stride1 (ms.data()); } static int stride2 (matrix_type& ms) { return ms.stride2() * matrix_traits::stride2 (ms.data()); } }; // matrix_row<> and matrix_column<> are vectors: // ublas::matrix_row<> template struct vector_detail_traits< boost::numeric::ublas::matrix_row, MR > : default_vector_traits< MR, typename M::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_row, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_row identifier_type; typedef MR vector_type; typedef typename M::value_type value_type; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (vector_type& mr) { m_type& mt = mr.data(); pointer ptr = matrix_traits::storage (mt); ptr += mr.index() * matrix_traits::stride1 (mt); return ptr; } static int stride (vector_type& mr) { return matrix_traits::stride2 (mr.data()); } }; // ublas::matrix_column<> template struct vector_detail_traits< boost::numeric::ublas::matrix_column, MC > : default_vector_traits< MC, typename M::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_column, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_column identifier_type; typedef MC vector_type; typedef typename M::value_type value_type ; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (vector_type& mc) { m_type& mt = mc.data(); pointer ptr = matrix_traits::storage (mt); ptr += mc.index() * matrix_traits::stride2 (mt); return ptr; } static int stride (vector_type& mc) { return matrix_traits::stride1 (mc.data()); } }; #ifndef BOOST_NUMERIC_BINDINGS_FORTRAN // (undocumented) ublas::c_matrix<> template struct matrix_detail_traits< boost::numeric::ublas::c_matrix, Matr > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif typedef boost::numeric::ublas::c_matrix identifier_type ; typedef Matr matrix_type; typedef general_t matrix_structure; typedef row_major_t ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& m) { return m.data(); } static int size1 (matrix_type& m) { return m.size1(); } static int size2 (matrix_type& m) { return m.size2(); } static int storage_size (matrix_type& m) { return M * N; } static int leading_dimension (matrix_type& m) { return N; } // stride1 == distance (m (i, j), m (i+1, j)) static int stride1 (matrix_type& m) { return N; } // stride2 == distance (m (i, j), m (i, j+1)) static int stride2 (matrix_type& m) { return 1; } }; #endif // BOOST_NUMERIC_BINDINGS_FORTRAN // TO DO: matrix_vector_range<>, matrix_vector_slice<> }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_MATRIX_H boost-bindings/boost/numeric/bindings/traits/ublas_sparse.hpp0000644000175000017500000001166710226750103024711 0ustar andreasandreas/* * * Copyright (c) 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SPARSE_MATRIX_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SPARSE_MATRIX_H #include #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::compressed_matrix<> template struct sparse_matrix_detail_traits< boost::numeric::ublas::compressed_matrix, MType > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::compressed_matrix, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::compressed_matrix identifier_type; typedef MType matrix_type; typedef general_t matrix_structure; typedef compressed_t storage_format; typedef typename detail::ublas_ordering< typename F::orientation_category >::type ordering_type; typedef F layout_type; typedef T value_type; private: typedef typename detail::generate_const::type val_array_t; typedef typename detail::generate_const::type idx_array_t; public: typedef typename vector_traits::pointer value_pointer; typedef typename vector_traits::pointer index_pointer; BOOST_STATIC_CONSTANT (std::size_t, index_base = IB); static index_pointer index1_storage (matrix_type& cm) { assert (cm.filled1() == layout_type::size1 (cm.size1(), cm.size2()) + 1); return vector_traits::storage (cm.index1_data()); } static index_pointer index2_storage (matrix_type& cm) { return vector_traits::storage (cm.index2_data()); } static value_pointer value_storage (matrix_type& cm) { return vector_traits::storage (cm.value_data()); } static int size1 (matrix_type& cm) { return cm.size1(); } static int size2 (matrix_type& cm) { return cm.size2(); } static int num_nonzeros (matrix_type& cm) { return cm.nnz(); // Joerg, this isn't very intuitive :o( // return cm.non_zeros(); } }; // ublas::coordinate_matrix<> template struct sparse_matrix_detail_traits< boost::numeric::ublas::coordinate_matrix, MType > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::coordinate_matrix, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::coordinate_matrix identifier_type; typedef MType matrix_type; typedef general_t matrix_structure; typedef coordinate_t storage_format; typedef typename detail::ublas_ordering< typename F::orientation_category >::type ordering_type; typedef T value_type; private: typedef typename detail::generate_const::type val_array_t; typedef typename detail::generate_const::type idx_array_t; public: typedef typename vector_traits::pointer value_pointer; typedef typename vector_traits::pointer index_pointer; BOOST_STATIC_CONSTANT (std::size_t, index_base = IB); static index_pointer index1_storage (matrix_type& cm) { return vector_traits::storage (cm.index1_data()); } static index_pointer index2_storage (matrix_type& cm) { return vector_traits::storage (cm.index2_data()); } static value_pointer value_storage (matrix_type& cm) { return vector_traits::storage (cm.value_data()); } static int size1 (matrix_type& cm) { return cm.size1(); } static int size2 (matrix_type& cm) { return cm.size2(); } static int num_nonzeros (matrix_type& cm) { return cm.nnz(); // Joerg, this isn't very intuitive :o( // return cm.non_zeros(); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SPARSE_MATRIX_H boost-bindings/boost/numeric/bindings/traits/ublas_symmetric.hpp0000644000175000017500000001012610142140555025416 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SYMMETRIC_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SYMMETRIC_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::symmetric_matrix<> template struct matrix_detail_traits, M> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif #ifdef BOOST_BINDINGS_FORTRAN BOOST_STATIC_ASSERT((boost::is_same< typename F2::orientation_category, boost::numeric::ublas::column_major_tag >::value)); #endif typedef boost::numeric::ublas::symmetric_matrix identifier_type; typedef M matrix_type; typedef symmetric_packed_t matrix_structure; typedef typename detail::ublas_ordering< typename F2::orientation_category >::type ordering_type; typedef typename detail::ublas_uplo< F1 >::type uplo_type; typedef T value_type ; typedef typename detail::generate_const::type* pointer ; static pointer storage (matrix_type& sm) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (sm.data()); } static int size1 (matrix_type& sm) { return sm.size1(); } static int size2 (matrix_type& sm) { return sm.size2(); } static int storage_size (matrix_type& sm) { return (size1 (sm) + 1) * size2 (sm) / 2; } }; // ublas::symmetric_adaptor<> template struct matrix_detail_traits, MA> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif typedef boost::numeric::ublas::symmetric_adaptor identifier_type; typedef MA matrix_type; typedef symmetric_t matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; typedef typename detail::ublas_uplo< F1 >::type uplo_type; typedef typename M::value_type value_type; typedef typename detail::generate_const::type* pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (matrix_type& sm) { return matrix_traits::storage (sm.data()); } static int size1 (matrix_type& sm) { return sm.size1(); } static int size2 (matrix_type& sm) { return sm.size2(); } static int storage_size (matrix_type& sm) { return size1 (sm) * size2 (sm); } static int leading_dimension (matrix_type& sm) { return matrix_traits::leading_dimension (sm.data()); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SYMMETRIC_H boost-bindings/boost/numeric/bindings/traits/ublas_vector.hpp0000644000175000017500000001347107725613132024723 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::vector<> template struct vector_detail_traits< boost::numeric::ublas::vector, V > : default_vector_traits< V, T > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector identifier_type; typedef V vector_type; typedef typename default_vector_traits< V, T >::pointer pointer; static pointer storage (vector_type& v) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (v.data()); } }; // ublas::vector_reference<> template struct vector_detail_traits< boost::numeric::ublas::vector_reference, VR > : default_vector_traits< VR, typename V::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector_reference, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector_reference identifier_type; typedef VR vector_type; typedef typename V::value_type value_type ; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type vct_t; public: static pointer storage (vector_type& v) { return vector_traits::storage (v.expression()); } static int stride (vector_type& v) { return vector_traits::stride (v.expression()); } }; // ublas::vector_range<> template struct vector_detail_traits< boost::numeric::ublas::vector_range, VR > : default_vector_traits< VR, typename V::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector_range, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector_range identifier_type; typedef VR vector_type; typedef typename V::value_type value_type ; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type v_type; public: static pointer storage (vector_type& vr) { pointer ptr = vector_traits::storage (vr.data()); ptr += vr.start() * vector_traits::stride (vr.data()); return ptr; } static int stride (vector_type& vr) { return vector_traits::stride (vr.data()); } }; // ublas::vector_slice<> template struct vector_detail_traits, VS > : default_vector_traits< VS, typename V::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector_slice, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector_slice identifier_type; typedef VS vector_type; typedef typename V::value_type value_type ; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type v_type; public: static pointer storage (vector_type& vs) { pointer ptr = vector_traits::storage (vs.data()); ptr += vs.start() * vector_traits::stride (vs.data()); return ptr; } static int stride (vector_type& vs) { return vs.stride() * vector_traits::stride (vs.data()); } }; #ifndef BOOST_NUMERIC_BINDINGS_FORTRAN // (undocumented) ublas::c_vector<> template struct vector_detail_traits< boost::numeric::ublas::c_vector, V > : default_vector_traits< V, T > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::c_vector, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::c_vector identifier_type; typedef V vector_type; typedef typename default_vector_traits::pointer pointer; static pointer storage (vector_type& v) { return v.data(); } }; #endif // BOOST_NUMERIC_BINDINGS_FORTRAN }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_H boost-bindings/boost/numeric/bindings/traits/ublas_vector2.hpp0000644000175000017500000001106210040734374024773 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_AS_MATRIX_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_AS_MATRIX_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::vector<> treated as matrix (nx1) template struct matrix_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector identifier_type; typedef V matrix_type; typedef general_t matrix_structure; typedef column_major_t ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& v) { typedef typename detail::generate_const::type array_type; return vector_traits::storage (v.data()); } static int size1 (matrix_type& v) { return v.size(); } static int size2 (matrix_type&) { return 1; } static int storage_size (matrix_type& v) { return v.size(); } static int leading_dimension (matrix_type& v) { return v.size(); } }; // ublas::vector_range<> treated as matrix (nx1) template struct matrix_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector_range, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector_range identifier_type; typedef V matrix_type; typedef general_t matrix_structure; typedef column_major_t ordering_type; typedef typename T::value_type value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& v) { return vector_traits::storage (v); } static int size1 (matrix_type& v) { return v.size(); } static int size2 (matrix_type&) { return 1; } static int storage_size (matrix_type& v) { return v.size(); } static int leading_dimension (matrix_type& v) { return v.size(); } }; #ifndef BOOST_NUMERIC_BINDINGS_FORTRAN // (undocumented) ublas::c_vector<> template struct matrix_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::c_vector, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::c_vector identifier_type; typedef V matrix_type; typedef general_t matrix_structure; typedef row_major_t ordering_type; // consistent with c_matrix<> typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& v) { return v.data(); } static int size1 (matrix_type&) { return 1; } static int size2 (matrix_type& v) { return v.size(); } static int storage_size (matrix_type&) { return N; } static int leading_dimension (matrix_type&) { return N; } }; #endif // BOOST_NUMERIC_BINDINGS_FORTRAN }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler ublas::vector<> cannot be used as matrix #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_AS_MATRIX_H boost-bindings/boost/numeric/bindings/traits/vector_raw.hpp0000644000175000017500000002144710116011311024363 0ustar andreasandreas// // Copyright (c) 2002,2003,2004 // Toon Knapen, Kresimir Fresl, Joerg Walter, Karl Meerbergen // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. The authors make no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. // // #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_RAW_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_RAW_HPP #include #include #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { template BOOST_UBLAS_INLINE int vector_size (const V &v) { return (int) v.size(); } //////////////////////////////////////////////////////////////// // ublas::vector<> etc. namespace ublas = boost::numeric::ublas; #if 0 // MSVC seems to dislike overloads if there is `generic' template template BOOST_UBLAS_INLINE int vector_size (const ublas::vector_reference &v) { return vector_size (v.expression()); } #endif #if 0 // MSVC seems to dislike overloads if there is `generic' template template BOOST_UBLAS_INLINE int vector_stride (const V &v) { return 1; } #endif template BOOST_UBLAS_INLINE int vector_stride (const ublas::vector &v) { return 1; } template BOOST_UBLAS_INLINE int vector_stride (const ublas::vector_reference &v) { return (int) vector_stride (v.expression()); } template BOOST_UBLAS_INLINE int vector_stride (const ublas::c_vector &v) { return 1; } template int vector_stride (const ublas::vector_slice&); template BOOST_UBLAS_INLINE int vector_stride (const ublas::vector_range &v) { return (int) vector_stride (v.data()); } template BOOST_UBLAS_INLINE int vector_stride (const ublas::vector_slice &v) { return (int) (v.stride() * vector_stride (v.data())); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::vector::value_type const* vector_storage (const ublas::vector &v) { return &v.data().begin()[0]; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::vector::value_type const* vector_storage_const (const ublas::vector &v) { return &v.data().begin()[0]; } template BOOST_UBLAS_INLINE typename ublas::vector::value_type* vector_storage (ublas::vector &v) { return &v.data().begin()[0]; } #if 0 // MSVC seems to dislike overloads if there is `generic' template #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename V::const_pointer vector_storage (const V &v) { return &v.data().begin()[0]; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename V::const_pointer vector_storage_const (const V &v) { return &v.data().begin()[0]; } template BOOST_UBLAS_INLINE typename V::pointer vector_storage (V &v) { return &v.data().begin()[0]; } #endif #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage (const ublas::vector_reference &v) { return vector_storage (v.expression()); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage_const (const ublas::vector_reference &v) { return vector_storage_const (v.expression()); } template BOOST_UBLAS_INLINE typename V::value_type* vector_storage (ublas::vector_reference &v) { return vector_storage (v.expression()); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::c_vector::value_type const* vector_storage (const ublas::c_vector &v) { return v.data(); } #endif #ifndef BOOST_MSVC // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::c_vector::value_type const* vector_storage_const (const ublas::c_vector &v) { return v.data(); } template BOOST_UBLAS_INLINE typename ublas::c_vector::value_type* vector_storage (ublas::c_vector &v) { return v.data(); } #endif #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template typename V::value_type const* vector_storage (const ublas::vector_slice&); template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage (const ublas::vector_range &v) { typename V::value_type const* ptr = vector_storage (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage (const ublas::vector_slice &v) { typename V::value_type const* ptr = vector_storage (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template typename V::value_type const* vector_storage_const (const ublas::vector_slice&); template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage_const (const ublas::vector_range &v) { typename V::value_type const* ptr = vector_storage_const (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage_const (const ublas::vector_slice &v) { typename V::value_type const* ptr = vector_storage_const (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } template typename V::value_type* vector_storage (ublas::vector_slice&); template BOOST_UBLAS_INLINE typename V::value_type* vector_storage (ublas::vector_range &v) { typename V::value_type* ptr = vector_storage (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } template BOOST_UBLAS_INLINE typename V::value_type* vector_storage (ublas::vector_slice &v) { typename V::value_type* ptr = vector_storage (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } ////////////////////////////////////////////////////////////////// // std::vector<> template BOOST_UBLAS_INLINE int vector_stride (const std::vector &v) { return 1; } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename std::vector::value_type const* vector_storage (const std::vector &v) { return &v.front(); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename std::vector::value_type const* vector_storage_const (const std::vector &v) { return &v.front(); } template BOOST_UBLAS_INLINE typename std::vector::value_type* vector_storage (std::vector &v) { return &v.front(); } ////////////////////////////////////////////////////////////////// // bindings::traits::detail::array<> template BOOST_UBLAS_INLINE int vector_stride (const detail::array &a) { return 1; } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE const T* vector_storage (const detail::array &a) { return a.storage(); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE const T* vector_storage_const (const detail::array &a) { return a.storage(); } template BOOST_UBLAS_INLINE T* vector_storage (detail::array &a) { return a.storage(); } }}}} #endif boost-bindings/boost/numeric/bindings/traits/vector_traits.hpp0000644000175000017500000000633510360750652025122 0ustar andreasandreas/* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_TRAITS_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_TRAITS_HPP #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { /// default_vector_traits is just a base-class that can be /// used as the default vector_traits and the different /// specialisation to automatically define most of the /// functions. template struct default_vector_traits { typedef T value_type; typedef typename detail::generate_const::type* pointer; // if V is const, pointer will be a const value_type* static pointer storage (V& v) { return &v[0]; } static int size (V& v) { return static_cast(v.size()); } static int stride (V&) { return 1; } }; // vector_detail_traits is used to implement specializations of vector_traits. // VIdentifier is the vector_type without const, while VType can have a const. // VIdentifier is used to write template specializations for VType and const VType. // e.g. vector_detail_traits< std::vector, std::vector const > // e.g. vector_detail_traits< std::vector, std::vector > // Note that boost::remove_const::type == VIdentifier. template struct vector_detail_traits : default_vector_traits { typedef VIdentifier identifier_type; typedef VType vector_type; }; // vector_traits<> generic version: template struct vector_traits : vector_detail_traits< typename boost::remove_const::type, V > {}; /////////////////////////// // // free accessor functions: // /////////////////////////// template inline typename vector_traits::pointer vector_storage (V& v) { return vector_traits::storage (v); } template inline int vector_size (V& v) { return vector_traits::size (v); } template inline int vector_stride (V& v) { return vector_traits::stride (v); } }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_TRAITS_HPP boost-bindings/boost/numeric/bindings/umfpack/0000755000175000017500000000000010776011453021632 5ustar andreasandreasboost-bindings/boost/numeric/bindings/umfpack/umfpack.hpp0000644000175000017500000011475007725611464024011 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ /* for UMFPACK Copyright, License and Availability see umfpack_inc.hpp */ #ifndef BOOST_NUMERIC_BINDINGS_UMFPACK_HPP #define BOOST_NUMERIC_BINDINGS_UMFPACK_HPP #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace umfpack { template struct symbolic_type : private noncopyable { void *ptr; ~symbolic_type() { if (ptr) detail::free_symbolic (T(), 0, &ptr); } void free() { if (ptr) detail::free_symbolic (T(), 0, &ptr); ptr = 0; } }; template void free (symbolic_type& s) { s.free(); } template struct numeric_type : private noncopyable { void *ptr; ~numeric_type() { if (ptr) detail::free_numeric (T(), 0, &ptr); } void free() { if (ptr) detail::free_numeric (T(), 0, &ptr); ptr = 0; } }; template void free (numeric_type& n) { n.free(); } template struct control_type : private noncopyable { double ptr[UMFPACK_CONTROL]; control_type() { detail::defaults (T(), 0, ptr); } double operator[] (int i) const { return ptr[i]; } double& operator[] (int i) { return ptr[i]; } void defaults() { detail::defaults (T(), 0, ptr); } }; template void defaults (control_type& c) { c.defaults(); } template struct info_type : private noncopyable { double ptr[UMFPACK_INFO]; double operator[] (int i) const { return ptr[i]; } double& operator[] (int i) { return ptr[i]; } }; ///////////////////////////////////// // solving system of linear equations ///////////////////////////////////// // symbolic /* * Given nonzero pattern of a sparse matrix A in column-oriented form, * umfpack_*_symbolic performs a column pre-ordering to reduce fill-in * (using COLAMD or AMD) and a symbolic factorisation. This is required * before the matrix can be numerically factorised with umfpack_*_numeric. */ namespace detail { template inline int symbolic (traits::compressed_t, MatrA const& A, void **Symbolic, double const* Control = 0, double* Info = 0) { return detail::symbolic (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Symbolic, Control, Info); } template inline int symbolic (traits::compressed_t, MatrA const& A, QVec const& Qinit, void **Symbolic, double const* Control = 0, double* Info = 0) { return detail::qsymbolic (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), traits::vector_storage (Qinit), Symbolic, Control, Info); } template inline int symbolic (traits::coordinate_t, MatrA const& A, void **Symbolic, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Ai (nnz); if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; int status = detail::triplet_to_col (n_row, n_col, nnz, Ti, Tj, static_cast (0), Ap.storage(), Ai.storage(), static_cast (0), 0); if (status != UMFPACK_OK) return status; return detail::symbolic (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), Symbolic, Control, Info); } template inline int symbolic (traits::coordinate_t, MatrA const& A, QVec const& Qinit, void **Symbolic, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Ai (nnz); if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; int status = detail::triplet_to_col (n_row, n_col, nnz, Ti, Tj, static_cast (0), Ap.storage(), Ai.storage(), static_cast (0), 0); if (status != UMFPACK_OK) return status; return detail::qsymbolic (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), traits::vector_storage (Qinit), Symbolic, Control, Info); } } // detail template inline int symbolic (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif return detail::symbolic (storage_f(), A, &Symbolic.ptr, Control, Info); } template inline int symbolic (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return symbolic (A, Symbolic, Control.ptr, Info.ptr); } template inline int symbolic (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return symbolic (A, Symbolic, Control.ptr); } template inline int symbolic (MatrA const& A, QVec const& Qinit, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif assert (traits::spmatrix_size2 (A) == traits::vector_size (Qinit)); return detail::symbolic (storage_f(), A, Qinit, &Symbolic.ptr, Control, Info); } template inline int symbolic (MatrA const& A, QVec const& Qinit, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return symbolic (A, Qinit, Symbolic, Control.ptr, Info.ptr); } template inline int symbolic (MatrA const& A, QVec const& Qinit, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return symbolic (A, Qinit, Symbolic, Control.ptr); } // numeric /* * Given a sparse matrix A in column-oriented form, and a symbolic analysis * computed by umfpack_*_*symbolic, the umfpack_*_numeric routine performs * the numerical factorisation, PAQ=LU, PRAQ=LU, or P(R\A)Q=LU, where P * and Q are permutation matrices (represented as permutation vectors), * R is the row scaling, L is unit-lower triangular, and U is upper * triangular. This is required before the system Ax=b (or other related * linear systems) can be solved. */ namespace detail { template inline int numeric (traits::compressed_t, MatrA const& A, void *Symbolic, void** Numeric, double const* Control = 0, double* Info = 0) { return detail::numeric (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Symbolic, Numeric, Control, Info); } template inline int numeric (traits::coordinate_t, MatrA const& A, void *Symbolic, void** Numeric, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Ai (nnz); if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; int status = detail::triplet_to_col (n_row, n_col, nnz, Ti, Tj, static_cast (0), Ap.storage(), Ai.storage(), static_cast (0), 0); if (status != UMFPACK_OK) return status; return detail::numeric (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), Symbolic, Numeric, Control, Info); } } // detail template inline int numeric (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type > const& Symbolic, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif return detail::numeric (storage_f(), A, Symbolic.ptr, &Numeric.ptr, Control, Info); } template inline int numeric (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type > const& Symbolic, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { // g++ (3.2) is unable to distinguish // function numeric() and namespace boost::numeric ;o) return umfpack::numeric (A, Symbolic, Numeric, Control.ptr, Info.ptr); } template inline int numeric (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type > const& Symbolic, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return umfpack::numeric (A, Symbolic, Numeric, Control.ptr); } // factor /* * symbolic and numeric */ namespace detail { template inline int factor (traits::compressed_t, MatrA const& A, void** Numeric, double const* Control = 0, double* Info = 0) { symbolic_type::value_type> Symbolic; int status; status = detail::symbolic (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), &Symbolic.ptr, Control, Info); if (status != UMFPACK_OK) return status; return detail::numeric (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Symbolic.ptr, Numeric, Control, Info); } template inline int factor (traits::coordinate_t, MatrA const& A, void** Numeric, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Ai (nnz); if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; int status = detail::triplet_to_col (n_row, n_col, nnz, Ti, Tj, static_cast (0), Ap.storage(), Ai.storage(), static_cast (0), 0); if (status != UMFPACK_OK) return status; symbolic_type::value_type> Symbolic; status = detail::symbolic (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), &Symbolic.ptr, Control, Info); if (status != UMFPACK_OK) return status; return detail::numeric (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), Symbolic.ptr, Numeric, Control, Info); } } // detail template inline int factor (MatrA const& A, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif return detail::factor (storage_f(), A, &Numeric.ptr, Control, Info); } template inline int factor (MatrA const& A, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return factor (A, Numeric, Control.ptr, Info.ptr); } template inline int factor (MatrA const& A, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return factor (A, Numeric, Control.ptr); } // solve /* * Given LU factors computed by umfpack_*_numeric and the right-hand-side, * B, solve a linear system for the solution X. Iterative refinement is * optionally performed. Only square systems are handled. */ namespace detail { template inline int solve (traits::compressed_t, int sys, MatrA const& A, VecX& X, VecB const& B, void *Numeric, double const* Control = 0, double* Info = 0) { return detail::solve (sys, traits::spmatrix_size1 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), traits::vector_storage (X), traits::vector_storage (B), Numeric, Control, Info); } template inline int solve (traits::coordinate_t, int sys, MatrA const& A, VecX& X, VecB const& B, void *Numeric, double const* Control = 0, double* Info = 0) { int n = traits::spmatrix_size1 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Ai (nnz); if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; int status = detail::triplet_to_col (n, n, nnz, Ti, Tj, static_cast (0), Ap.storage(), Ai.storage(), static_cast (0), 0); if (status != UMFPACK_OK) return status; return detail::solve (sys, n, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), traits::vector_storage (X), traits::vector_storage (B), Numeric, Control, Info); } } // detail template inline int solve (int sys, MatrA const& A, VecX& X, VecB const& B, numeric_type< typename traits::sparse_matrix_traits::value_type > const& Numeric, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif assert (traits::spmatrix_size1 (A) == traits::spmatrix_size1 (A)); assert (traits::spmatrix_size2 (A) == traits::vector_size (X)); assert (traits::spmatrix_size2 (A) == traits::vector_size (B)); return detail::solve (storage_f(), sys, A, X, B, Numeric.ptr, Control, Info); } template inline int solve (int sys, MatrA const& A, VecX& X, VecB const& B, numeric_type< typename traits::sparse_matrix_traits::value_type > const& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return solve (sys, A, X, B, Numeric, Control.ptr, Info.ptr); } template inline int solve (int sys, MatrA const& A, VecX& X, VecB const& B, numeric_type< typename traits::sparse_matrix_traits::value_type > const& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return solve (sys, A, X, B, Numeric, Control.ptr); } template inline int solve (MatrA const& A, VecX& X, VecB const& B, numeric_type< typename traits::sparse_matrix_traits::value_type > const& Numeric, double const* Control = 0, double* Info = 0) { return solve (UMFPACK_A, A, X, B, Numeric, Control, Info); } template inline int solve (MatrA const& A, VecX& X, VecB const& B, numeric_type< typename traits::sparse_matrix_traits::value_type > const& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return solve (UMFPACK_A, A, X, B, Numeric, Control.ptr, Info.ptr); } template inline int solve (MatrA const& A, VecX& X, VecB const& B, numeric_type< typename traits::sparse_matrix_traits::value_type > const& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return solve (UMFPACK_A, A, X, B, Numeric, Control.ptr); } // umf_solve /* * symbolic, numeric and solve */ namespace detail { template inline int umf_solve (traits::compressed_t, MatrA const& A, VecX& X, VecB const& B, double const* Control = 0, double* Info = 0) { symbolic_type::value_type> Symbolic; numeric_type::value_type> Numeric; int status; status = detail::symbolic (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), &Symbolic.ptr, Control, Info); if (status != UMFPACK_OK) return status; status = detail::numeric (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Symbolic.ptr, &Numeric.ptr, Control, Info); if (status != UMFPACK_OK) return status; return detail::solve (UMFPACK_A, traits::spmatrix_size1 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), traits::vector_storage (X), traits::vector_storage (B), Numeric.ptr, Control, Info); } template inline int umf_solve (traits::coordinate_t, MatrA const& A, VecX& X, VecB const& B, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Ai (nnz); if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; int status = detail::triplet_to_col (n_row, n_col, nnz, Ti, Tj, static_cast (0), Ap.storage(), Ai.storage(), static_cast (0), 0); if (status != UMFPACK_OK) return status; symbolic_type::value_type> Symbolic; numeric_type::value_type> Numeric; status = detail::symbolic (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), &Symbolic.ptr, Control, Info); if (status != UMFPACK_OK) return status; status = detail::numeric (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), Symbolic.ptr, &Numeric.ptr, Control, Info); if (status != UMFPACK_OK) return status; return detail::solve (UMFPACK_A, n_row, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), traits::vector_storage (X), traits::vector_storage (B), Numeric.ptr, Control, Info); } } // detail template inline int umf_solve (MatrA const& A, VecX& X, VecB const& B, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif assert (traits::spmatrix_size1 (A) == traits::spmatrix_size1 (A)); assert (traits::spmatrix_size2 (A) == traits::vector_size (X)); assert (traits::spmatrix_size2 (A) == traits::vector_size (B)); return detail::umf_solve (storage_f(), A, X, B, Control, Info); } template inline int umf_solve (MatrA const& A, VecX& X, VecB const& B, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return umf_solve (A, X, B, Control.ptr, Info.ptr); } template inline int umf_solve (MatrA const& A, VecX& X, VecB const& B, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return umf_solve (A, X, B, Control.ptr); } /////////////////////// // matrix manipulations /////////////////////// // scale template inline int scale (VecX& X, VecB const& B, numeric_type< typename traits::vector_traits::value_type > const& Numeric) { return detail::scale (traits::vector_size (B), traits::vector_storage (X), traits::vector_storage (B), Numeric.ptr); } //////////// // reporting //////////// // report status template inline void report_status (control_type const& Control, int status) { detail::report_status (T(), 0, Control.ptr, status); } #if 0 template inline void report_status (int printing_level, int status) { control_type Control; Control[UMFPACK_PRL] = printing_level; detail::report_status (T(), 0, Control.ptr, status); } template inline void report_status (int status) { control_type Control; detail::report_status (T(), 0, Control.ptr, status); } #endif // report control template inline void report_control (control_type const& Control) { detail::report_control (T(), 0, Control.ptr); } // report info template inline void report_info (control_type const& Control, info_type const& Info) { detail::report_info (T(), 0, Control.ptr, Info.ptr); } #if 0 template inline void report_info (int printing_level, info_type const& Info) { control_type Control; Control[UMFPACK_PRL] = printing_level; detail::report_info (T(), 0, Control.ptr, Info.ptr); } template inline void report_info (info_type const& Info) { control_type Control; detail::report_info (T(), 0, Control.ptr, Info.ptr); } #endif // report matrix (compressed column and coordinate) namespace detail { template inline int report_matrix (traits::compressed_t, MatrA const& A, double const* Control) { return detail::report_matrix (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), 1, Control); } template inline int report_matrix (traits::coordinate_t, MatrA const& A, double const* Control) { return detail::report_triplet (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_num_nonzeros (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Control); } } // detail template inline int report_matrix (MatrA const& A, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif return detail::report_matrix (storage_f(), A, Control.ptr); } // report vector template inline int report_vector (VecX const& X, control_type< typename traits::vector_traits::value_type > const& Control) { return detail::report_vector (traits::vector_size (X), traits::vector_storage (X), Control.ptr); } // report numeric template inline int report_numeric (numeric_type const& Numeric, control_type const& Control) { return detail::report_numeric (T(), 0, Numeric.ptr, Control.ptr); } // report symbolic template inline int report_symbolic (symbolic_type const& Symbolic, control_type const& Control) { return detail::report_symbolic (T(), 0, Symbolic.ptr, Control.ptr); } // report permutation vector template inline int report_permutation (VecP const& Perm, control_type const& Control) { return detail::report_perm (T(), 0, traits::vector_storage (Perm), Control.ptr); } }}}} #endif // BOOST_NUMERIC_BINDINGS_UMFPACK_HPP boost-bindings/boost/numeric/bindings/umfpack/umfpack_inc.hpp0000644000175000017500000000405610664336554024637 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ /***********************************************************************/ /* UMFPACK Copyright, License and Availability */ /***********************************************************************/ /* * * UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. * Davis. All Rights Reserved. * * UMFPACK License: * * Your use or distribution of UMFPACK or any modified version of * UMFPACK implies that you agree to this License. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY * EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program, provided * that the Copyright, this License, and the Availability of the original * version is retained on all copies. User documentation of any code that * uses UMFPACK or any modified version of UMFPACK code must cite the * Copyright, this License, the Availability note, and "Used by permission." * Permission to modify the code and to distribute modified code is granted, * provided the Copyright, this License, and the Availability note are * retained, and a notice that the code was modified is included. This * software was developed with support from the National Science Foundation, * and is provided to you free of charge. * * Availability: * * http://www.cise.ufl.edu/research/sparse/umfpack * */ /* Used by permission. */ #ifndef BOOST_NUMERIC_BINDINGS_UMFPACK_INC_H #define BOOST_NUMERIC_BINDINGS_UMFPACK_INC_H extern "C" { #include } #endif boost-bindings/boost/numeric/bindings/umfpack/umfpack_overloads.hpp0000644000175000017500000003740307725611464026066 0ustar andreasandreas/* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ /* for UMFPACK Copyright, License and Availability see umfpack_inc.hpp */ #ifndef BOOST_NUMERIC_BINDINGS_UMFPACK_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_UMFPACK_OVERLOADS_HPP #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace umfpack { namespace detail { //////////////////////////// // UMFPACK primary routines: //////////////////////////// // symbolic inline int symbolic (int n_row, int n_col, int const* Ap, int const* Ai, double const* Ax, void **Symbolic, double const* Control, double* Info) { return umfpack_di_symbolic (n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info); } inline int symbolic (int n_row, int n_col, int const* Ap, int const* Ai, traits::complex_d const* Ax, void **Symbolic, double const* Control, double* Info) { int nnz = Ap[n_col]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Axi (nnz); if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (Ax, Ax+nnz, Axr.storage(), Axi.storage()); return umfpack_zi_symbolic (n_row, n_col, Ap, Ai, Axr.storage(), Axi.storage(), Symbolic, Control, Info); } // numeric inline int numeric (int, int, int const* Ap, int const* Ai, double const* Ax, void *Symbolic, void **Numeric, double const* Control, double* Info) { return umfpack_di_numeric (Ap, Ai, Ax, Symbolic, Numeric, Control, Info); } inline int numeric (int, int n_col, int const* Ap, int const* Ai, traits::complex_d const* Ax, void *Symbolic, void **Numeric, double const* Control, double* Info) { int nnz = Ap[n_col]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Axi (nnz); if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (Ax, Ax+nnz, Axr.storage(), Axi.storage()); return umfpack_zi_numeric (Ap, Ai, Axr.storage(), Axi.storage(), Symbolic, Numeric, Control, Info); } // solve inline int solve (int sys, int, int const* Ap, int const* Ai, double const* Ax, double* X, double const* B, void *Numeric, double const* Control, double* Info) { return umfpack_di_solve (sys, Ap, Ai, Ax, X, B, Numeric, Control, Info); } inline int solve (int sys, int n, int const* Ap, int const* Ai, traits::complex_d const* Ax, traits::complex_d* X, traits::complex_d const* B, void *Numeric, double const* Control, double* Info) { int nnz = Ap[n]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Axi (nnz); if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (Ax, Ax+nnz, Axr.storage(), Axi.storage()); traits::detail::array Br (n); if (!Br.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Bi (n); if (!Bi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (B, B+n, Br.storage(), Bi.storage()); traits::detail::array Xr (n); if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Xi (n); if (!Xi.valid()) return UMFPACK_ERROR_out_of_memory; int status = umfpack_zi_solve (sys, Ap, Ai, Axr.storage(), Axi.storage(), Xr.storage(), Xi.storage(), Br.storage(), Bi.storage(), Numeric, Control, Info); if (status != UMFPACK_OK) return status; traits::detail::interlace (Xr.storage(), Xr.storage() + n, Xi.storage(), X); return status; } // free_symbolic inline void free_symbolic (double, int, void **Symbolic) { umfpack_di_free_symbolic (Symbolic); } inline void free_symbolic (traits::complex_d const&, int, void **Symbolic) { umfpack_zi_free_symbolic (Symbolic); } // free_numeric inline void free_numeric (double, int, void **Numeric) { umfpack_di_free_numeric (Numeric); } inline void free_numeric (traits::complex_d const&, int, void **Numeric) { umfpack_zi_free_numeric (Numeric); } //////////////////////////////// // UMFPACK alternative routines: //////////////////////////////// // default control inline void defaults (double, int, double* Control) { umfpack_di_defaults (Control); } inline void defaults (traits::complex_d const&, int, double* Control) { umfpack_zi_defaults (Control); } // symbolic with specified column preordering inline int qsymbolic (int n_row, int n_col, int const* Ap, int const* Ai, double const* Ax, int const* Qinit, void **Symbolic, double const* Control, double* Info) { return umfpack_di_qsymbolic (n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info); } inline int qsymbolic (int n_row, int n_col, int const* Ap, int const* Ai, traits::complex_d const* Ax, int const* Qinit, void **Symbolic, double const* Control, double* Info) { int nnz = Ap[n_col]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Axi (nnz); if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (Ax, Ax+nnz, Axr.storage(), Axi.storage()); return umfpack_zi_qsymbolic (n_row, n_col, Ap, Ai, Axr.storage(), Axi.storage(), Qinit, Symbolic, Control, Info); } /////////////////////////////////////// // UMFPACK matrix manipulation routines /////////////////////////////////////// // triplet (coordinate) to compressed column inline int triplet_to_col (int n_row, int n_col, int nz, int const* Ti, int const* Tj, double const* Tx, int* Ap, int* Ai, double* Ax, int* Map) { return umfpack_di_triplet_to_col (n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map); } inline int triplet_to_col (int n_row, int n_col, int nz, int const* Ti, int const* Tj, traits::complex_d const* Tx, int* Ap, int* Ai, traits::complex_d* Ax, int* Map) { assert (Tx == 0 && Ax == 0 || Tx != 0 && Ax != 0); double *Txr = 0, *Txi = 0; if (Tx != 0) { traits::detail::array ATxr (nz); if (!ATxr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array ATxi (nz); if (!ATxi.valid()) return UMFPACK_ERROR_out_of_memory; Txr = ATxr.storage(); Txi = ATxi.storage(); traits::detail::disentangle (Tx, Tx+nz, Txr, Txi); } double *Axr = 0, *Axi = 0; if (Ax != 0) { traits::detail::array AAxr (nz); if (!AAxr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array AAxi (nz); if (!AAxi.valid()) return UMFPACK_ERROR_out_of_memory; Axr = AAxr.storage(); Axi = AAxi.storage(); } int status; status = umfpack_zi_triplet_to_col (n_row, n_col, nz, Ti, Tj, Txr, Txi, Ap, Ai, Axr, Axi, Map); if (Ax != 0) { if (status != UMFPACK_OK) return status; traits::detail::interlace (Axr, Axr + nz, Axi, Ax); } return status; } // scale inline int scale (int, double* X, double const* B, void* Numeric) { return umfpack_di_scale (X, B, Numeric); } inline int scale (int n, traits::complex_d* X, traits::complex_d const* B, void* Numeric) { traits::detail::array Br (n); if (!Br.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Bi (n); if (!Bi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (B, B+n, Br.storage(), Bi.storage()); traits::detail::array Xr (n); if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Xi (n); if (!Xi.valid()) return UMFPACK_ERROR_out_of_memory; int status = umfpack_zi_scale (Xr.storage(), Xi.storage(), Br.storage(), Bi.storage(), Numeric); if (status != UMFPACK_OK) return status; traits::detail::interlace (Xr.storage(), Xr.storage() + n, Xi.storage(), X); return status; } ////////////////////////////// // UMFPACK reporting routines: ////////////////////////////// // report status inline void report_status (double, int, double const* Control, int status) { umfpack_di_report_status (Control, status); } inline void report_status (traits::complex_d const&, int, double const* Control, int status) { umfpack_zi_report_status (Control, status); } // report control inline void report_control (double, int, double const* Control) { umfpack_di_report_control (Control); } inline void report_control (traits::complex_d const&, int, double const* Control) { umfpack_zi_report_control (Control); } // report info inline void report_info (double, int, double const* Control, double const* Info) { umfpack_di_report_info (Control, Info); } inline void report_info (traits::complex_d const&, int, double const* Control, double const* Info) { umfpack_zi_report_info (Control, Info); } // report matrix inline int report_matrix (int n_row, int n_col, int const* Ap, int const* Ai, double const* Ax, int col_form, double const* Control) { return umfpack_di_report_matrix (n_row, n_col, Ap, Ai, Ax, col_form, Control); } inline int report_matrix (int n_row, int n_col, int const* Ap, int const* Ai, traits::complex_d const* Ax, int col_form, double const* Control) { int nnz = Ap[n_col]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Axi (nnz); if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (Ax, Ax+nnz, Axr.storage(), Axi.storage()); return umfpack_zi_report_matrix (n_row, n_col, Ap, Ai, Axr.storage(), Axi.storage(), col_form, Control); } // report triplet (coordinate) int report_triplet (int n_row, int n_col, int nz, int const* Ti, int const* Tj, double const* Tx, double const* Control) { return umfpack_di_report_triplet (n_row, n_col, nz, Ti, Tj, Tx, Control); } int report_triplet (int n_row, int n_col, int nz, int const* Ti, int const* Tj, traits::complex_d const* Tx, double const* Control) { traits::detail::array Txr (nz); if (!Txr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Txi (nz); if (!Txi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (Tx, Tx+nz, Txr.storage(), Txi.storage()); return umfpack_zi_report_triplet (n_row, n_col, nz, Ti, Tj, Txr.storage(), Txi.storage(), Control); } // report vector int report_vector (int n, double const* X, double const* Control) { return umfpack_di_report_vector (n, X, Control); } int report_vector (int n, traits::complex_d const* X, double const* Control) { #if 0 // see UMFPACK v 4.1 User Guide traits::detail::array Xr (n); if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Xi (n); if (!Xi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (X, X+n, Xr.storage(), Xi.storage()); return umfpack_zi_report_vector (n, Xr.storage(), Xi.storage(), Control); #endif return umfpack_zi_report_vector (n, reinterpret_cast (X), reinterpret_cast (0), Control); } // report numeric inline int report_numeric (double, int, void* Numeric, double const* Control) { return umfpack_di_report_numeric (Numeric, Control); } inline int report_numeric (traits::complex_d const&, int, void* Numeric, double const* Control) { return umfpack_zi_report_numeric (Numeric, Control); } // report symbolic inline int report_symbolic (double, int, void* Symbolic, double const* Control) { return umfpack_di_report_symbolic (Symbolic, Control); } inline int report_symbolic (traits::complex_d const&, int, void* Symbolic, double const* Control) { return umfpack_zi_report_symbolic (Symbolic, Control); } // report permutation vector inline int report_perm (double, int, int np, int const* Perm, double const* Control) { return umfpack_di_report_perm (np, Perm, Control); } inline int report_perm (traits::complex_d const&, int, int np, int const* Perm, double const* Control) { return umfpack_zi_report_perm (np, Perm, Control); } }} }}} #endif // BOOST_NUMERIC_BINDINGS_UMFPACK_OVERLOADS_HPP boost-bindings/boost/numeric/bindings/mumps/0000755000175000017500000000000010776012707021350 5ustar andreasandreasboost-bindings/boost/numeric/bindings/mumps/4.6.4/0000755000175000017500000000000010776012707022021 5ustar andreasandreasboost-bindings/boost/numeric/bindings/mumps/4.6.4/cmumps_c.hpp0000644000175000017500000001001110776012707024331 0ustar andreasandreas#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_464_CMUMPS_C_HPP #define BOOST_NUMERIC_BINDINGS_MUMPS_464_CMUMPS_C_HPP /* THIS FILE IS PART OF MUMPS VERSION 4.6.4 This Version was built on Thu Jan 11 13:32:35 2007 This version of MUMPS is provided to you free of charge. It is public domain, based on public domain software developed during the Esprit IV European project PARASOL (1996-1999) by CERFACS, ENSEEIHT-IRIT and RAL. Since this first public domain version in 1999, the developments are supported by the following institutions: CERFACS, ENSEEIHT-IRIT, and INRIA. Main contributors are Patrick Amestoy, Iain Duff, Abdou Guermouche, Jacko Koster, Jean-Yves L'Excellent, and Stephane Pralet. Up-to-date copies of the MUMPS package can be obtained from the Web pages http://www.enseeiht.fr/apo/MUMPS/ or http://graal.ens-lyon.fr/MUMPS THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. User documentation of any code that uses this software can include this complete notice. You can acknowledge (using references [1], [2], and [3] the contribution of this package in any scientific publication dependent upon the use of the package. You shall use reasonable endeavours to notify the authors of the package of this publication. [1] P. R. Amestoy, I. S. Duff and J.-Y. L'Excellent, Multifrontal parallel distributed symmetric and unsymmetric solvers, in Comput. Methods in Appl. Mech. Eng., 184, 501-520 (2000). [2] P. R. Amestoy, I. S. Duff, J. Koster and J.-Y. L'Excellent, A fully asynchronous multifrontal solver using distributed dynamic scheduling, SIAM Journal of Matrix Analysis and Applications, Vol 23, No 1, pp 15-41 (2001). [3] P. R. Amestoy and A. Guermouche and J.-Y. L'Excellent and S. Pralet, Hybrid scheduling for the parallel solution of linear systems. Parallel Computing Vol 32 (2), pp 136-156 (2006). */ /* $Id: cmumps_c.hpp 39206 2007-09-12 06:58:12Z karlmeerbergen $ */ /* Mostly written in march 2002 (JYL) */ // This file is modified by Karl Meerbergen for C++ users /* Complex datatypes */ typedef struct {float r,i;} mumps_complex; /* Next line defines CMUMPS_INT, CMUMPS_DOUBLE and CMUMPS_DOUBLE2 */ #include "cmumps_prec.h" /* * Definition of the (simplified) * MUMPS C structure */ typedef struct { CMUMPS_INT sym, par, job; CMUMPS_INT comm_fortran; /* Fortran communicator */ CMUMPS_INT icntl[40]; CMUMPS_DOUBLE2 cntl[5]; CMUMPS_INT n; CMUMPS_INT nz_alloc; /* used in matlab interface to decide if we free + malloc when we have large variation */ /* Assembled entry */ CMUMPS_INT nz; CMUMPS_INT *irn; CMUMPS_INT *jcn; CMUMPS_DOUBLE *a; /* Distributed entry */ CMUMPS_INT nz_loc; CMUMPS_INT *irn_loc; CMUMPS_INT *jcn_loc; CMUMPS_DOUBLE *a_loc; /* Element entry */ CMUMPS_INT nelt; CMUMPS_INT *eltptr; CMUMPS_INT *eltvar; CMUMPS_DOUBLE *a_elt; /* Ordering, if given by user */ CMUMPS_INT *perm_in; /* Orderings returned to user */ /* symmetric permutation */ CMUMPS_INT *sym_perm; /* column permutation */ CMUMPS_INT *uns_perm; /* Scaling (input only in this version) */ CMUMPS_DOUBLE *colsca; CMUMPS_DOUBLE *rowsca; /* RHS, solution, ouptput data and statistics */ CMUMPS_DOUBLE *rhs, *rhs_sparse, *sol_loc; CMUMPS_INT *irhs_sparse, *irhs_ptr, *isol_loc; CMUMPS_INT nrhs, lrhs, nz_rhs, lsol_loc; CMUMPS_INT schur_mloc, schur_nloc, schur_lld; CMUMPS_INT mblock, nblock, nprow, npcol; CMUMPS_INT info[40],infog[40]; CMUMPS_DOUBLE2 rinfo[20], rinfog[20]; /* Null space */ CMUMPS_INT deficiency; CMUMPS_DOUBLE * nullspace; CMUMPS_INT * mapping; /* Schur */ CMUMPS_INT size_schur; CMUMPS_INT *listvar_schur; CMUMPS_DOUBLE *schur; /* Internal parameters */ CMUMPS_INT instance_number; /* For out-of-core */ char ooc_tmpdir[151]; char ooc_prefix[151]; } CMUMPS_STRUC_C; extern "C" { void cmumps_c(CMUMPS_STRUC_C * cmumps_par); } #endif boost-bindings/boost/numeric/bindings/mumps/4.6.4/dmumps_c.hpp0000644000175000017500000001016510776012707024344 0ustar andreasandreas#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_464_DMUMPS_C_HPP #define BOOST_NUMERIC_BINDINGS_MUMPS_464_DMUMPS_C_HPP /* THIS FILE IS PART OF MUMPS VERSION 4.6.4 This Version was built on Thu Jan 11 13:32:35 2007 This version of MUMPS is provided to you free of charge. It is public domain, based on public domain software developed during the Esprit IV European project PARASOL (1996-1999) by CERFACS, ENSEEIHT-IRIT and RAL. Since this first public domain version in 1999, the developments are supported by the following institutions: CERFACS, ENSEEIHT-IRIT, and INRIA. Main contributors are Patrick Amestoy, Iain Duff, Abdou Guermouche, Jacko Koster, Jean-Yves L'Excellent, and Stephane Pralet. Up-to-date copies of the MUMPS package can be obtained from the Web pages http://www.enseeiht.fr/apo/MUMPS/ or http://graal.ens-lyon.fr/MUMPS THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. User documentation of any code that uses this software can include this complete notice. You can acknowledge (using references [1], [2], and [3] the contribution of this package in any scientific publication dependent upon the use of the package. You shall use reasonable endeavours to notify the authors of the package of this publication. [1] P. R. Amestoy, I. S. Duff and J.-Y. L'Excellent, Multifrontal parallel distributed symmetric and unsymmetric solvers, in Comput. Methods in Appl. Mech. Eng., 184, 501-520 (2000). [2] P. R. Amestoy, I. S. Duff, J. Koster and J.-Y. L'Excellent, A fully asynchronous multifrontal solver using distributed dynamic scheduling, SIAM Journal of Matrix Analysis and Applications, Vol 23, No 1, pp 15-41 (2001). [3] P. R. Amestoy and A. Guermouche and J.-Y. L'Excellent and S. Pralet, Hybrid scheduling for the parallel solution of linear systems. Parallel Computing Vol 32 (2), pp 136-156 (2006). */ /* $Id: dmumps_c.hpp 39206 2007-09-12 06:58:12Z karlmeerbergen $ */ /* Mostly written in march 2002 (JYL) */ // This file is modified by Karl Meerbergen for C++ users /* Complex datatypes */ /* Next line defines DMUMPS_INT, DMUMPS_DOUBLE and DMUMPS_DOUBLE2 */ #include "dmumps_prec.h" /* * Definition of the (simplified) * MUMPS C structure */ typedef struct { DMUMPS_INT sym, par, job; DMUMPS_INT comm_fortran; /* Fortran communicator */ DMUMPS_INT icntl[40]; DMUMPS_DOUBLE2 cntl[5]; DMUMPS_INT n; DMUMPS_INT nz_alloc; /* used in matlab interface to decide if we free + malloc when we have large variation */ /* Assembled entry */ DMUMPS_INT nz; DMUMPS_INT *irn; DMUMPS_INT *jcn; DMUMPS_DOUBLE *a; /* Distributed entry */ DMUMPS_INT nz_loc; DMUMPS_INT *irn_loc; DMUMPS_INT *jcn_loc; DMUMPS_DOUBLE *a_loc; /* Element entry */ DMUMPS_INT nelt; DMUMPS_INT *eltptr; DMUMPS_INT *eltvar; DMUMPS_DOUBLE *a_elt; /* Ordering, if given by user */ DMUMPS_INT *perm_in; /* Orderings returned to user */ /* symmetric permutation */ DMUMPS_INT *sym_perm; /* column permutation */ DMUMPS_INT *uns_perm; /* Scaling (input only in this version) */ DMUMPS_DOUBLE *colsca; DMUMPS_DOUBLE *rowsca; /* RHS, solution, ouptput data and statistics */ DMUMPS_DOUBLE *rhs, *rhs_sparse, *sol_loc; DMUMPS_INT *irhs_sparse, *irhs_ptr, *isol_loc; DMUMPS_INT nrhs, lrhs, nz_rhs, lsol_loc; DMUMPS_INT schur_mloc, schur_nloc, schur_lld; DMUMPS_INT mblock, nblock, nprow, npcol; DMUMPS_INT info[40],infog[40]; DMUMPS_DOUBLE2 rinfo[20], rinfog[20]; /* Null space */ DMUMPS_INT deficiency; DMUMPS_DOUBLE * nullspace; DMUMPS_INT * mapping; /* Schur */ DMUMPS_INT size_schur; DMUMPS_INT *listvar_schur; DMUMPS_DOUBLE *schur; /* Internal parameters */ DMUMPS_INT instance_number; /* For out-of-core */ char ooc_tmpdir[151]; char ooc_prefix[151]; } DMUMPS_STRUC_C; #define MUMPS_CALL #if defined(_WIN32) /* * Next line May be needed depending on your Windows environment: * #define MUMPS_CALL __stdcall */ #endif extern "C" { void dmumps_c(DMUMPS_STRUC_C * dmumps_par); } #endif boost-bindings/boost/numeric/bindings/mumps/4.6.4/smumps_c.hpp0000644000175000017500000000773410776012707024373 0ustar andreasandreas#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_464_SMUMPS_C_HPP #define BOOST_NUMERIC_BINDINGS_MUMPS_464_SMUMPS_C_HPP /* THIS FILE IS PART OF MUMPS VERSION 4.6.4 This Version was built on Thu Jan 11 13:32:35 2007 This version of MUMPS is provided to you free of charge. It is public domain, based on public domain software developed during the Esprit IV European project PARASOL (1996-1999) by CERFACS, ENSEEIHT-IRIT and RAL. Since this first public domain version in 1999, the developments are supported by the following institutions: CERFACS, ENSEEIHT-IRIT, and INRIA. Main contributors are Patrick Amestoy, Iain Duff, Abdou Guermouche, Jacko Koster, Jean-Yves L'Excellent, and Stephane Pralet. Up-to-date copies of the MUMPS package can be obtained from the Web pages http://www.enseeiht.fr/apo/MUMPS/ or http://graal.ens-lyon.fr/MUMPS THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. User documentation of any code that uses this software can include this complete notice. You can acknowledge (using references [1], [2], and [3] the contribution of this package in any scientific publication dependent upon the use of the package. You shall use reasonable endeavours to notify the authors of the package of this publication. [1] P. R. Amestoy, I. S. Duff and J.-Y. L'Excellent, Multifrontal parallel distributed symmetric and unsymmetric solvers, in Comput. Methods in Appl. Mech. Eng., 184, 501-520 (2000). [2] P. R. Amestoy, I. S. Duff, J. Koster and J.-Y. L'Excellent, A fully asynchronous multifrontal solver using distributed dynamic scheduling, SIAM Journal of Matrix Analysis and Applications, Vol 23, No 1, pp 15-41 (2001). [3] P. R. Amestoy and A. Guermouche and J.-Y. L'Excellent and S. Pralet, Hybrid scheduling for the parallel solution of linear systems. Parallel Computing Vol 32 (2), pp 136-156 (2006). */ /* $Id: smumps_c.hpp 39206 2007-09-12 06:58:12Z karlmeerbergen $ */ /* Mostly written in march 2002 (JYL) */ // This file is modified by Karl Meerbergen for C++ users /* Complex datatypes */ /* Next line defines SMUMPS_INT, SMUMPS_DOUBLE and SMUMPS_DOUBLE2 */ #include /* * Definition of the (simplified) * MUMPS C structure */ typedef struct { SMUMPS_INT sym, par, job; SMUMPS_INT comm_fortran; /* Fortran communicator */ SMUMPS_INT icntl[40]; SMUMPS_DOUBLE2 cntl[5]; SMUMPS_INT n; SMUMPS_INT nz_alloc; /* used in matlab interface to decide if we free + malloc when we have large variation */ /* Assembled entry */ SMUMPS_INT nz; SMUMPS_INT *irn; SMUMPS_INT *jcn; SMUMPS_DOUBLE *a; /* Distributed entry */ SMUMPS_INT nz_loc; SMUMPS_INT *irn_loc; SMUMPS_INT *jcn_loc; SMUMPS_DOUBLE *a_loc; /* Element entry */ SMUMPS_INT nelt; SMUMPS_INT *eltptr; SMUMPS_INT *eltvar; SMUMPS_DOUBLE *a_elt; /* Ordering, if given by user */ SMUMPS_INT *perm_in; /* Orderings returned to user */ /* symmetric permutation */ SMUMPS_INT *sym_perm; /* column permutation */ SMUMPS_INT *uns_perm; /* Scaling (input only in this version) */ SMUMPS_DOUBLE *colsca; SMUMPS_DOUBLE *rowsca; /* RHS, solution, ouptput data and statistics */ SMUMPS_DOUBLE *rhs, *rhs_sparse, *sol_loc; SMUMPS_INT *irhs_sparse, *irhs_ptr, *isol_loc; SMUMPS_INT nrhs, lrhs, nz_rhs, lsol_loc; SMUMPS_INT schur_mloc, schur_nloc, schur_lld; SMUMPS_INT mblock, nblock, nprow, npcol; SMUMPS_INT info[40],infog[40]; SMUMPS_DOUBLE2 rinfo[20], rinfog[20]; /* Null space */ SMUMPS_INT deficiency; SMUMPS_DOUBLE * nullspace; SMUMPS_INT * mapping; /* Schur */ SMUMPS_INT size_schur; SMUMPS_INT *listvar_schur; SMUMPS_DOUBLE *schur; /* Internal parameters */ SMUMPS_INT instance_number; /* For out-of-core */ char ooc_tmpdir[151]; char ooc_prefix[151]; } SMUMPS_STRUC_C; extern "C" { void smumps_c(SMUMPS_STRUC_C * smumps_par); } #endif boost-bindings/boost/numeric/bindings/mumps/4.6.4/zmumps_c.hpp0000644000175000017500000001001710776012707024366 0ustar andreasandreas#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_464_ZMUMPS_C_HPP #define BOOST_NUMERIC_BINDINGS_MUMPS_464_ZMUMPS_C_HPP /* THIS FILE IS PART OF MUMPS VERSION 4.6.4 This Version was built on Thu Jan 11 13:32:35 2007 This version of MUMPS is provided to you free of charge. It is public domain, based on public domain software developed during the Esprit IV European project PARASOL (1996-1999) by CERFACS, ENSEEIHT-IRIT and RAL. Since this first public domain version in 1999, the developments are supported by the following institutions: CERFACS, ENSEEIHT-IRIT, and INRIA. Main contributors are Patrick Amestoy, Iain Duff, Abdou Guermouche, Jacko Koster, Jean-Yves L'Excellent, and Stephane Pralet. Up-to-date copies of the MUMPS package can be obtained from the Web pages http://www.enseeiht.fr/apo/MUMPS/ or http://graal.ens-lyon.fr/MUMPS THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. User documentation of any code that uses this software can include this complete notice. You can acknowledge (using references [1], [2], and [3] the contribution of this package in any scientific publication dependent upon the use of the package. You shall use reasonable endeavours to notify the authors of the package of this publication. [1] P. R. Amestoy, I. S. Duff and J.-Y. L'Excellent, Multifrontal parallel distributed symmetric and unsymmetric solvers, in Comput. Methods in Appl. Mech. Eng., 184, 501-520 (2000). [2] P. R. Amestoy, I. S. Duff, J. Koster and J.-Y. L'Excellent, A fully asynchronous multifrontal solver using distributed dynamic scheduling, SIAM Journal of Matrix Analysis and Applications, Vol 23, No 1, pp 15-41 (2001). [3] P. R. Amestoy and A. Guermouche and J.-Y. L'Excellent and S. Pralet, Hybrid scheduling for the parallel solution of linear systems. Parallel Computing Vol 32 (2), pp 136-156 (2006). */ /* $Id: zmumps_c.hpp 39206 2007-09-12 06:58:12Z karlmeerbergen $ */ /* Mostly written in march 2002 (JYL) */ // This file is modified by Karl Meerbergen for C++ users /* Complex datatypes */ typedef struct {double r,i;} mumps_double_complex; /* Next line defines ZMUMPS_INT, ZMUMPS_DOUBLE and ZMUMPS_DOUBLE2 */ #include "zmumps_prec.h" /* * Definition of the (simplified) * MUMPS C structure */ typedef struct { ZMUMPS_INT sym, par, job; ZMUMPS_INT comm_fortran; /* Fortran communicator */ ZMUMPS_INT icntl[40]; ZMUMPS_DOUBLE2 cntl[5]; ZMUMPS_INT n; ZMUMPS_INT nz_alloc; /* used in matlab interface to decide if we free + malloc when we have large variation */ /* Assembled entry */ ZMUMPS_INT nz; ZMUMPS_INT *irn; ZMUMPS_INT *jcn; ZMUMPS_DOUBLE *a; /* Distributed entry */ ZMUMPS_INT nz_loc; ZMUMPS_INT *irn_loc; ZMUMPS_INT *jcn_loc; ZMUMPS_DOUBLE *a_loc; /* Element entry */ ZMUMPS_INT nelt; ZMUMPS_INT *eltptr; ZMUMPS_INT *eltvar; ZMUMPS_DOUBLE *a_elt; /* Ordering, if given by user */ ZMUMPS_INT *perm_in; /* Orderings returned to user */ /* symmetric permutation */ ZMUMPS_INT *sym_perm; /* column permutation */ ZMUMPS_INT *uns_perm; /* Scaling (input only in this version) */ ZMUMPS_DOUBLE *colsca; ZMUMPS_DOUBLE *rowsca; /* RHS, solution, ouptput data and statistics */ ZMUMPS_DOUBLE *rhs, *rhs_sparse, *sol_loc; ZMUMPS_INT *irhs_sparse, *irhs_ptr, *isol_loc; ZMUMPS_INT nrhs, lrhs, nz_rhs, lsol_loc; ZMUMPS_INT schur_mloc, schur_nloc, schur_lld; ZMUMPS_INT mblock, nblock, nprow, npcol; ZMUMPS_INT info[40],infog[40]; ZMUMPS_DOUBLE2 rinfo[20], rinfog[20]; /* Null space */ ZMUMPS_INT deficiency; ZMUMPS_DOUBLE * nullspace; ZMUMPS_INT * mapping; /* Schur */ ZMUMPS_INT size_schur; ZMUMPS_INT *listvar_schur; ZMUMPS_DOUBLE *schur; /* Internal parameters */ ZMUMPS_INT instance_number; /* For out-of-core */ char ooc_tmpdir[151]; char ooc_prefix[151]; } ZMUMPS_STRUC_C; extern "C" { void zmumps_c(ZMUMPS_STRUC_C * zmumps_par); } #endif boost-bindings/boost/numeric/bindings/mumps/mumps_driver_4_6_4.hpp0000644000175000017500000002015310776012707025471 0ustar andreasandreas// // Copyright Karl Meerbergen 2007 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_4_6_4_HPP #define BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_4_6_4_HPP #include #include #include #include #include #include #include #include #include #include // // This file contains a C++ driver for MUMPS // // The templated class mumps is a wrapper for the corresponding C struct. // The class contains constructor and destructor that call mumps with JOB=-1 and JOB=-2 // respectively. // // The function driver() calls MUMPS. The user must set the parameters of the data manually. // // The following functions are very helpful in this respect, since they extract pointer and size // data using the Boost Bindings. // // void matrix_integer_data() : to set the integer data of the matrix. // void matrix_value_data() : to set the values of the matrix. // void rhs_sol_value_data() : to set the right-hand side and solution vectors in the case of a dense solution vector. // namespace boost { namespace numeric { namespace bindings { namespace mumps { namespace detail { // // Type and Driver // template struct mumps_type { } ; template struct mumps_call { } ; template struct mumps_internal_value_type { typedef T type ; } ; // // Specialization for float // template <> struct mumps_type< float > { typedef SMUMPS_STRUC_C type ; } ; template <> struct mumps_call< float > { void operator() ( SMUMPS_STRUC_C& struc ) const { smumps_c( &struc ) ; } } ; // // Specialization for double // template <> struct mumps_type< double > { typedef DMUMPS_STRUC_C type ; } ; template <> struct mumps_call< double > { void operator() ( DMUMPS_STRUC_C& struc ) const { dmumps_c( &struc ) ; } } ; // // Specialization for complex // template <> struct mumps_type< std::complex< float > > { typedef CMUMPS_STRUC_C type ; } ; template <> struct mumps_call< std::complex< float > > { void operator() ( CMUMPS_STRUC_C& struc ) const { cmumps_c( &struc ) ; } } ; template <> struct mumps_internal_value_type< std::complex > { typedef mumps_complex type ; } ; // // Specialization for complex // template <> struct mumps_type< std::complex< double > > { typedef ZMUMPS_STRUC_C type ; } ; template <> struct mumps_call< std::complex< double > > { void operator() ( ZMUMPS_STRUC_C& struc ) const { zmumps_c( &struc ) ; } } ; template <> struct mumps_internal_value_type< std::complex > { typedef mumps_double_complex type ; } ; // // Symmetry map // template struct mumps_sym { } ; template <> struct mumps_sym< boost::numeric::bindings::traits::symmetric_t > { static int const value = 2 ; } ; template <> struct mumps_sym< boost::numeric::bindings::traits::general_t > { static int const value = 0 ; } ; // // Get index pointers // template void indices( boost::numeric::bindings::traits::row_major_t, int*& rows, int*& cols, M const& m ) { rows = const_cast( boost::numeric::bindings::traits::spmatrix_index1_storage( m ) ) ; cols = const_cast( boost::numeric::bindings::traits::spmatrix_index2_storage( m ) ) ; } template void indices( boost::numeric::bindings::traits::column_major_t, int*& rows, int*& cols, M const& m ) { cols = const_cast( boost::numeric::bindings::traits::spmatrix_index1_storage( m ) ) ; rows = const_cast( boost::numeric::bindings::traits::spmatrix_index2_storage( m ) ) ; } // Pointer Cast float* cast_2_mumps( float* p ) { return p ; } double* cast_2_mumps( double* p ) { return p ; } mumps_double_complex* cast_2_mumps( std::complex* p ) { return reinterpret_cast( p ) ; } mumps_complex* cast_2_mumps( std::complex* p ) { return reinterpret_cast( p ) ; } } // namespace detail // // Generic MUMPS data for any value_type // template struct mumps : detail::mumps_type< typename boost::numeric::bindings::traits::sparse_matrix_traits::value_type >::type { typedef typename boost::numeric::bindings::traits::sparse_matrix_traits::value_type value_type ; typedef typename detail::mumps_type< typename boost::numeric::bindings::traits::sparse_matrix_traits::value_type >::type c_struct_type ; // // Initialize MUMPS solver // Pass a communicator (comm=-987654 means choose default) // Pass 'par': default = 1: host is involved in factorization // mumps( int comm_fortran=-987654, int par=1 ) { this->job = -1 ; this->par = par ; this->comm_fortran = comm_fortran ; this->sym = detail::mumps_sym< typename boost::numeric::bindings::traits::sparse_matrix_traits::matrix_structure >::value ; detail::mumps_call() ( *this ) ; } // Destroy the solver ~mumps() { this->job = -2 ; detail::mumps_call() ( *this ) ; } } ; // // Copy the matrix integer data (matrix order, structure) to the MUMPS struct // template void matrix_integer_data( mumps& data, M& m ) { BOOST_STATIC_ASSERT( (1 == boost::numeric::bindings::traits::sparse_matrix_traits::index_base) ) ; data.n = boost::numeric::bindings::traits::spmatrix_size1( m ) ; assert( boost::numeric::bindings::traits::spmatrix_size2( m ) == data.n ) ; data.nz = boost::numeric::bindings::traits::spmatrix_num_nonzeros( m ) ; detail::indices( typename boost::numeric::bindings::traits::sparse_matrix_traits::ordering_type(), data.irn, data.jcn, m ) ; data.nz_loc = boost::numeric::bindings::traits::spmatrix_num_nonzeros( m ) ; detail::indices( typename boost::numeric::bindings::traits::sparse_matrix_traits::ordering_type(), data.irn_loc, data.jcn_loc, m ) ; } // matrix_integer_data() // // Copy the values pointer to the MUMPS struct // template void matrix_value_data( mumps& data, M& m ) { data.a = detail::cast_2_mumps( boost::numeric::bindings::traits::spmatrix_value_storage( m ) ) ; data.a_loc = detail::cast_2_mumps( boost::numeric::bindings::traits::spmatrix_value_storage( m ) ) ; } // matrix_value_data() // // Copy the right-hand side / solution pointer to the MUMPS struct // in case of a dense undistributed right-hand side and solution. // template void rhs_sol_value_data( mumps& data, X& x ) { data.rhs = detail::cast_2_mumps( boost::numeric::bindings::traits::matrix_storage( x ) ) ; data.nrhs = boost::numeric::bindings::traits::matrix_size2( x ) ; data.lrhs = boost::numeric::bindings::traits::leading_dimension( x ) ; } // matrix_rhs_sol_value_data() // // Call the MUMPS driver for the given MUMPS struct. // template int driver( mumps& data ) { assert( data.job>=1 ? data.irn!=0 : true ) ; assert( data.job>=1 ? data.jcn!=0 : true ) ; assert( data.job>=2 ? data.a!=0 : true ) ; assert( data.job>=3 ? data.rhs!=0 : true ) ; detail::mumps_call() ( static_cast::c_struct_type&>( data ) ) ; return data.info[0] ; } // driver() } } } } // namespace boost::numeric::bindings::mumps #endif boost-bindings/boost/numeric/bindings/mumps/mumps_driver.hpp0000644000175000017500000000057610776012707024605 0ustar andreasandreas// // Copyright Karl Meerbergen 2007 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_HPP #define BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_HPP #include #endif boost-bindings/LICENSE_1_0.txt0000644000175000017500000000247210025376415016105 0ustar andreasandreasBoost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. boost-bindings/Makefile.in0000644000175000017500000000024510714455203015662 0ustar andreasandreasall: true install: for header in `find boost -name '*.hpp' -o -name '*.h'`; do \ install -D $$header ${PREFIX}/include/boost-bindings/$$header ; \ done boost-bindings/README0000644000175000017500000000027710776012466014512 0ustar andreasandreasHow to obtain a new version: svn co http://svn.boost.org/svn/boost/sandbox/boost/numeric/bindings Make a patch: diff -x '.svn' -x '*~' -wruN boost/numeric/bindings ~/tmp/bindings > my.patch