Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r58923 - in sandbox/numeric_bindings/boost/numeric/bindings: blas/level1 blas/level2 blas/level3 lapack lapack/auxiliary lapack/computational lapack/detail lapack/driver
From: rutger_at_[hidden]
Date: 2010-01-12 05:23:26


Author: rutger
Date: 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
New Revision: 58923
URL: http://svn.boost.org/trac/boost/changeset/58923

Log:
Added a number of auxiliairy routines, const args by value

Added:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lange.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansy.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantr.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larf.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfb.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfg.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larft.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfx.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/largv.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larnv.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larrb.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larre.hpp (contents, props changed)
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gejsv.hpp (contents, props changed)
Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp | 58 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp | 46 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp | 15 +
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp | 38 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp | 46 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp | 110 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp | 92 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp | 34 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp | 48 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp | 48 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp | 56 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp | 56 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp | 36 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp | 48 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp | 44 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp | 28 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp | 44 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp | 36 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp | 32 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp | 28 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp | 34 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp | 32 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp | 64 ++++----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp | 64 ++++----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp | 52 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp | 52 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp | 62 ++++----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp | 62 ++++----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp | 109 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp | 57 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp | 50 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp | 38 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp | 95 +++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp | 95 +++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp | 80 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp | 80 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp | 80 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp | 13
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp | 40 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp | 46 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp | 29 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp | 30 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp | 52 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp | 34 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebak.hpp | 28 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebal.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp | 49 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp | 36 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp | 44 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp | 50 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp | 32 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp | 30 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp | 42 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp | 35 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp | 35 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp | 58 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp | 57 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp | 35 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp | 20 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp | 15 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp | 27 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp | 54 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp | 23 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrf.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp | 53 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp | 38 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp | 38 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp | 27 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp | 118 ++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp | 27 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp | 20 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp | 10
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp | 17 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp | 17 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp | 15 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp | 27 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp | 46 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrf.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftri.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp | 44 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp | 30 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp | 30 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp | 44 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp | 36 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp | 10
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp | 19 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp | 33 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp | 23 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp | 13
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp | 41 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp | 32 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp | 48 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp | 38 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stemr.hpp | 52 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp | 19 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp | 25 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp | 10
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp | 49 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp | 20 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp | 26 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp | 44 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp | 30 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tftri.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp | 47 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp | 38 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp | 65 ++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp | 59 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp | 56 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp | 60 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp | 40 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp | 38 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp | 27 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp | 37 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp | 49 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp | 38 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp | 30 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp | 16 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h | 281 ++++++++++++++++++++++++++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h | 118 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp | 32 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp | 58 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp | 39 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp | 50 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp | 39 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp | 49 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp | 42 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp | 32 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp | 40 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp | 38 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp | 39 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp | 36 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp | 44 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp | 40 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp | 51 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp | 52 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp | 70 +++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp | 42 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp | 61 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp | 36 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp | 36 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp | 54 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp | 45 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp | 20 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp | 28 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp | 28 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp | 13
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp | 32 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp | 28 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp | 30 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp | 28 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp | 21 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp | 33 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp | 98 +++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp | 46 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp | 42 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp | 49 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp | 21 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp | 42 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp | 41 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp | 22 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp | 27 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp | 9
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp | 9
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp | 17 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp | 16 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sposv.hpp | 7
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp | 38 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp | 19 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp | 10
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp | 24 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp | 14 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp | 18 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp | 28 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp | 32 ++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp | 52 +++---
   289 files changed, 5188 insertions(+), 4035 deletions(-)

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,7 +60,7 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline float asum( int n, const float* x, int incx ) {
+inline float asum( const int n, const float* x, const int incx ) {
     return cblas_sasum( n, x, incx );
 }
 
@@ -69,7 +69,7 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline double asum( int n, const double* x, int incx ) {
+inline double asum( const int n, const double* x, const int incx ) {
     return cblas_dasum( n, x, incx );
 }
 
@@ -79,7 +79,7 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline float asum( int n, const float* x, int incx ) {
+inline float asum( const int n, const float* x, const int incx ) {
     return cublasSasum( n, x, incx );
 }
 
@@ -88,7 +88,7 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline double asum( int n, const double* x, int incx ) {
+inline double asum( const int n, const double* x, const int incx ) {
     return cublasDasum( n, x, incx );
 }
 
@@ -98,7 +98,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline float asum( fortran_int_t n, const float* x, fortran_int_t incx ) {
+inline float asum( const fortran_int_t n, const float* x,
+ const fortran_int_t incx ) {
     return BLAS_SASUM( &n, x, &incx );
 }
 
@@ -107,7 +108,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline double asum( fortran_int_t n, const double* x, fortran_int_t incx ) {
+inline double asum( const fortran_int_t n, const double* x,
+ const fortran_int_t incx ) {
     return BLAS_DASUM( &n, x, &incx );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,8 +60,8 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline void axpy( int n, float a, const float* x, int incx, float* y,
- int incy ) {
+inline void axpy( const int n, const float a, const float* x, const int incx,
+ float* y, const int incy ) {
     cblas_saxpy( n, a, x, incx, y, incy );
 }
 
@@ -70,8 +70,8 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline void axpy( int n, double a, const double* x, int incx, double* y,
- int incy ) {
+inline void axpy( const int n, const double a, const double* x,
+ const int incx, double* y, const int incy ) {
     cblas_daxpy( n, a, x, incx, y, incy );
 }
 
@@ -80,8 +80,9 @@
 // * CBLAS backend, and
 // * complex<float> value-type.
 //
-inline void axpy( int n, std::complex<float> a, const std::complex<float>* x,
- int incx, std::complex<float>* y, int incy ) {
+inline void axpy( const int n, const std::complex<float> a,
+ const std::complex<float>* x, const int incx, std::complex<float>* y,
+ const int incy ) {
     cblas_caxpy( n, &a, x, incx, y, incy );
 }
 
@@ -90,9 +91,9 @@
 // * CBLAS backend, and
 // * complex<double> value-type.
 //
-inline void axpy( int n, std::complex<double> a,
- const std::complex<double>* x, int incx, std::complex<double>* y,
- int incy ) {
+inline void axpy( const int n, const std::complex<double> a,
+ const std::complex<double>* x, const int incx,
+ std::complex<double>* y, const int incy ) {
     cblas_zaxpy( n, &a, x, incx, y, incy );
 }
 
@@ -102,8 +103,8 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline void axpy( int n, float a, const float* x, int incx, float* y,
- int incy ) {
+inline void axpy( const int n, const float a, const float* x, const int incx,
+ float* y, const int incy ) {
     cublasSaxpy( n, a, x, incx, y, incy );
 }
 
@@ -112,8 +113,8 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline void axpy( int n, double a, const double* x, int incx, double* y,
- int incy ) {
+inline void axpy( const int n, const double a, const double* x,
+ const int incx, double* y, const int incy ) {
     cublasDaxpy( n, a, x, incx, y, incy );
 }
 
@@ -122,8 +123,9 @@
 // * CUBLAS backend, and
 // * complex<float> value-type.
 //
-inline void axpy( int n, std::complex<float> a, const std::complex<float>* x,
- int incx, std::complex<float>* y, int incy ) {
+inline void axpy( const int n, const std::complex<float> a,
+ const std::complex<float>* x, const int incx, std::complex<float>* y,
+ const int incy ) {
     cublasCaxpy( n, a, x, incx, y, incy );
 }
 
@@ -132,9 +134,9 @@
 // * CUBLAS backend, and
 // * complex<double> value-type.
 //
-inline void axpy( int n, std::complex<double> a,
- const std::complex<double>* x, int incx, std::complex<double>* y,
- int incy ) {
+inline void axpy( const int n, const std::complex<double> a,
+ const std::complex<double>* x, const int incx,
+ std::complex<double>* y, const int incy ) {
     // NOT FOUND();
 }
 
@@ -144,8 +146,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline void axpy( fortran_int_t n, float a, const float* x,
- fortran_int_t incx, float* y, fortran_int_t incy ) {
+inline void axpy( const fortran_int_t n, const float a, const float* x,
+ const fortran_int_t incx, float* y, const fortran_int_t incy ) {
     BLAS_SAXPY( &n, &a, x, &incx, y, &incy );
 }
 
@@ -154,8 +156,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline void axpy( fortran_int_t n, double a, const double* x,
- fortran_int_t incx, double* y, fortran_int_t incy ) {
+inline void axpy( const fortran_int_t n, const double a, const double* x,
+ const fortran_int_t incx, double* y, const fortran_int_t incy ) {
     BLAS_DAXPY( &n, &a, x, &incx, y, &incy );
 }
 
@@ -164,9 +166,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<float> value-type.
 //
-inline void axpy( fortran_int_t n, std::complex<float> a,
- const std::complex<float>* x, fortran_int_t incx,
- std::complex<float>* y, fortran_int_t incy ) {
+inline void axpy( const fortran_int_t n, const std::complex<float> a,
+ const std::complex<float>* x, const fortran_int_t incx,
+ std::complex<float>* y, const fortran_int_t incy ) {
     BLAS_CAXPY( &n, &a, x, &incx, y, &incy );
 }
 
@@ -175,9 +177,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<double> value-type.
 //
-inline void axpy( fortran_int_t n, std::complex<double> a,
- const std::complex<double>* x, fortran_int_t incx,
- std::complex<double>* y, fortran_int_t incy ) {
+inline void axpy( const fortran_int_t n, const std::complex<double> a,
+ const std::complex<double>* x, const fortran_int_t incx,
+ std::complex<double>* y, const fortran_int_t incy ) {
     BLAS_ZAXPY( &n, &a, x, &incx, y, &incy );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,7 +60,8 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline void copy( int n, const float* x, int incx, float* y, int incy ) {
+inline void copy( const int n, const float* x, const int incx, float* y,
+ const int incy ) {
     cblas_scopy( n, x, incx, y, incy );
 }
 
@@ -69,7 +70,8 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline void copy( int n, const double* x, int incx, double* y, int incy ) {
+inline void copy( const int n, const double* x, const int incx, double* y,
+ const int incy ) {
     cblas_dcopy( n, x, incx, y, incy );
 }
 
@@ -78,8 +80,8 @@
 // * CBLAS backend, and
 // * complex<float> value-type.
 //
-inline void copy( int n, const std::complex<float>* x, int incx,
- std::complex<float>* y, int incy ) {
+inline void copy( const int n, const std::complex<float>* x, const int incx,
+ std::complex<float>* y, const int incy ) {
     cblas_ccopy( n, x, incx, y, incy );
 }
 
@@ -88,8 +90,8 @@
 // * CBLAS backend, and
 // * complex<double> value-type.
 //
-inline void copy( int n, const std::complex<double>* x, int incx,
- std::complex<double>* y, int incy ) {
+inline void copy( const int n, const std::complex<double>* x, const int incx,
+ std::complex<double>* y, const int incy ) {
     cblas_zcopy( n, x, incx, y, incy );
 }
 
@@ -99,7 +101,8 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline void copy( int n, const float* x, int incx, float* y, int incy ) {
+inline void copy( const int n, const float* x, const int incx, float* y,
+ const int incy ) {
     cublasScopy( n, x, incx, y, incy );
 }
 
@@ -108,7 +111,8 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline void copy( int n, const double* x, int incx, double* y, int incy ) {
+inline void copy( const int n, const double* x, const int incx, double* y,
+ const int incy ) {
     cublasDcopy( n, x, incx, y, incy );
 }
 
@@ -117,8 +121,8 @@
 // * CUBLAS backend, and
 // * complex<float> value-type.
 //
-inline void copy( int n, const std::complex<float>* x, int incx,
- std::complex<float>* y, int incy ) {
+inline void copy( const int n, const std::complex<float>* x, const int incx,
+ std::complex<float>* y, const int incy ) {
     cublasCcopy( n, x, incx, y, incy );
 }
 
@@ -127,8 +131,8 @@
 // * CUBLAS backend, and
 // * complex<double> value-type.
 //
-inline void copy( int n, const std::complex<double>* x, int incx,
- std::complex<double>* y, int incy ) {
+inline void copy( const int n, const std::complex<double>* x, const int incx,
+ std::complex<double>* y, const int incy ) {
     // NOT FOUND();
 }
 
@@ -138,8 +142,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline void copy( fortran_int_t n, const float* x, fortran_int_t incx,
- float* y, fortran_int_t incy ) {
+inline void copy( const fortran_int_t n, const float* x,
+ const fortran_int_t incx, float* y, const fortran_int_t incy ) {
     BLAS_SCOPY( &n, x, &incx, y, &incy );
 }
 
@@ -148,8 +152,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline void copy( fortran_int_t n, const double* x, fortran_int_t incx,
- double* y, fortran_int_t incy ) {
+inline void copy( const fortran_int_t n, const double* x,
+ const fortran_int_t incx, double* y, const fortran_int_t incy ) {
     BLAS_DCOPY( &n, x, &incx, y, &incy );
 }
 
@@ -158,8 +162,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<float> value-type.
 //
-inline void copy( fortran_int_t n, const std::complex<float>* x,
- fortran_int_t incx, std::complex<float>* y, fortran_int_t incy ) {
+inline void copy( const fortran_int_t n, const std::complex<float>* x,
+ const fortran_int_t incx, std::complex<float>* y,
+ const fortran_int_t incy ) {
     BLAS_CCOPY( &n, x, &incx, y, &incy );
 }
 
@@ -168,8 +173,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<double> value-type.
 //
-inline void copy( fortran_int_t n, const std::complex<double>* x,
- fortran_int_t incx, std::complex<double>* y, fortran_int_t incy ) {
+inline void copy( const fortran_int_t n, const std::complex<double>* x,
+ const fortran_int_t incx, std::complex<double>* y,
+ const fortran_int_t incy ) {
     BLAS_ZCOPY( &n, x, &incx, y, &incy );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,7 +60,8 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline float dot( int n, const float* x, int incx, const float* y, int incy ) {
+inline float dot( const int n, const float* x, const int incx, const float* y,
+ const int incy ) {
     return cblas_sdot( n, x, incx, y, incy );
 }
 
@@ -69,8 +70,8 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline double dot( int n, const double* x, int incx, const double* y,
- int incy ) {
+inline double dot( const int n, const double* x, const int incx,
+ const double* y, const int incy ) {
     return cblas_ddot( n, x, incx, y, incy );
 }
 
@@ -80,7 +81,8 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline float dot( int n, const float* x, int incx, const float* y, int incy ) {
+inline float dot( const int n, const float* x, const int incx, const float* y,
+ const int incy ) {
     return cublasSdot( n, x, incx, y, incy );
 }
 
@@ -89,8 +91,8 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline double dot( int n, const double* x, int incx, const double* y,
- int incy ) {
+inline double dot( const int n, const double* x, const int incx,
+ const double* y, const int incy ) {
     return cublasDdot( n, x, incx, y, incy );
 }
 
@@ -100,8 +102,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline float dot( fortran_int_t n, const float* x, fortran_int_t incx,
- const float* y, fortran_int_t incy ) {
+inline float dot( const fortran_int_t n, const float* x,
+ const fortran_int_t incx, const float* y, const fortran_int_t incy ) {
     return BLAS_SDOT( &n, x, &incx, y, &incy );
 }
 
@@ -110,8 +112,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline double dot( fortran_int_t n, const double* x, fortran_int_t incx,
- const double* y, fortran_int_t incy ) {
+inline double dot( const fortran_int_t n, const double* x,
+ const fortran_int_t incx, const double* y, const fortran_int_t incy ) {
     return BLAS_DDOT( &n, x, &incx, y, &incy );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,8 +60,8 @@
 // * CBLAS backend, and
 // * complex<float> value-type.
 //
-inline std::complex<float> dotc( int n, const std::complex<float>* x,
- int incx, const std::complex<float>* y, int incy ) {
+inline std::complex<float> dotc( const int n, const std::complex<float>* x,
+ const int incx, const std::complex<float>* y, const int incy ) {
     std::complex<float> result;
     cblas_cdotc_sub( n, x, incx, y, incy, &result );
     return result;
@@ -72,8 +72,8 @@
 // * CBLAS backend, and
 // * complex<double> value-type.
 //
-inline std::complex<double> dotc( int n, const std::complex<double>* x,
- int incx, const std::complex<double>* y, int incy ) {
+inline std::complex<double> dotc( const int n, const std::complex<double>* x,
+ const int incx, const std::complex<double>* y, const int incy ) {
     std::complex<double> result;
     cblas_zdotc_sub( n, x, incx, y, incy, &result );
     return result;
@@ -85,8 +85,8 @@
 // * CUBLAS backend, and
 // * complex<float> value-type.
 //
-inline std::complex<float> dotc( int n, const std::complex<float>* x,
- int incx, const std::complex<float>* y, int incy ) {
+inline std::complex<float> dotc( const int n, const std::complex<float>* x,
+ const int incx, const std::complex<float>* y, const int incy ) {
     return cublasCdotc( n, x, incx, y, incy );
 }
 
@@ -95,8 +95,8 @@
 // * CUBLAS backend, and
 // * complex<double> value-type.
 //
-inline std::complex<double> dotc( int n, const std::complex<double>* x,
- int incx, const std::complex<double>* y, int incy ) {
+inline std::complex<double> dotc( const int n, const std::complex<double>* x,
+ const int incx, const std::complex<double>* y, const int incy ) {
     return // NOT FOUND();
 }
 
@@ -106,9 +106,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<float> value-type.
 //
-inline std::complex<float> dotc( fortran_int_t n,
- const std::complex<float>* x, fortran_int_t incx,
- const std::complex<float>* y, fortran_int_t incy ) {
+inline std::complex<float> dotc( const fortran_int_t n,
+ const std::complex<float>* x, const fortran_int_t incx,
+ const std::complex<float>* y, const fortran_int_t incy ) {
     return BLAS_CDOTC( &n, x, &incx, y, &incy );
 }
 
@@ -117,9 +117,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<double> value-type.
 //
-inline std::complex<double> dotc( fortran_int_t n,
- const std::complex<double>* x, fortran_int_t incx,
- const std::complex<double>* y, fortran_int_t incy ) {
+inline std::complex<double> dotc( const fortran_int_t n,
+ const std::complex<double>* x, const fortran_int_t incx,
+ const std::complex<double>* y, const fortran_int_t incy ) {
     return BLAS_ZDOTC( &n, x, &incx, y, &incy );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,8 +60,8 @@
 // * CBLAS backend, and
 // * complex<float> value-type.
 //
-inline std::complex<float> dotu( int n, const std::complex<float>* x,
- int incx, const std::complex<float>* y, int incy ) {
+inline std::complex<float> dotu( const int n, const std::complex<float>* x,
+ const int incx, const std::complex<float>* y, const int incy ) {
     std::complex<float> result;
     cblas_cdotu_sub( n, x, incx, y, incy, &result );
     return result;
@@ -72,8 +72,8 @@
 // * CBLAS backend, and
 // * complex<double> value-type.
 //
-inline std::complex<double> dotu( int n, const std::complex<double>* x,
- int incx, const std::complex<double>* y, int incy ) {
+inline std::complex<double> dotu( const int n, const std::complex<double>* x,
+ const int incx, const std::complex<double>* y, const int incy ) {
     std::complex<double> result;
     cblas_zdotu_sub( n, x, incx, y, incy, &result );
     return result;
@@ -85,8 +85,8 @@
 // * CUBLAS backend, and
 // * complex<float> value-type.
 //
-inline std::complex<float> dotu( int n, const std::complex<float>* x,
- int incx, const std::complex<float>* y, int incy ) {
+inline std::complex<float> dotu( const int n, const std::complex<float>* x,
+ const int incx, const std::complex<float>* y, const int incy ) {
     return cublasCdotu( n, x, incx, y, incy );
 }
 
@@ -95,8 +95,8 @@
 // * CUBLAS backend, and
 // * complex<double> value-type.
 //
-inline std::complex<double> dotu( int n, const std::complex<double>* x,
- int incx, const std::complex<double>* y, int incy ) {
+inline std::complex<double> dotu( const int n, const std::complex<double>* x,
+ const int incx, const std::complex<double>* y, const int incy ) {
     return cublasZdotu( n, x, incx, y, incy );
 }
 
@@ -106,9 +106,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<float> value-type.
 //
-inline std::complex<float> dotu( fortran_int_t n,
- const std::complex<float>* x, fortran_int_t incx,
- const std::complex<float>* y, fortran_int_t incy ) {
+inline std::complex<float> dotu( const fortran_int_t n,
+ const std::complex<float>* x, const fortran_int_t incx,
+ const std::complex<float>* y, const fortran_int_t incy ) {
     return BLAS_CDOTU( &n, x, &incx, y, &incy );
 }
 
@@ -117,9 +117,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<double> value-type.
 //
-inline std::complex<double> dotu( fortran_int_t n,
- const std::complex<double>* x, fortran_int_t incx,
- const std::complex<double>* y, fortran_int_t incy ) {
+inline std::complex<double> dotu( const fortran_int_t n,
+ const std::complex<double>* x, const fortran_int_t incx,
+ const std::complex<double>* y, const fortran_int_t incy ) {
     return BLAS_ZDOTU( &n, x, &incx, y, &incy );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,7 +60,7 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline float nrm2( int n, const float* x, int incx ) {
+inline float nrm2( const int n, const float* x, const int incx ) {
     return cblas_snrm2( n, x, incx );
 }
 
@@ -69,7 +69,7 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline double nrm2( int n, const double* x, int incx ) {
+inline double nrm2( const int n, const double* x, const int incx ) {
     return cblas_dnrm2( n, x, incx );
 }
 
@@ -79,7 +79,7 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline float nrm2( int n, const float* x, int incx ) {
+inline float nrm2( const int n, const float* x, const int incx ) {
     return cublasSnrm2( n, x, incx );
 }
 
@@ -88,7 +88,7 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline double nrm2( int n, const double* x, int incx ) {
+inline double nrm2( const int n, const double* x, const int incx ) {
     return cublasDnrm2( n, x, incx );
 }
 
@@ -98,7 +98,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline float nrm2( fortran_int_t n, const float* x, fortran_int_t incx ) {
+inline float nrm2( const fortran_int_t n, const float* x,
+ const fortran_int_t incx ) {
     return BLAS_SNRM2( &n, x, &incx );
 }
 
@@ -107,7 +108,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline double nrm2( fortran_int_t n, const double* x, fortran_int_t incx ) {
+inline double nrm2( const fortran_int_t n, const double* x,
+ const fortran_int_t incx ) {
     return BLAS_DNRM2( &n, x, &incx );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,8 +60,8 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline void rot( int n, const float* x, int incx, float* y, int incy, float c,
- float s ) {
+inline void rot( const int n, const float* x, const int incx, float* y,
+ const int incy, const float c, const float s ) {
     cblas_srot( n, x, incx, y, incy, c, s );
 }
 
@@ -70,8 +70,8 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline void rot( int n, const double* x, int incx, double* y, int incy,
- double c, double s ) {
+inline void rot( const int n, const double* x, const int incx, double* y,
+ const int incy, const double c, const double s ) {
     cblas_drot( n, x, incx, y, incy, c, s );
 }
 
@@ -81,8 +81,8 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline void rot( int n, const float* x, int incx, float* y, int incy, float c,
- float s ) {
+inline void rot( const int n, const float* x, const int incx, float* y,
+ const int incy, const float c, const float s ) {
     cublasSrot( n, x, incx, y, incy, c, s );
 }
 
@@ -91,8 +91,8 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline void rot( int n, const double* x, int incx, double* y, int incy,
- double c, double s ) {
+inline void rot( const int n, const double* x, const int incx, double* y,
+ const int incy, const double c, const double s ) {
     cublasDrot( n, x, incx, y, incy, c, s );
 }
 
@@ -102,8 +102,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline void rot( fortran_int_t n, const float* x, fortran_int_t incx,
- float* y, fortran_int_t incy, float c, float s ) {
+inline void rot( const fortran_int_t n, const float* x,
+ const fortran_int_t incx, float* y, const fortran_int_t incy,
+ const float c, const float s ) {
     BLAS_SROT( &n, x, &incx, y, &incy, &c, &s );
 }
 
@@ -112,8 +113,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline void rot( fortran_int_t n, const double* x, fortran_int_t incx,
- double* y, fortran_int_t incy, double c, double s ) {
+inline void rot( const fortran_int_t n, const double* x,
+ const fortran_int_t incx, double* y, const fortran_int_t incy,
+ const double c, const double s ) {
     BLAS_DROT( &n, x, &incx, y, &incy, &c, &s );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,8 +60,8 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline void rotm( int n, float* x, int incx, float* y, int incy,
- float* param ) {
+inline void rotm( const int n, float* x, const int incx, float* y,
+ const int incy, float* param ) {
     cblas_srotm( n, x, incx, y, incy, param );
 }
 
@@ -70,8 +70,8 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline void rotm( int n, double* x, int incx, double* y, int incy,
- double* param ) {
+inline void rotm( const int n, double* x, const int incx, double* y,
+ const int incy, double* param ) {
     cblas_drotm( n, x, incx, y, incy, param );
 }
 
@@ -81,8 +81,8 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline void rotm( int n, float* x, int incx, float* y, int incy,
- float* param ) {
+inline void rotm( const int n, float* x, const int incx, float* y,
+ const int incy, float* param ) {
     cublasSrotm( n, x, incx, y, incy, param );
 }
 
@@ -91,8 +91,8 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline void rotm( int n, double* x, int incx, double* y, int incy,
- double* param ) {
+inline void rotm( const int n, double* x, const int incx, double* y,
+ const int incy, double* param ) {
     cublasDrotm( n, x, incx, y, incy, param );
 }
 
@@ -102,8 +102,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline void rotm( fortran_int_t n, float* x, fortran_int_t incx, float* y,
- fortran_int_t incy, float* param ) {
+inline void rotm( const fortran_int_t n, float* x, const fortran_int_t incx,
+ float* y, const fortran_int_t incy, float* param ) {
     BLAS_SROTM( &n, x, &incx, y, &incy, param );
 }
 
@@ -112,8 +112,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline void rotm( fortran_int_t n, double* x, fortran_int_t incx, double* y,
- fortran_int_t incy, double* param ) {
+inline void rotm( const fortran_int_t n, double* x, const fortran_int_t incx,
+ double* y, const fortran_int_t incy, double* param ) {
     BLAS_DROTM( &n, x, &incx, y, &incy, param );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,7 +60,8 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline void rotmg( float& d1, float& d2, float& x1, float y1, float* sparam ) {
+inline void rotmg( float& d1, float& d2, float& x1, const float y1,
+ float* sparam ) {
     cblas_srotmg( &d1, &d2, &x1, &y1, sparam );
 }
 
@@ -69,7 +70,7 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline void rotmg( double& d1, double& d2, double& x1, double y1,
+inline void rotmg( double& d1, double& d2, double& x1, const double y1,
         double* dparam ) {
     cblas_drotmg( &d1, &d2, &x1, &y1, dparam );
 }
@@ -80,7 +81,8 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline void rotmg( float& d1, float& d2, float& x1, float y1, float* sparam ) {
+inline void rotmg( float& d1, float& d2, float& x1, const float y1,
+ float* sparam ) {
     cublasSrotmg( &d1, &d2, &x1, &y1, sparam );
 }
 
@@ -89,7 +91,7 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline void rotmg( double& d1, double& d2, double& x1, double y1,
+inline void rotmg( double& d1, double& d2, double& x1, const double y1,
         double* dparam ) {
     cublasDrotmg( &d1, &d2, &x1, &y1, dparam );
 }
@@ -100,7 +102,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline void rotmg( float& d1, float& d2, float& x1, float y1, float* sparam ) {
+inline void rotmg( float& d1, float& d2, float& x1, const float y1,
+ float* sparam ) {
     BLAS_SROTMG( &d1, &d2, &x1, &y1, sparam );
 }
 
@@ -109,7 +112,7 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline void rotmg( double& d1, double& d2, double& x1, double y1,
+inline void rotmg( double& d1, double& d2, double& x1, const double y1,
         double* dparam ) {
     BLAS_DROTMG( &d1, &d2, &x1, &y1, dparam );
 }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,7 +60,7 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline void scal( int n, float a, float* x, int incx ) {
+inline void scal( const int n, const float a, float* x, const int incx ) {
     cblas_sscal( n, a, x, incx );
 }
 
@@ -69,7 +69,7 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline void scal( int n, double a, double* x, int incx ) {
+inline void scal( const int n, const double a, double* x, const int incx ) {
     cblas_dscal( n, a, x, incx );
 }
 
@@ -78,8 +78,8 @@
 // * CBLAS backend, and
 // * complex<float> value-type.
 //
-inline void scal( int n, std::complex<float> a, std::complex<float>* x,
- int incx ) {
+inline void scal( const int n, const std::complex<float> a,
+ std::complex<float>* x, const int incx ) {
     cblas_cscal( n, &a, x, incx );
 }
 
@@ -88,8 +88,8 @@
 // * CBLAS backend, and
 // * complex<double> value-type.
 //
-inline void scal( int n, std::complex<double> a, std::complex<double>* x,
- int incx ) {
+inline void scal( const int n, const std::complex<double> a,
+ std::complex<double>* x, const int incx ) {
     cblas_zscal( n, &a, x, incx );
 }
 
@@ -99,7 +99,7 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline void scal( int n, float a, float* x, int incx ) {
+inline void scal( const int n, const float a, float* x, const int incx ) {
     cublasSscal( n, a, x, incx );
 }
 
@@ -108,7 +108,7 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline void scal( int n, double a, double* x, int incx ) {
+inline void scal( const int n, const double a, double* x, const int incx ) {
     cublasDscal( n, a, x, incx );
 }
 
@@ -117,8 +117,8 @@
 // * CUBLAS backend, and
 // * complex<float> value-type.
 //
-inline void scal( int n, std::complex<float> a, std::complex<float>* x,
- int incx ) {
+inline void scal( const int n, const std::complex<float> a,
+ std::complex<float>* x, const int incx ) {
     cublasCscal( n, a, x, incx );
 }
 
@@ -127,8 +127,8 @@
 // * CUBLAS backend, and
 // * complex<double> value-type.
 //
-inline void scal( int n, std::complex<double> a, std::complex<double>* x,
- int incx ) {
+inline void scal( const int n, const std::complex<double> a,
+ std::complex<double>* x, const int incx ) {
     cublasZscal( n, a, x, incx );
 }
 
@@ -138,7 +138,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline void scal( fortran_int_t n, float a, float* x, fortran_int_t incx ) {
+inline void scal( const fortran_int_t n, const float a, float* x,
+ const fortran_int_t incx ) {
     BLAS_SSCAL( &n, &a, x, &incx );
 }
 
@@ -147,7 +148,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline void scal( fortran_int_t n, double a, double* x, fortran_int_t incx ) {
+inline void scal( const fortran_int_t n, const double a, double* x,
+ const fortran_int_t incx ) {
     BLAS_DSCAL( &n, &a, x, &incx );
 }
 
@@ -156,8 +158,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<float> value-type.
 //
-inline void scal( fortran_int_t n, std::complex<float> a,
- std::complex<float>* x, fortran_int_t incx ) {
+inline void scal( const fortran_int_t n, const std::complex<float> a,
+ std::complex<float>* x, const fortran_int_t incx ) {
     BLAS_CSCAL( &n, &a, x, &incx );
 }
 
@@ -166,8 +168,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<double> value-type.
 //
-inline void scal( fortran_int_t n, std::complex<double> a,
- std::complex<double>* x, fortran_int_t incx ) {
+inline void scal( const fortran_int_t n, const std::complex<double> a,
+ std::complex<double>* x, const fortran_int_t incx ) {
     BLAS_ZSCAL( &n, &a, x, &incx );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,8 +60,8 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline double sdot( int n, const float* sx, int incx, const float* sy,
- int incy ) {
+inline double sdot( const int n, const float* sx, const int incx,
+ const float* sy, const int incy ) {
     return cblas_dsdot( n, sx, incx, sy, incy );
 }
 
@@ -71,8 +71,8 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline double sdot( int n, const float* sx, int incx, const float* sy,
- int incy ) {
+inline double sdot( const int n, const float* sx, const int incx,
+ const float* sy, const int incy ) {
     return // NOT FOUND();
 }
 
@@ -82,8 +82,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline double sdot( fortran_int_t n, const float* sx, fortran_int_t incx,
- const float* sy, fortran_int_t incy ) {
+inline double sdot( const fortran_int_t n, const float* sx,
+ const fortran_int_t incx, const float* sy, const fortran_int_t incy ) {
     return BLAS_DSDOT( &n, sx, &incx, sy, &incy );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -60,7 +60,8 @@
 // * CBLAS backend, and
 // * float value-type.
 //
-inline void swap( int n, float* x, int incx, float* y, int incy ) {
+inline void swap( const int n, float* x, const int incx, float* y,
+ const int incy ) {
     cblas_sswap( n, x, incx, y, incy );
 }
 
@@ -69,7 +70,8 @@
 // * CBLAS backend, and
 // * double value-type.
 //
-inline void swap( int n, double* x, int incx, double* y, int incy ) {
+inline void swap( const int n, double* x, const int incx, double* y,
+ const int incy ) {
     cblas_dswap( n, x, incx, y, incy );
 }
 
@@ -78,8 +80,8 @@
 // * CBLAS backend, and
 // * complex<float> value-type.
 //
-inline void swap( int n, std::complex<float>* x, int incx,
- std::complex<float>* y, int incy ) {
+inline void swap( const int n, std::complex<float>* x, const int incx,
+ std::complex<float>* y, const int incy ) {
     cblas_cswap( n, x, incx, y, incy );
 }
 
@@ -88,8 +90,8 @@
 // * CBLAS backend, and
 // * complex<double> value-type.
 //
-inline void swap( int n, std::complex<double>* x, int incx,
- std::complex<double>* y, int incy ) {
+inline void swap( const int n, std::complex<double>* x, const int incx,
+ std::complex<double>* y, const int incy ) {
     cblas_zswap( n, x, incx, y, incy );
 }
 
@@ -99,7 +101,8 @@
 // * CUBLAS backend, and
 // * float value-type.
 //
-inline void swap( int n, float* x, int incx, float* y, int incy ) {
+inline void swap( const int n, float* x, const int incx, float* y,
+ const int incy ) {
     cublasSswap( n, x, incx, y, incy );
 }
 
@@ -108,7 +111,8 @@
 // * CUBLAS backend, and
 // * double value-type.
 //
-inline void swap( int n, double* x, int incx, double* y, int incy ) {
+inline void swap( const int n, double* x, const int incx, double* y,
+ const int incy ) {
     cublasDswap( n, x, incx, y, incy );
 }
 
@@ -117,8 +121,8 @@
 // * CUBLAS backend, and
 // * complex<float> value-type.
 //
-inline void swap( int n, std::complex<float>* x, int incx,
- std::complex<float>* y, int incy ) {
+inline void swap( const int n, std::complex<float>* x, const int incx,
+ std::complex<float>* y, const int incy ) {
     cublasCswap( n, x, incx, y, incy );
 }
 
@@ -127,8 +131,8 @@
 // * CUBLAS backend, and
 // * complex<double> value-type.
 //
-inline void swap( int n, std::complex<double>* x, int incx,
- std::complex<double>* y, int incy ) {
+inline void swap( const int n, std::complex<double>* x, const int incx,
+ std::complex<double>* y, const int incy ) {
     // NOT FOUND();
 }
 
@@ -138,8 +142,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * float value-type.
 //
-inline void swap( fortran_int_t n, float* x, fortran_int_t incx, float* y,
- fortran_int_t incy ) {
+inline void swap( const fortran_int_t n, float* x, const fortran_int_t incx,
+ float* y, const fortran_int_t incy ) {
     BLAS_SSWAP( &n, x, &incx, y, &incy );
 }
 
@@ -148,8 +152,8 @@
 // * netlib-compatible BLAS backend (the default), and
 // * double value-type.
 //
-inline void swap( fortran_int_t n, double* x, fortran_int_t incx, double* y,
- fortran_int_t incy ) {
+inline void swap( const fortran_int_t n, double* x, const fortran_int_t incx,
+ double* y, const fortran_int_t incy ) {
     BLAS_DSWAP( &n, x, &incx, y, &incy );
 }
 
@@ -158,8 +162,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<float> value-type.
 //
-inline void swap( fortran_int_t n, std::complex<float>* x, fortran_int_t incx,
- std::complex<float>* y, fortran_int_t incy ) {
+inline void swap( const fortran_int_t n, std::complex<float>* x,
+ const fortran_int_t incx, std::complex<float>* y,
+ const fortran_int_t incy ) {
     BLAS_CSWAP( &n, x, &incx, y, &incy );
 }
 
@@ -168,8 +173,9 @@
 // * netlib-compatible BLAS backend (the default), and
 // * complex<double> value-type.
 //
-inline void swap( fortran_int_t n, std::complex<double>* x,
- fortran_int_t incx, std::complex<double>* y, fortran_int_t incy ) {
+inline void swap( const fortran_int_t n, std::complex<double>* x,
+ const fortran_int_t incx, std::complex<double>* y,
+ const fortran_int_t incy ) {
     BLAS_ZSWAP( &n, x, &incx, y, &incy );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -64,9 +64,10 @@
 // * float value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, int m, int n, int kl, int ku, float alpha,
- const float* a, int lda, const float* x, int incx, float beta,
- float* y, int incy ) {
+inline void gbmv( Order, Trans, const int m, const int n, const int kl,
+ const int ku, const float alpha, const float* a, const int lda,
+ const float* x, const int incx, const float beta, float* y,
+ const int incy ) {
     cblas_sgbmv( cblas_option< Order >::value, cblas_option< Trans >::value,
             m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy );
 }
@@ -77,9 +78,10 @@
 // * double value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, int m, int n, int kl, int ku, double alpha,
- const double* a, int lda, const double* x, int incx, double beta,
- double* y, int incy ) {
+inline void gbmv( Order, Trans, const int m, const int n, const int kl,
+ const int ku, const double alpha, const double* a, const int lda,
+ const double* x, const int incx, const double beta, double* y,
+ const int incy ) {
     cblas_dgbmv( cblas_option< Order >::value, cblas_option< Trans >::value,
             m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy );
 }
@@ -90,10 +92,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, int m, int n, int kl, int ku,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* x, int incx, std::complex<float> beta,
- std::complex<float>* y, int incy ) {
+inline void gbmv( Order, Trans, const int m, const int n, const int kl,
+ const int ku, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda,
+ const std::complex<float>* x, const int incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const int incy ) {
     cblas_cgbmv( cblas_option< Order >::value, cblas_option< Trans >::value,
             m, n, kl, ku, &alpha, a, lda, x, incx, &beta, y, incy );
 }
@@ -104,10 +108,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, int m, int n, int kl, int ku,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* x, int incx, std::complex<double> beta,
- std::complex<double>* y, int incy ) {
+inline void gbmv( Order, Trans, const int m, const int n, const int kl,
+ const int ku, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda,
+ const std::complex<double>* x, const int incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const int incy ) {
     cblas_zgbmv( cblas_option< Order >::value, cblas_option< Trans >::value,
             m, n, kl, ku, &alpha, a, lda, x, incx, &beta, y, incy );
 }
@@ -119,9 +125,10 @@
 // * float value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, int m, int n, int kl, int ku, float alpha,
- const float* a, int lda, const float* x, int incx, float beta,
- float* y, int incy ) {
+inline void gbmv( Order, Trans, const int m, const int n, const int kl,
+ const int ku, const float alpha, const float* a, const int lda,
+ const float* x, const int incx, const float beta, float* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSgbmv( blas_option< Trans >::value, m, n, kl, ku, alpha, a, lda, x,
             incx, beta, y, incy );
@@ -133,9 +140,10 @@
 // * double value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, int m, int n, int kl, int ku, double alpha,
- const double* a, int lda, const double* x, int incx, double beta,
- double* y, int incy ) {
+inline void gbmv( Order, Trans, const int m, const int n, const int kl,
+ const int ku, const double alpha, const double* a, const int lda,
+ const double* x, const int incx, const double beta, double* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -146,10 +154,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, int m, int n, int kl, int ku,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* x, int incx, std::complex<float> beta,
- std::complex<float>* y, int incy ) {
+inline void gbmv( Order, Trans, const int m, const int n, const int kl,
+ const int ku, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda,
+ const std::complex<float>* x, const int incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCgbmv( blas_option< Trans >::value, m, n, kl, ku, alpha, a, lda, x,
             incx, beta, y, incy );
@@ -161,10 +171,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, int m, int n, int kl, int ku,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* x, int incx, std::complex<double> beta,
- std::complex<double>* y, int incy ) {
+inline void gbmv( Order, Trans, const int m, const int n, const int kl,
+ const int ku, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda,
+ const std::complex<double>* x, const int incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -176,10 +188,11 @@
 // * float value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, fortran_int_t m, fortran_int_t n,
- fortran_int_t kl, fortran_int_t ku, float alpha, const float* a,
- fortran_int_t lda, const float* x, fortran_int_t incx, float beta,
- float* y, fortran_int_t incy ) {
+inline void gbmv( Order, Trans, const fortran_int_t m, const fortran_int_t n,
+ const fortran_int_t kl, const fortran_int_t ku, const float alpha,
+ const float* a, const fortran_int_t lda, const float* x,
+ const fortran_int_t incx, const float beta, float* y,
+ const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a,
             &lda, x, &incx, &beta, y, &incy );
@@ -191,10 +204,11 @@
 // * double value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, fortran_int_t m, fortran_int_t n,
- fortran_int_t kl, fortran_int_t ku, double alpha, const double* a,
- fortran_int_t lda, const double* x, fortran_int_t incx, double beta,
- double* y, fortran_int_t incy ) {
+inline void gbmv( Order, Trans, const fortran_int_t m, const fortran_int_t n,
+ const fortran_int_t kl, const fortran_int_t ku, const double alpha,
+ const double* a, const fortran_int_t lda, const double* x,
+ const fortran_int_t incx, const double beta, double* y,
+ const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a,
             &lda, x, &incx, &beta, y, &incy );
@@ -206,12 +220,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, fortran_int_t m, fortran_int_t n,
- fortran_int_t kl, fortran_int_t ku, std::complex<float> alpha,
- const std::complex<float>* a, fortran_int_t lda,
- const std::complex<float>* x, fortran_int_t incx,
- std::complex<float> beta, std::complex<float>* y,
- fortran_int_t incy ) {
+inline void gbmv( Order, Trans, const fortran_int_t m, const fortran_int_t n,
+ const fortran_int_t kl, const fortran_int_t ku,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const fortran_int_t lda, const std::complex<float>* x,
+ const fortran_int_t incx, const std::complex<float> beta,
+ std::complex<float>* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a,
             &lda, x, &incx, &beta, y, &incy );
@@ -223,12 +237,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, fortran_int_t m, fortran_int_t n,
- fortran_int_t kl, fortran_int_t ku, std::complex<double> alpha,
- const std::complex<double>* a, fortran_int_t lda,
- const std::complex<double>* x, fortran_int_t incx,
- std::complex<double> beta, std::complex<double>* y,
- fortran_int_t incy ) {
+inline void gbmv( Order, Trans, const fortran_int_t m, const fortran_int_t n,
+ const fortran_int_t kl, const fortran_int_t ku,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const fortran_int_t lda, const std::complex<double>* x,
+ const fortran_int_t incx, const std::complex<double> beta,
+ std::complex<double>* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a,
             &lda, x, &incx, &beta, y, &incy );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,8 +63,9 @@
 // * float value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, int m, int n, float alpha, const float* a,
- int lda, const float* x, int incx, float beta, float* y, int incy ) {
+inline void gemv( Order, 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 ) {
     cblas_sgemv( cblas_option< Order >::value, cblas_option< Trans >::value,
             m, n, alpha, a, lda, x, incx, beta, y, incy );
 }
@@ -75,9 +76,9 @@
 // * double value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, int m, int n, double alpha, const double* a,
- int lda, const double* x, int incx, double beta, double* y,
- int incy ) {
+inline void gemv( Order, 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 ) {
     cblas_dgemv( cblas_option< Order >::value, cblas_option< Trans >::value,
             m, n, alpha, a, lda, x, incx, beta, y, incy );
 }
@@ -88,10 +89,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, int m, int n, std::complex<float> alpha,
- const std::complex<float>* a, int lda, const std::complex<float>* x,
- int incx, std::complex<float> beta, std::complex<float>* y,
- int incy ) {
+inline void gemv( Order, Trans, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* x, const int incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const int incy ) {
     cblas_cgemv( cblas_option< Order >::value, cblas_option< Trans >::value,
             m, n, &alpha, a, lda, x, incx, &beta, y, incy );
 }
@@ -102,10 +104,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, int m, int n, std::complex<double> alpha,
- const std::complex<double>* a, int lda, const std::complex<double>* x,
- int incx, std::complex<double> beta, std::complex<double>* y,
- int incy ) {
+inline void gemv( Order, Trans, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* x, const int incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const int incy ) {
     cblas_zgemv( cblas_option< Order >::value, cblas_option< Trans >::value,
             m, n, &alpha, a, lda, x, incx, &beta, y, incy );
 }
@@ -117,8 +120,9 @@
 // * float value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, int m, int n, float alpha, const float* a,
- int lda, const float* x, int incx, float beta, float* y, int incy ) {
+inline void gemv( Order, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx,
             beta, y, incy );
@@ -130,9 +134,9 @@
 // * double value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, int m, int n, double alpha, const double* a,
- int lda, const double* x, int incx, double beta, double* y,
- int incy ) {
+inline void gemv( Order, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx,
             beta, y, incy );
@@ -144,10 +148,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, int m, int n, std::complex<float> alpha,
- const std::complex<float>* a, int lda, const std::complex<float>* x,
- int incx, std::complex<float> beta, std::complex<float>* y,
- int incy ) {
+inline void gemv( Order, Trans, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* x, const int incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx,
             beta, y, incy );
@@ -159,10 +164,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, int m, int n, std::complex<double> alpha,
- const std::complex<double>* a, int lda, const std::complex<double>* x,
- int incx, std::complex<double> beta, std::complex<double>* y,
- int incy ) {
+inline void gemv( Order, Trans, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* x, const int incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasZgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx,
             beta, y, incy );
@@ -175,9 +181,10 @@
 // * float value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, fortran_int_t m, fortran_int_t n, float alpha,
- const float* a, fortran_int_t lda, const float* x, fortran_int_t incx,
- float beta, float* y, fortran_int_t incy ) {
+inline void gemv( Order, Trans, const fortran_int_t m, const fortran_int_t n,
+ const float alpha, const float* a, const fortran_int_t lda,
+ const float* x, const fortran_int_t incx, const float beta, float* y,
+ const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x,
             &incx, &beta, y, &incy );
@@ -189,9 +196,10 @@
 // * double value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, fortran_int_t m, fortran_int_t n,
- double alpha, const double* a, fortran_int_t lda, const double* x,
- fortran_int_t incx, double beta, double* y, fortran_int_t incy ) {
+inline void gemv( Order, Trans, const fortran_int_t m, const fortran_int_t n,
+ const double alpha, const double* a, const fortran_int_t lda,
+ const double* x, const fortran_int_t incx, const double beta,
+ double* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x,
             &incx, &beta, y, &incy );
@@ -203,11 +211,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, fortran_int_t m, fortran_int_t n,
- std::complex<float> alpha, const std::complex<float>* a,
- fortran_int_t lda, const std::complex<float>* x, fortran_int_t incx,
- std::complex<float> beta, std::complex<float>* y,
- fortran_int_t incy ) {
+inline void gemv( Order, Trans, const fortran_int_t m, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const fortran_int_t lda, const std::complex<float>* x,
+ const fortran_int_t incx, const std::complex<float> beta,
+ std::complex<float>* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x,
             &incx, &beta, y, &incy );
@@ -219,11 +227,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename Trans >
-inline void gemv( Order, Trans, fortran_int_t m, fortran_int_t n,
- std::complex<double> alpha, const std::complex<double>* a,
- fortran_int_t lda, const std::complex<double>* x, fortran_int_t incx,
- std::complex<double> beta, std::complex<double>* y,
- fortran_int_t incy ) {
+inline void gemv( Order, Trans, const fortran_int_t m, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const fortran_int_t lda, const std::complex<double>* x,
+ const fortran_int_t incx, const std::complex<double> beta,
+ std::complex<double>* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x,
             &incx, &beta, y, &incy );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -62,8 +62,9 @@
 // * float value-type.
 //
 template< typename Order >
-inline void ger( Order, int m, int n, float alpha, const float* x, int incx,
- const float* y, int incy, float* a, int lda ) {
+inline void ger( Order, 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 ) {
     cblas_sger( cblas_option< Order >::value, m, n, alpha, x, incx, y, incy,
             a, lda );
 }
@@ -74,8 +75,9 @@
 // * double value-type.
 //
 template< typename Order >
-inline void ger( Order, int m, int n, double alpha, const double* x, int incx,
- const double* y, int incy, double* a, int lda ) {
+inline void ger( Order, 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 ) {
     cblas_dger( cblas_option< Order >::value, m, n, alpha, x, incx, y, incy,
             a, lda );
 }
@@ -87,8 +89,9 @@
 // * float value-type.
 //
 template< typename Order >
-inline void ger( Order, int m, int n, float alpha, const float* x, int incx,
- const float* y, int incy, float* a, int lda ) {
+inline void ger( Order, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSger( m, n, alpha, x, incx, y, incy, a, lda );
 }
@@ -99,8 +102,9 @@
 // * double value-type.
 //
 template< typename Order >
-inline void ger( Order, int m, int n, double alpha, const double* x, int incx,
- const double* y, int incy, double* a, int lda ) {
+inline void ger( Order, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDger( m, n, alpha, x, incx, y, incy, a, lda );
 }
@@ -112,9 +116,10 @@
 // * float value-type.
 //
 template< typename Order >
-inline void ger( Order, fortran_int_t m, fortran_int_t n, float alpha,
- const float* x, fortran_int_t incx, const float* y,
- fortran_int_t incy, float* a, fortran_int_t lda ) {
+inline void ger( Order, const fortran_int_t m, const fortran_int_t n,
+ const float alpha, const float* x, const fortran_int_t incx,
+ const float* y, const fortran_int_t incy, float* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SGER( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
 }
@@ -125,9 +130,10 @@
 // * double value-type.
 //
 template< typename Order >
-inline void ger( Order, fortran_int_t m, fortran_int_t n, double alpha,
- const double* x, fortran_int_t incx, const double* y,
- fortran_int_t incy, double* a, fortran_int_t lda ) {
+inline void ger( Order, const fortran_int_t m, const fortran_int_t n,
+ const double alpha, const double* x, const fortran_int_t incx,
+ const double* y, const fortran_int_t incy, double* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DGER( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
 }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -62,9 +62,10 @@
 // * complex<float> value-type.
 //
 template< typename Order >
-inline void gerc( Order, int m, int n, std::complex<float> alpha,
- const std::complex<float>* x, int incx, const std::complex<float>* y,
- int incy, std::complex<float>* a, int lda ) {
+inline void gerc( Order, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* x,
+ const int incx, const std::complex<float>* y, const int incy,
+ std::complex<float>* a, const int lda ) {
     cblas_cgerc( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy,
             a, lda );
 }
@@ -75,10 +76,10 @@
 // * complex<double> value-type.
 //
 template< typename Order >
-inline void gerc( Order, int m, int n, std::complex<double> alpha,
- const std::complex<double>* x, int incx,
- const std::complex<double>* y, int incy, std::complex<double>* a,
- int lda ) {
+inline void gerc( Order, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* x,
+ const int incx, const std::complex<double>* y, const int incy,
+ std::complex<double>* a, const int lda ) {
     cblas_zgerc( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy,
             a, lda );
 }
@@ -90,9 +91,10 @@
 // * complex<float> value-type.
 //
 template< typename Order >
-inline void gerc( Order, int m, int n, std::complex<float> alpha,
- const std::complex<float>* x, int incx, const std::complex<float>* y,
- int incy, std::complex<float>* a, int lda ) {
+inline void gerc( Order, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* x,
+ const int incx, const std::complex<float>* y, const int incy,
+ std::complex<float>* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCgerc( m, n, alpha, x, incx, y, incy, a, lda );
 }
@@ -103,10 +105,10 @@
 // * complex<double> value-type.
 //
 template< typename Order >
-inline void gerc( Order, int m, int n, std::complex<double> alpha,
- const std::complex<double>* x, int incx,
- const std::complex<double>* y, int incy, std::complex<double>* a,
- int lda ) {
+inline void gerc( Order, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* x,
+ const int incx, const std::complex<double>* y, const int incy,
+ std::complex<double>* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -118,10 +120,11 @@
 // * complex<float> value-type.
 //
 template< typename Order >
-inline void gerc( Order, fortran_int_t m, fortran_int_t n,
- std::complex<float> alpha, const std::complex<float>* x,
- fortran_int_t incx, const std::complex<float>* y, fortran_int_t incy,
- std::complex<float>* a, fortran_int_t lda ) {
+inline void gerc( Order, const fortran_int_t m, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* x,
+ const fortran_int_t incx, const std::complex<float>* y,
+ const fortran_int_t incy, std::complex<float>* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CGERC( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
 }
@@ -132,10 +135,11 @@
 // * complex<double> value-type.
 //
 template< typename Order >
-inline void gerc( Order, fortran_int_t m, fortran_int_t n,
- std::complex<double> alpha, const std::complex<double>* x,
- fortran_int_t incx, const std::complex<double>* y, fortran_int_t incy,
- std::complex<double>* a, fortran_int_t lda ) {
+inline void gerc( Order, const fortran_int_t m, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* x,
+ const fortran_int_t incx, const std::complex<double>* y,
+ const fortran_int_t incy, std::complex<double>* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZGERC( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
 }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -62,9 +62,10 @@
 // * complex<float> value-type.
 //
 template< typename Order >
-inline void geru( Order, int m, int n, std::complex<float> alpha,
- const std::complex<float>* x, int incx, const std::complex<float>* y,
- int incy, std::complex<float>* a, int lda ) {
+inline void geru( Order, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* x,
+ const int incx, const std::complex<float>* y, const int incy,
+ std::complex<float>* a, const int lda ) {
     cblas_cgeru( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy,
             a, lda );
 }
@@ -75,10 +76,10 @@
 // * complex<double> value-type.
 //
 template< typename Order >
-inline void geru( Order, int m, int n, std::complex<double> alpha,
- const std::complex<double>* x, int incx,
- const std::complex<double>* y, int incy, std::complex<double>* a,
- int lda ) {
+inline void geru( Order, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* x,
+ const int incx, const std::complex<double>* y, const int incy,
+ std::complex<double>* a, const int lda ) {
     cblas_zgeru( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy,
             a, lda );
 }
@@ -90,9 +91,10 @@
 // * complex<float> value-type.
 //
 template< typename Order >
-inline void geru( Order, int m, int n, std::complex<float> alpha,
- const std::complex<float>* x, int incx, const std::complex<float>* y,
- int incy, std::complex<float>* a, int lda ) {
+inline void geru( Order, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* x,
+ const int incx, const std::complex<float>* y, const int incy,
+ std::complex<float>* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCgeru( m, n, alpha, x, incx, y, incy, a, lda );
 }
@@ -103,10 +105,10 @@
 // * complex<double> value-type.
 //
 template< typename Order >
-inline void geru( Order, int m, int n, std::complex<double> alpha,
- const std::complex<double>* x, int incx,
- const std::complex<double>* y, int incy, std::complex<double>* a,
- int lda ) {
+inline void geru( Order, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* x,
+ const int incx, const std::complex<double>* y, const int incy,
+ std::complex<double>* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -118,10 +120,11 @@
 // * complex<float> value-type.
 //
 template< typename Order >
-inline void geru( Order, fortran_int_t m, fortran_int_t n,
- std::complex<float> alpha, const std::complex<float>* x,
- fortran_int_t incx, const std::complex<float>* y, fortran_int_t incy,
- std::complex<float>* a, fortran_int_t lda ) {
+inline void geru( Order, const fortran_int_t m, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* x,
+ const fortran_int_t incx, const std::complex<float>* y,
+ const fortran_int_t incy, std::complex<float>* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CGERU( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
 }
@@ -132,10 +135,11 @@
 // * complex<double> value-type.
 //
 template< typename Order >
-inline void geru( Order, fortran_int_t m, fortran_int_t n,
- std::complex<double> alpha, const std::complex<double>* x,
- fortran_int_t incx, const std::complex<double>* y, fortran_int_t incy,
- std::complex<double>* a, fortran_int_t lda ) {
+inline void geru( Order, const fortran_int_t m, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* x,
+ const fortran_int_t incx, const std::complex<double>* y,
+ const fortran_int_t incy, std::complex<double>* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZGERU( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
 }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -64,10 +64,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, int n, int k, std::complex<float> alpha,
- const std::complex<float>* a, int lda, const std::complex<float>* x,
- int incx, std::complex<float> beta, std::complex<float>* y,
- int incy ) {
+inline void hbmv( Order, UpLo, const int n, const int k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* x, const int incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const int incy ) {
     cblas_chbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             k, &alpha, a, lda, x, incx, &beta, y, incy );
 }
@@ -78,10 +79,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, int n, int k, std::complex<double> alpha,
- const std::complex<double>* a, int lda, const std::complex<double>* x,
- int incx, std::complex<double> beta, std::complex<double>* y,
- int incy ) {
+inline void hbmv( Order, UpLo, const int n, const int k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* x, const int incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const int incy ) {
     cblas_zhbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             k, &alpha, a, lda, x, incx, &beta, y, incy );
 }
@@ -93,10 +95,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, int n, int k, std::complex<float> alpha,
- const std::complex<float>* a, int lda, const std::complex<float>* x,
- int incx, std::complex<float> beta, std::complex<float>* y,
- int incy ) {
+inline void hbmv( Order, UpLo, const int n, const int k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* x, const int incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasChbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx,
             beta, y, incy );
@@ -108,10 +111,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, int n, int k, std::complex<double> alpha,
- const std::complex<double>* a, int lda, const std::complex<double>* x,
- int incx, std::complex<double> beta, std::complex<double>* y,
- int incy ) {
+inline void hbmv( Order, UpLo, const int n, const int k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* x, const int incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -123,11 +127,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, fortran_int_t n, fortran_int_t k,
- std::complex<float> alpha, const std::complex<float>* a,
- fortran_int_t lda, const std::complex<float>* x, fortran_int_t incx,
- std::complex<float> beta, std::complex<float>* y,
- fortran_int_t incy ) {
+inline void hbmv( Order, UpLo, const fortran_int_t n, const fortran_int_t k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const fortran_int_t lda, const std::complex<float>* x,
+ const fortran_int_t incx, const std::complex<float> beta,
+ std::complex<float>* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x,
             &incx, &beta, y, &incy );
@@ -139,11 +143,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, fortran_int_t n, fortran_int_t k,
- std::complex<double> alpha, const std::complex<double>* a,
- fortran_int_t lda, const std::complex<double>* x, fortran_int_t incx,
- std::complex<double> beta, std::complex<double>* y,
- fortran_int_t incy ) {
+inline void hbmv( Order, UpLo, const fortran_int_t n, const fortran_int_t k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const fortran_int_t lda, const std::complex<double>* x,
+ const fortran_int_t incx, const std::complex<double> beta,
+ std::complex<double>* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x,
             &incx, &beta, y, &incy );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,10 +63,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, int n, std::complex<float> alpha,
- const std::complex<float>* a, int lda, const std::complex<float>* x,
- int incx, std::complex<float> beta, std::complex<float>* y,
- int incy ) {
+inline void hemv( Order, UpLo, const int n, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda,
+ const std::complex<float>* x, const int incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const int incy ) {
     cblas_chemv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             &alpha, a, lda, x, incx, &beta, y, incy );
 }
@@ -77,10 +78,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, int n, std::complex<double> alpha,
- const std::complex<double>* a, int lda, const std::complex<double>* x,
- int incx, std::complex<double> beta, std::complex<double>* y,
- int incy ) {
+inline void hemv( Order, UpLo, const int n, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda,
+ const std::complex<double>* x, const int incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const int incy ) {
     cblas_zhemv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             &alpha, a, lda, x, incx, &beta, y, incy );
 }
@@ -92,10 +94,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, int n, std::complex<float> alpha,
- const std::complex<float>* a, int lda, const std::complex<float>* x,
- int incx, std::complex<float> beta, std::complex<float>* y,
- int incy ) {
+inline void hemv( Order, UpLo, const int n, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda,
+ const std::complex<float>* x, const int incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasChemv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta,
             y, incy );
@@ -107,10 +110,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, int n, std::complex<double> alpha,
- const std::complex<double>* a, int lda, const std::complex<double>* x,
- int incx, std::complex<double> beta, std::complex<double>* y,
- int incy ) {
+inline void hemv( Order, UpLo, const int n, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda,
+ const std::complex<double>* x, const int incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -122,11 +126,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, fortran_int_t n, std::complex<float> alpha,
- const std::complex<float>* a, fortran_int_t lda,
- const std::complex<float>* x, fortran_int_t incx,
- std::complex<float> beta, std::complex<float>* y,
- fortran_int_t incy ) {
+inline void hemv( Order, UpLo, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const fortran_int_t lda, const std::complex<float>* x,
+ const fortran_int_t incx, const std::complex<float> beta,
+ std::complex<float>* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHEMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx,
             &beta, y, &incy );
@@ -138,11 +142,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, fortran_int_t n, std::complex<double> alpha,
- const std::complex<double>* a, fortran_int_t lda,
- const std::complex<double>* x, fortran_int_t incx,
- std::complex<double> beta, std::complex<double>* y,
- fortran_int_t incy ) {
+inline void hemv( Order, UpLo, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const fortran_int_t lda, const std::complex<double>* x,
+ const fortran_int_t incx, const std::complex<double> beta,
+ std::complex<double>* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHEMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx,
             &beta, y, &incy );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,9 +63,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her( Order, UpLo, int n, float alpha,
- const std::complex<float>* x, int incx, std::complex<float>* a,
- int lda ) {
+inline void her( Order, UpLo, const int n, const float alpha,
+ const std::complex<float>* x, const int incx, std::complex<float>* a,
+ const int lda ) {
     cblas_cher( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, a, lda );
 }
@@ -76,9 +76,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her( Order, UpLo, int n, double alpha,
- const std::complex<double>* x, int incx, std::complex<double>* a,
- int lda ) {
+inline void her( Order, UpLo, const int n, const double alpha,
+ const std::complex<double>* x, const int incx,
+ std::complex<double>* a, const int lda ) {
     cblas_zher( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, a, lda );
 }
@@ -90,9 +90,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her( Order, UpLo, int n, float alpha,
- const std::complex<float>* x, int incx, std::complex<float>* a,
- int lda ) {
+inline void her( Order, UpLo, const int n, const float alpha,
+ const std::complex<float>* x, const int incx, std::complex<float>* a,
+ const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCher( blas_option< UpLo >::value, n, alpha, x, incx, a, lda );
 }
@@ -103,9 +103,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her( Order, UpLo, int n, double alpha,
- const std::complex<double>* x, int incx, std::complex<double>* a,
- int lda ) {
+inline void her( Order, UpLo, const int n, const double alpha,
+ const std::complex<double>* x, const int incx,
+ std::complex<double>* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -117,9 +117,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her( Order, UpLo, fortran_int_t n, float alpha,
- const std::complex<float>* x, fortran_int_t incx,
- std::complex<float>* a, fortran_int_t lda ) {
+inline void her( Order, UpLo, const fortran_int_t n, const float alpha,
+ const std::complex<float>* x, const fortran_int_t incx,
+ std::complex<float>* a, const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHER( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda );
 }
@@ -130,9 +130,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her( Order, UpLo, fortran_int_t n, double alpha,
- const std::complex<double>* x, fortran_int_t incx,
- std::complex<double>* a, fortran_int_t lda ) {
+inline void her( Order, UpLo, const fortran_int_t n, const double alpha,
+ const std::complex<double>* x, const fortran_int_t incx,
+ std::complex<double>* a, const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHER( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda );
 }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,9 +63,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, int n, std::complex<float> alpha,
- const std::complex<float>* x, int incx, const std::complex<float>* y,
- int incy, std::complex<float>* a, int lda ) {
+inline void her2( Order, UpLo, const int n, const std::complex<float> alpha,
+ const std::complex<float>* x, const int incx,
+ const std::complex<float>* y, const int incy, std::complex<float>* a,
+ const int lda ) {
     cblas_cher2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             &alpha, x, incx, y, incy, a, lda );
 }
@@ -76,10 +77,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, int n, std::complex<double> alpha,
- const std::complex<double>* x, int incx,
- const std::complex<double>* y, int incy, std::complex<double>* a,
- int lda ) {
+inline void her2( Order, UpLo, const int n, const std::complex<double> alpha,
+ const std::complex<double>* x, const int incx,
+ const std::complex<double>* y, const int incy,
+ std::complex<double>* a, const int lda ) {
     cblas_zher2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             &alpha, x, incx, y, incy, a, lda );
 }
@@ -91,9 +92,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, int n, std::complex<float> alpha,
- const std::complex<float>* x, int incx, const std::complex<float>* y,
- int incy, std::complex<float>* a, int lda ) {
+inline void her2( Order, UpLo, const int n, const std::complex<float> alpha,
+ const std::complex<float>* x, const int incx,
+ const std::complex<float>* y, const int incy, std::complex<float>* a,
+ const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCher2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a,
             lda );
@@ -105,10 +107,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, int n, std::complex<double> alpha,
- const std::complex<double>* x, int incx,
- const std::complex<double>* y, int incy, std::complex<double>* a,
- int lda ) {
+inline void her2( Order, UpLo, const int n, const std::complex<double> alpha,
+ const std::complex<double>* x, const int incx,
+ const std::complex<double>* y, const int incy,
+ std::complex<double>* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -120,10 +122,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, fortran_int_t n, std::complex<float> alpha,
- const std::complex<float>* x, fortran_int_t incx,
- const std::complex<float>* y, fortran_int_t incy,
- std::complex<float>* a, fortran_int_t lda ) {
+inline void her2( Order, UpLo, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* x,
+ const fortran_int_t incx, const std::complex<float>* y,
+ const fortran_int_t incy, std::complex<float>* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHER2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
             a, &lda );
@@ -135,10 +138,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, fortran_int_t n, std::complex<double> alpha,
- const std::complex<double>* x, fortran_int_t incx,
- const std::complex<double>* y, fortran_int_t incy,
- std::complex<double>* a, fortran_int_t lda ) {
+inline void her2( Order, UpLo, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* x,
+ const fortran_int_t incx, const std::complex<double>* y,
+ const fortran_int_t incy, std::complex<double>* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHER2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
             a, &lda );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,9 +63,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, int n, std::complex<float> alpha,
- const std::complex<float>* ap, const std::complex<float>* x, int incx,
- std::complex<float> beta, std::complex<float>* y, int incy ) {
+inline void hpmv( Order, UpLo, const int n, const std::complex<float> alpha,
+ const std::complex<float>* ap, const std::complex<float>* x,
+ const int incx, const std::complex<float> beta,
+ std::complex<float>* y, const int incy ) {
     cblas_chpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             &alpha, ap, x, incx, &beta, y, incy );
 }
@@ -76,10 +77,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, int n, std::complex<double> alpha,
+inline void hpmv( Order, UpLo, const int n, const std::complex<double> alpha,
         const std::complex<double>* ap, const std::complex<double>* x,
- int incx, std::complex<double> beta, std::complex<double>* y,
- int incy ) {
+ const int incx, const std::complex<double> beta,
+ std::complex<double>* y, const int incy ) {
     cblas_zhpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             &alpha, ap, x, incx, &beta, y, incy );
 }
@@ -91,9 +92,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, int n, std::complex<float> alpha,
- const std::complex<float>* ap, const std::complex<float>* x, int incx,
- std::complex<float> beta, std::complex<float>* y, int incy ) {
+inline void hpmv( Order, UpLo, const int n, const std::complex<float> alpha,
+ const std::complex<float>* ap, const std::complex<float>* x,
+ const int incx, const std::complex<float> beta,
+ std::complex<float>* y, const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasChpmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y,
             incy );
@@ -105,10 +107,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, int n, std::complex<double> alpha,
+inline void hpmv( Order, UpLo, const int n, const std::complex<double> alpha,
         const std::complex<double>* ap, const std::complex<double>* x,
- int incx, std::complex<double> beta, std::complex<double>* y,
- int incy ) {
+ const int incx, const std::complex<double> beta,
+ std::complex<double>* y, const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -120,10 +122,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, fortran_int_t n, std::complex<float> alpha,
- const std::complex<float>* ap, const std::complex<float>* x,
- fortran_int_t incx, std::complex<float> beta, std::complex<float>* y,
- fortran_int_t incy ) {
+inline void hpmv( Order, UpLo, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* ap,
+ const std::complex<float>* x, const fortran_int_t incx,
+ const std::complex<float> beta, std::complex<float>* y,
+ const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta,
             y, &incy );
@@ -135,10 +138,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, fortran_int_t n, std::complex<double> alpha,
- const std::complex<double>* ap, const std::complex<double>* x,
- fortran_int_t incx, std::complex<double> beta,
- std::complex<double>* y, fortran_int_t incy ) {
+inline void hpmv( Order, UpLo, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* ap,
+ const std::complex<double>* x, const fortran_int_t incx,
+ const std::complex<double> beta, std::complex<double>* y,
+ const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta,
             y, &incy );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,8 +63,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, int n, float alpha,
- const std::complex<float>* x, int incx, std::complex<float>* ap ) {
+inline void hpr( Order, UpLo, const int n, const float alpha,
+ const std::complex<float>* x, const int incx,
+ std::complex<float>* ap ) {
     cblas_chpr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, ap );
 }
@@ -75,8 +76,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, int n, double alpha,
- const std::complex<double>* x, int incx, std::complex<double>* ap ) {
+inline void hpr( Order, UpLo, const int n, const double alpha,
+ const std::complex<double>* x, const int incx,
+ std::complex<double>* ap ) {
     cblas_zhpr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, ap );
 }
@@ -88,8 +90,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, int n, float alpha,
- const std::complex<float>* x, int incx, std::complex<float>* ap ) {
+inline void hpr( Order, UpLo, const int n, const float alpha,
+ const std::complex<float>* x, const int incx,
+ std::complex<float>* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasChpr( blas_option< UpLo >::value, n, alpha, x, incx, ap );
 }
@@ -100,8 +103,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, int n, double alpha,
- const std::complex<double>* x, int incx, std::complex<double>* ap ) {
+inline void hpr( Order, UpLo, const int n, const double alpha,
+ const std::complex<double>* x, const int incx,
+ std::complex<double>* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -113,8 +117,8 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, fortran_int_t n, float alpha,
- const std::complex<float>* x, fortran_int_t incx,
+inline void hpr( Order, UpLo, const fortran_int_t n, const float alpha,
+ const std::complex<float>* x, const fortran_int_t incx,
         std::complex<float>* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap );
@@ -126,8 +130,8 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, fortran_int_t n, double alpha,
- const std::complex<double>* x, fortran_int_t incx,
+inline void hpr( Order, UpLo, const fortran_int_t n, const double alpha,
+ const std::complex<double>* x, const fortran_int_t incx,
         std::complex<double>* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,9 +63,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, int n, std::complex<float> alpha,
- const std::complex<float>* x, int incx, const std::complex<float>* y,
- int incy, std::complex<float>* ap ) {
+inline void hpr2( Order, UpLo, const int n, const std::complex<float> alpha,
+ const std::complex<float>* x, const int incx,
+ const std::complex<float>* y, const int incy,
+ std::complex<float>* ap ) {
     cblas_chpr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             &alpha, x, incx, y, incy, ap );
 }
@@ -76,9 +77,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, int n, std::complex<double> alpha,
- const std::complex<double>* x, int incx,
- const std::complex<double>* y, int incy, std::complex<double>* ap ) {
+inline void hpr2( Order, UpLo, const int n, const std::complex<double> alpha,
+ const std::complex<double>* x, const int incx,
+ const std::complex<double>* y, const int incy,
+ std::complex<double>* ap ) {
     cblas_zhpr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             &alpha, x, incx, y, incy, ap );
 }
@@ -90,9 +92,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, int n, std::complex<float> alpha,
- const std::complex<float>* x, int incx, const std::complex<float>* y,
- int incy, std::complex<float>* ap ) {
+inline void hpr2( Order, UpLo, const int n, const std::complex<float> alpha,
+ const std::complex<float>* x, const int incx,
+ const std::complex<float>* y, const int incy,
+ std::complex<float>* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasChpr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap );
 }
@@ -103,9 +106,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, int n, std::complex<double> alpha,
- const std::complex<double>* x, int incx,
- const std::complex<double>* y, int incy, std::complex<double>* ap ) {
+inline void hpr2( Order, UpLo, const int n, const std::complex<double> alpha,
+ const std::complex<double>* x, const int incx,
+ const std::complex<double>* y, const int incy,
+ std::complex<double>* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -117,10 +121,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, fortran_int_t n, std::complex<float> alpha,
- const std::complex<float>* x, fortran_int_t incx,
- const std::complex<float>* y, fortran_int_t incy,
- std::complex<float>* ap ) {
+inline void hpr2( Order, UpLo, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* x,
+ const fortran_int_t incx, const std::complex<float>* y,
+ const fortran_int_t incy, std::complex<float>* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
             ap );
@@ -132,10 +136,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, fortran_int_t n, std::complex<double> alpha,
- const std::complex<double>* x, fortran_int_t incx,
- const std::complex<double>* y, fortran_int_t incy,
- std::complex<double>* ap ) {
+inline void hpr2( Order, UpLo, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* x,
+ const fortran_int_t incx, const std::complex<double>* y,
+ const fortran_int_t incy, std::complex<double>* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
             ap );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -64,8 +64,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, int n, int k, float alpha, const float* a,
- int lda, const float* x, int incx, float beta, float* y, int incy ) {
+inline void sbmv( Order, UpLo, const int n, const int k, const float alpha,
+ const float* a, const int lda, const float* x, const int incx,
+ const float beta, float* y, const int incy ) {
     cblas_ssbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             k, alpha, a, lda, x, incx, beta, y, incy );
 }
@@ -76,9 +77,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, int n, int k, double alpha, const double* a,
- int lda, const double* x, int incx, double beta, double* y,
- int incy ) {
+inline void sbmv( Order, UpLo, const int n, const int k, const double alpha,
+ const double* a, const int lda, const double* x, const int incx,
+ const double beta, double* y, const int incy ) {
     cblas_dsbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             k, alpha, a, lda, x, incx, beta, y, incy );
 }
@@ -90,8 +91,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, int n, int k, float alpha, const float* a,
- int lda, const float* x, int incx, float beta, float* y, int incy ) {
+inline void sbmv( Order, UpLo, const int n, const int k, const float alpha,
+ const float* a, const int lda, const float* x, const int incx,
+ const float beta, float* y, const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSsbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx,
             beta, y, incy );
@@ -103,9 +105,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, int n, int k, double alpha, const double* a,
- int lda, const double* x, int incx, double beta, double* y,
- int incy ) {
+inline void sbmv( Order, UpLo, const int n, const int k, const double alpha,
+ const double* a, const int lda, const double* x, const int incx,
+ const double beta, double* y, const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -117,9 +119,10 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, fortran_int_t n, fortran_int_t k, float alpha,
- const float* a, fortran_int_t lda, const float* x, fortran_int_t incx,
- float beta, float* y, fortran_int_t incy ) {
+inline void sbmv( Order, UpLo, const fortran_int_t n, const fortran_int_t k,
+ const float alpha, const float* a, const fortran_int_t lda,
+ const float* x, const fortran_int_t incx, const float beta, float* y,
+ const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x,
             &incx, &beta, y, &incy );
@@ -131,9 +134,10 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, fortran_int_t n, fortran_int_t k, double alpha,
- const double* a, fortran_int_t lda, const double* x,
- fortran_int_t incx, double beta, double* y, fortran_int_t incy ) {
+inline void sbmv( Order, UpLo, const fortran_int_t n, const fortran_int_t k,
+ const double alpha, const double* a, const fortran_int_t lda,
+ const double* x, const fortran_int_t incx, const double beta,
+ double* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x,
             &incx, &beta, y, &incy );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,8 +63,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, int n, float alpha, const float* ap,
- const float* x, int incx, float beta, float* y, int incy ) {
+inline void spmv( Order, UpLo, const int n, const float alpha,
+ const float* ap, const float* x, const int incx, const float beta,
+ float* y, const int incy ) {
     cblas_sspmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, ap, x, incx, beta, y, incy );
 }
@@ -75,8 +76,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, int n, double alpha, const double* ap,
- const double* x, int incx, double beta, double* y, int incy ) {
+inline void spmv( Order, UpLo, const int n, const double alpha,
+ const double* ap, const double* x, const int incx, const double beta,
+ double* y, const int incy ) {
     cblas_dspmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, ap, x, incx, beta, y, incy );
 }
@@ -88,8 +90,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, int n, float alpha, const float* ap,
- const float* x, int incx, float beta, float* y, int incy ) {
+inline void spmv( Order, UpLo, const int n, const float alpha,
+ const float* ap, const float* x, const int incx, const float beta,
+ float* y, const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSspmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y,
             incy );
@@ -101,8 +104,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, int n, double alpha, const double* ap,
- const double* x, int incx, double beta, double* y, int incy ) {
+inline void spmv( Order, UpLo, const int n, const double alpha,
+ const double* ap, const double* x, const int incx, const double beta,
+ double* y, const int incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -114,9 +118,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, fortran_int_t n, float alpha, const float* ap,
- const float* x, fortran_int_t incx, float beta, float* y,
- fortran_int_t incy ) {
+inline void spmv( Order, UpLo, const fortran_int_t n, const float alpha,
+ const float* ap, const float* x, const fortran_int_t incx,
+ const float beta, float* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta,
             y, &incy );
@@ -128,9 +132,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, fortran_int_t n, double alpha,
- const double* ap, const double* x, fortran_int_t incx, double beta,
- double* y, fortran_int_t incy ) {
+inline void spmv( Order, UpLo, const fortran_int_t n, const double alpha,
+ const double* ap, const double* x, const fortran_int_t incx,
+ const double beta, double* y, const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta,
             y, &incy );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,8 +63,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, int n, float alpha, const float* x, int incx,
- float* ap ) {
+inline void spr( Order, UpLo, const int n, const float alpha, const float* x,
+ const int incx, float* ap ) {
     cblas_sspr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, ap );
 }
@@ -75,8 +75,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, int n, double alpha, const double* x, int incx,
- double* ap ) {
+inline void spr( Order, UpLo, const int n, const double alpha,
+ const double* x, const int incx, double* ap ) {
     cblas_dspr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, ap );
 }
@@ -88,8 +88,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, int n, float alpha, const float* x, int incx,
- float* ap ) {
+inline void spr( Order, UpLo, const int n, const float alpha, const float* x,
+ const int incx, float* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSspr( blas_option< UpLo >::value, n, alpha, x, incx, ap );
 }
@@ -100,8 +100,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, int n, double alpha, const double* x, int incx,
- double* ap ) {
+inline void spr( Order, UpLo, const int n, const double alpha,
+ const double* x, const int incx, double* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -113,8 +113,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, fortran_int_t n, float alpha, const float* x,
- fortran_int_t incx, float* ap ) {
+inline void spr( Order, UpLo, const fortran_int_t n, const float alpha,
+ const float* x, const fortran_int_t incx, float* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap );
 }
@@ -125,8 +125,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, fortran_int_t n, double alpha, const double* x,
- fortran_int_t incx, double* ap ) {
+inline void spr( Order, UpLo, const fortran_int_t n, const double alpha,
+ const double* x, const fortran_int_t incx, double* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap );
 }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,8 +63,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, int n, float alpha, const float* x, int incx,
- const float* y, int incy, float* ap ) {
+inline void spr2( Order, UpLo, const int n, const float alpha, const float* x,
+ const int incx, const float* y, const int incy, float* ap ) {
     cblas_sspr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, y, incy, ap );
 }
@@ -75,8 +75,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, int n, double alpha, const double* x, int incx,
- const double* y, int incy, double* ap ) {
+inline void spr2( Order, UpLo, const int n, const double alpha,
+ const double* x, const int incx, const double* y, const int incy,
+ double* ap ) {
     cblas_dspr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, y, incy, ap );
 }
@@ -88,8 +89,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, int n, float alpha, const float* x, int incx,
- const float* y, int incy, float* ap ) {
+inline void spr2( Order, UpLo, const int n, const float alpha, const float* x,
+ const int incx, const float* y, const int incy, float* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSspr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap );
 }
@@ -100,8 +101,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, int n, double alpha, const double* x, int incx,
- const double* y, int incy, double* ap ) {
+inline void spr2( Order, UpLo, const int n, const double alpha,
+ const double* x, const int incx, const double* y, const int incy,
+ double* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -113,8 +115,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, fortran_int_t n, float alpha, const float* x,
- fortran_int_t incx, const float* y, fortran_int_t incy, float* ap ) {
+inline void spr2( Order, UpLo, const fortran_int_t n, const float alpha,
+ const float* x, const fortran_int_t incx, const float* y,
+ const fortran_int_t incy, float* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
             ap );
@@ -126,8 +129,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, fortran_int_t n, double alpha, const double* x,
- fortran_int_t incx, const double* y, fortran_int_t incy, double* ap ) {
+inline void spr2( Order, UpLo, const fortran_int_t n, const double alpha,
+ const double* x, const fortran_int_t incx, const double* y,
+ const fortran_int_t incy, double* ap ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
             ap );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,8 +63,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, int n, float alpha, const float* a, int lda,
- const float* x, int incx, float beta, float* y, int incy ) {
+inline void symv( Order, UpLo, 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 ) {
     cblas_ssymv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, a, lda, x, incx, beta, y, incy );
 }
@@ -75,8 +76,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, int n, double alpha, const double* a, int lda,
- const double* x, int incx, double beta, double* y, int incy ) {
+inline void symv( Order, UpLo, 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 ) {
     cblas_dsymv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, a, lda, x, incx, beta, y, incy );
 }
@@ -88,8 +90,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, int n, float alpha, const float* a, int lda,
- const float* x, int incx, float beta, float* y, int incy ) {
+inline void symv( Order, UpLo, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSsymv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta,
             y, incy );
@@ -101,8 +104,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, int n, double alpha, const double* a, int lda,
- const double* x, int incx, double beta, double* y, int incy ) {
+inline void symv( Order, UpLo, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -114,9 +118,10 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, fortran_int_t n, float alpha, const float* a,
- fortran_int_t lda, const float* x, fortran_int_t incx, float beta,
- float* y, fortran_int_t incy ) {
+inline void symv( Order, UpLo, const fortran_int_t n, const float alpha,
+ const float* a, const fortran_int_t lda, const float* x,
+ const fortran_int_t incx, const float beta, float* y,
+ const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSYMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx,
             &beta, y, &incy );
@@ -128,9 +133,10 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, fortran_int_t n, double alpha, const double* a,
- fortran_int_t lda, const double* x, fortran_int_t incx, double beta,
- double* y, fortran_int_t incy ) {
+inline void symv( Order, UpLo, const fortran_int_t n, const double alpha,
+ const double* a, const fortran_int_t lda, const double* x,
+ const fortran_int_t incx, const double beta, double* y,
+ const fortran_int_t incy ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSYMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx,
             &beta, y, &incy );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,8 +63,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, int n, float alpha, const float* x, int incx,
- float* a, int lda ) {
+inline void syr( Order, UpLo, const int n, const float alpha, const float* x,
+ const int incx, float* a, const int lda ) {
     cblas_ssyr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, a, lda );
 }
@@ -75,8 +75,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, int n, double alpha, const double* x, int incx,
- double* a, int lda ) {
+inline void syr( Order, UpLo, const int n, const double alpha,
+ const double* x, const int incx, double* a, const int lda ) {
     cblas_dsyr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, a, lda );
 }
@@ -88,8 +88,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, int n, float alpha, const float* x, int incx,
- float* a, int lda ) {
+inline void syr( Order, UpLo, const int n, const float alpha, const float* x,
+ const int incx, float* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSsyr( blas_option< UpLo >::value, n, alpha, x, incx, a, lda );
 }
@@ -100,8 +100,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, int n, double alpha, const double* x, int incx,
- double* a, int lda ) {
+inline void syr( Order, UpLo, const int n, const double alpha,
+ const double* x, const int incx, double* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDsyr( blas_option< UpLo >::value, n, alpha, x, incx, a, lda );
 }
@@ -113,8 +113,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, fortran_int_t n, float alpha, const float* x,
- fortran_int_t incx, float* a, fortran_int_t lda ) {
+inline void syr( Order, UpLo, const fortran_int_t n, const float alpha,
+ const float* x, const fortran_int_t incx, float* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSYR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda );
 }
@@ -125,8 +126,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, fortran_int_t n, double alpha, const double* x,
- fortran_int_t incx, double* a, fortran_int_t lda ) {
+inline void syr( Order, UpLo, const fortran_int_t n, const double alpha,
+ const double* x, const fortran_int_t incx, double* a,
+ const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSYR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda );
 }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,8 +63,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, int n, float alpha, const float* x, int incx,
- const float* y, int incy, float* a, int lda ) {
+inline void syr2( Order, UpLo, const int n, const float alpha, const float* x,
+ const int incx, const float* y, const int incy, float* a,
+ const int lda ) {
     cblas_ssyr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, y, incy, a, lda );
 }
@@ -75,8 +76,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, int n, double alpha, const double* x, int incx,
- const double* y, int incy, double* a, int lda ) {
+inline void syr2( Order, UpLo, const int n, const double alpha,
+ const double* x, const int incx, const double* y, const int incy,
+ double* a, const int lda ) {
     cblas_dsyr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
             alpha, x, incx, y, incy, a, lda );
 }
@@ -88,8 +90,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, int n, float alpha, const float* x, int incx,
- const float* y, int incy, float* a, int lda ) {
+inline void syr2( Order, UpLo, const int n, const float alpha, const float* x,
+ const int incx, const float* y, const int incy, float* a,
+ const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSsyr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a,
             lda );
@@ -101,8 +104,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, int n, double alpha, const double* x, int incx,
- const double* y, int incy, double* a, int lda ) {
+inline void syr2( Order, UpLo, const int n, const double alpha,
+ const double* x, const int incx, const double* y, const int incy,
+ double* a, const int lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -114,9 +118,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, fortran_int_t n, float alpha, const float* x,
- fortran_int_t incx, const float* y, fortran_int_t incy, float* a,
- fortran_int_t lda ) {
+inline void syr2( Order, UpLo, const fortran_int_t n, const float alpha,
+ const float* x, const fortran_int_t incx, const float* y,
+ const fortran_int_t incy, float* a, const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSYR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
             a, &lda );
@@ -128,9 +132,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, fortran_int_t n, double alpha, const double* x,
- fortran_int_t incx, const double* y, fortran_int_t incy, double* a,
- fortran_int_t lda ) {
+inline void syr2( Order, UpLo, const fortran_int_t n, const double alpha,
+ const double* x, const fortran_int_t incx, const double* y,
+ const fortran_int_t incy, double* a, const fortran_int_t lda ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSYR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
             a, &lda );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -66,8 +66,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, int n, int k, const float* a,
- int lda, float* x, int incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const float* a, const int lda, float* x, const int incx ) {
     cblas_stbmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
             a, lda, x, incx );
@@ -79,8 +79,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, int n, int k, const double* a,
- int lda, double* x, int incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const double* a, const int lda, double* x, const int incx ) {
     cblas_dtbmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
             a, lda, x, incx );
@@ -92,9 +92,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, int n, int k,
- const std::complex<float>* a, int lda, std::complex<float>* x,
- int incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const std::complex<float>* a, const int lda, std::complex<float>* x,
+ const int incx ) {
     cblas_ctbmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
             a, lda, x, incx );
@@ -106,9 +106,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, int n, int k,
- const std::complex<double>* a, int lda, std::complex<double>* x,
- int incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const std::complex<double>* a, const int lda, std::complex<double>* x,
+ const int incx ) {
     cblas_ztbmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
             a, lda, x, incx );
@@ -121,8 +121,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, int n, int k, const float* a,
- int lda, float* x, int incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const float* a, const int lda, float* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasStbmv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, k, a, lda, x, incx );
@@ -134,8 +134,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, int n, int k, const double* a,
- int lda, double* x, int incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const double* a, const int lda, double* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -146,9 +146,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, int n, int k,
- const std::complex<float>* a, int lda, std::complex<float>* x,
- int incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const std::complex<float>* a, const int lda, std::complex<float>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCtbmv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, k, a, lda, x, incx );
@@ -160,9 +160,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, int n, int k,
- const std::complex<double>* a, int lda, std::complex<double>* x,
- int incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const std::complex<double>* a, const int lda, std::complex<double>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -174,8 +174,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
- const float* a, fortran_int_t lda, float* x, fortran_int_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t k, const float* a, const fortran_int_t lda,
+ float* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_STBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -187,8 +188,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
- const double* a, fortran_int_t lda, double* x, fortran_int_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t k, const double* a, const fortran_int_t lda,
+ double* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -200,9 +202,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
- const std::complex<float>* a, fortran_int_t lda,
- std::complex<float>* x, fortran_int_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<float>* a,
+ const fortran_int_t lda, std::complex<float>* x,
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -214,9 +217,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
- const std::complex<double>* a, fortran_int_t lda,
- std::complex<double>* x, fortran_int_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<double>* a,
+ const fortran_int_t lda, std::complex<double>* x,
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -66,8 +66,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, int n, int k, const float* a,
- int lda, float* x, int incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const float* a, const int lda, float* x, const int incx ) {
     cblas_stbsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
             a, lda, x, incx );
@@ -79,8 +79,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, int n, int k, const double* a,
- int lda, double* x, int incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const double* a, const int lda, double* x, const int incx ) {
     cblas_dtbsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
             a, lda, x, incx );
@@ -92,9 +92,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, int n, int k,
- const std::complex<float>* a, int lda, std::complex<float>* x,
- int incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const std::complex<float>* a, const int lda, std::complex<float>* x,
+ const int incx ) {
     cblas_ctbsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
             a, lda, x, incx );
@@ -106,9 +106,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, int n, int k,
- const std::complex<double>* a, int lda, std::complex<double>* x,
- int incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const std::complex<double>* a, const int lda, std::complex<double>* x,
+ const int incx ) {
     cblas_ztbsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
             a, lda, x, incx );
@@ -121,8 +121,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, int n, int k, const float* a,
- int lda, float* x, int incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const float* a, const int lda, float* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasStbsv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, k, a, lda, x, incx );
@@ -134,8 +134,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, int n, int k, const double* a,
- int lda, double* x, int incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const double* a, const int lda, double* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -146,9 +146,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, int n, int k,
- const std::complex<float>* a, int lda, std::complex<float>* x,
- int incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const std::complex<float>* a, const int lda, std::complex<float>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCtbsv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, k, a, lda, x, incx );
@@ -160,9 +160,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, int n, int k,
- const std::complex<double>* a, int lda, std::complex<double>* x,
- int incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const int n, const int k,
+ const std::complex<double>* a, const int lda, std::complex<double>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -174,8 +174,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
- const float* a, fortran_int_t lda, float* x, fortran_int_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t k, const float* a, const fortran_int_t lda,
+ float* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_STBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -187,8 +188,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
- const double* a, fortran_int_t lda, double* x, fortran_int_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t k, const double* a, const fortran_int_t lda,
+ double* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -200,9 +202,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
- const std::complex<float>* a, fortran_int_t lda,
- std::complex<float>* x, fortran_int_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<float>* a,
+ const fortran_int_t lda, std::complex<float>* x,
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -214,9 +217,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
- const std::complex<double>* a, fortran_int_t lda,
- std::complex<double>* x, fortran_int_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<double>* a,
+ const fortran_int_t lda, std::complex<double>* x,
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -65,8 +65,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, int n, const float* ap, float* x,
- int incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const int n, const float* ap,
+ float* x, const int incx ) {
     cblas_stpmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
             x, incx );
@@ -78,8 +78,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, int n, const double* ap,
- double* x, int incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const int n, const double* ap,
+ double* x, const int incx ) {
     cblas_dtpmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
             x, incx );
@@ -91,8 +91,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, int n,
- const std::complex<float>* ap, std::complex<float>* x, int incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<float>* ap, std::complex<float>* x,
+ const int incx ) {
     cblas_ctpmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
             x, incx );
@@ -104,8 +105,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, int n,
- const std::complex<double>* ap, std::complex<double>* x, int incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<double>* ap, std::complex<double>* x,
+ const int incx ) {
     cblas_ztpmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
             x, incx );
@@ -118,8 +120,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, int n, const float* ap, float* x,
- int incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const int n, const float* ap,
+ float* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasStpmv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, ap, x, incx );
@@ -131,8 +133,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, int n, const double* ap,
- double* x, int incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const int n, const double* ap,
+ double* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -143,8 +145,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, int n,
- const std::complex<float>* ap, std::complex<float>* x, int incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<float>* ap, std::complex<float>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCtpmv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, ap, x, incx );
@@ -156,8 +159,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, int n,
- const std::complex<double>* ap, std::complex<double>* x, int incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<double>* ap, std::complex<double>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -169,8 +173,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, fortran_int_t n, const float* ap,
- float* x, fortran_int_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const float* ap, float* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_STPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, ap, x, &incx );
@@ -182,8 +186,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, fortran_int_t n, const double* ap,
- double* x, fortran_int_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const double* ap, double* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, ap, x, &incx );
@@ -195,9 +199,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, fortran_int_t n,
+inline void tpmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
         const std::complex<float>* ap, std::complex<float>* x,
- fortran_int_t incx ) {
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, ap, x, &incx );
@@ -209,9 +213,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, fortran_int_t n,
+inline void tpmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
         const std::complex<double>* ap, std::complex<double>* x,
- fortran_int_t incx ) {
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, ap, x, &incx );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -65,8 +65,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, int n, const float* ap, float* x,
- int incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const int n, const float* ap,
+ float* x, const int incx ) {
     cblas_stpsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
             x, incx );
@@ -78,8 +78,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, int n, const double* ap,
- double* x, int incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const int n, const double* ap,
+ double* x, const int incx ) {
     cblas_dtpsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
             x, incx );
@@ -91,8 +91,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, int n,
- const std::complex<float>* ap, std::complex<float>* x, int incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<float>* ap, std::complex<float>* x,
+ const int incx ) {
     cblas_ctpsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
             x, incx );
@@ -104,8 +105,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, int n,
- const std::complex<double>* ap, std::complex<double>* x, int incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<double>* ap, std::complex<double>* x,
+ const int incx ) {
     cblas_ztpsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
             x, incx );
@@ -118,8 +120,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, int n, const float* ap, float* x,
- int incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const int n, const float* ap,
+ float* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasStpsv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, ap, x, incx );
@@ -131,8 +133,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, int n, const double* ap,
- double* x, int incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const int n, const double* ap,
+ double* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -143,8 +145,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, int n,
- const std::complex<float>* ap, std::complex<float>* x, int incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<float>* ap, std::complex<float>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCtpsv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, ap, x, incx );
@@ -156,8 +159,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, int n,
- const std::complex<double>* ap, std::complex<double>* x, int incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<double>* ap, std::complex<double>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -169,8 +173,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, fortran_int_t n, const float* ap,
- float* x, fortran_int_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const float* ap, float* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_STPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, ap, x, &incx );
@@ -182,8 +186,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, fortran_int_t n, const double* ap,
- double* x, fortran_int_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const double* ap, double* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, ap, x, &incx );
@@ -195,9 +199,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, fortran_int_t n,
+inline void tpsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
         const std::complex<float>* ap, std::complex<float>* x,
- fortran_int_t incx ) {
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, ap, x, &incx );
@@ -209,9 +213,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, fortran_int_t n,
+inline void tpsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
         const std::complex<double>* ap, std::complex<double>* x,
- fortran_int_t incx ) {
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, ap, x, &incx );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -65,8 +65,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, int n, const float* a, int lda,
- float* x, int incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const int n, const float* a,
+ const int lda, float* x, const int incx ) {
     cblas_strmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
             lda, x, incx );
@@ -78,8 +78,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, int n, const double* a, int lda,
- double* x, int incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const int n, const double* a,
+ const int lda, double* x, const int incx ) {
     cblas_dtrmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
             lda, x, incx );
@@ -91,9 +91,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, int n,
- const std::complex<float>* a, int lda, std::complex<float>* x,
- int incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<float>* a, const int lda, std::complex<float>* x,
+ const int incx ) {
     cblas_ctrmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
             lda, x, incx );
@@ -105,9 +105,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, int n,
- const std::complex<double>* a, int lda, std::complex<double>* x,
- int incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<double>* a, const int lda, std::complex<double>* x,
+ const int incx ) {
     cblas_ztrmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
             lda, x, incx );
@@ -120,8 +120,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, int n, const float* a, int lda,
- float* x, int incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const int n, const float* a,
+ const int lda, float* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasStrmv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, a, lda, x, incx );
@@ -133,8 +133,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, int n, const double* a, int lda,
- double* x, int incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const int n, const double* a,
+ const int lda, double* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -145,9 +145,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, int n,
- const std::complex<float>* a, int lda, std::complex<float>* x,
- int incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<float>* a, const int lda, std::complex<float>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -158,9 +158,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, int n,
- const std::complex<double>* a, int lda, std::complex<double>* x,
- int incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<double>* a, const int lda, std::complex<double>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -172,8 +172,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, fortran_int_t n, const float* a,
- fortran_int_t lda, float* x, fortran_int_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const float* a, const fortran_int_t lda, float* x,
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_STRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -185,8 +186,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, fortran_int_t n, const double* a,
- fortran_int_t lda, double* x, fortran_int_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const double* a, const fortran_int_t lda, double* x,
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -198,9 +200,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, fortran_int_t n,
- const std::complex<float>* a, fortran_int_t lda,
- std::complex<float>* x, fortran_int_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const std::complex<float>* a, const fortran_int_t lda,
+ std::complex<float>* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -212,9 +214,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, fortran_int_t n,
- const std::complex<double>* a, fortran_int_t lda,
- std::complex<double>* x, fortran_int_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const std::complex<double>* a, const fortran_int_t lda,
+ std::complex<double>* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, a, &lda, x, &incx );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -65,8 +65,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, int n, const float* a, int lda,
- float* x, int incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const int n, const float* a,
+ const int lda, float* x, const int incx ) {
     cblas_strsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
             lda, x, incx );
@@ -78,8 +78,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, int n, const double* a, int lda,
- double* x, int incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const int n, const double* a,
+ const int lda, double* x, const int incx ) {
     cblas_dtrsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
             lda, x, incx );
@@ -91,9 +91,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, int n,
- const std::complex<float>* a, int lda, std::complex<float>* x,
- int incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<float>* a, const int lda, std::complex<float>* x,
+ const int incx ) {
     cblas_ctrsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
             lda, x, incx );
@@ -105,9 +105,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, int n,
- const std::complex<double>* a, int lda, std::complex<double>* x,
- int incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<double>* a, const int lda, std::complex<double>* x,
+ const int incx ) {
     cblas_ztrsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
             lda, x, incx );
@@ -120,8 +120,8 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, int n, const float* a, int lda,
- float* x, int incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const int n, const float* a,
+ const int lda, float* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasStrsv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, a, lda, x, incx );
@@ -133,8 +133,8 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, int n, const double* a, int lda,
- double* x, int incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const int n, const double* a,
+ const int lda, double* x, const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDtrsv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, a, lda, x, incx );
@@ -146,9 +146,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, int n,
- const std::complex<float>* a, int lda, std::complex<float>* x,
- int incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<float>* a, const int lda, std::complex<float>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCtrsv( blas_option< UpLo >::value, blas_option< Trans >::value,
             blas_option< Diag >::value, n, a, lda, x, incx );
@@ -160,9 +160,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, int n,
- const std::complex<double>* a, int lda, std::complex<double>* x,
- int incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const int n,
+ const std::complex<double>* a, const int lda, std::complex<double>* x,
+ const int incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -174,8 +174,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, fortran_int_t n, const float* a,
- fortran_int_t lda, float* x, fortran_int_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const float* a, const fortran_int_t lda, float* x,
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_STRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -187,8 +188,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, fortran_int_t n, const double* a,
- fortran_int_t lda, double* x, fortran_int_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const double* a, const fortran_int_t lda, double* x,
+ const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -200,9 +202,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, fortran_int_t n,
- const std::complex<float>* a, fortran_int_t lda,
- std::complex<float>* x, fortran_int_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const std::complex<float>* a, const fortran_int_t lda,
+ std::complex<float>* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -214,9 +216,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, fortran_int_t n,
- const std::complex<double>* a, fortran_int_t lda,
- std::complex<double>* x, fortran_int_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, const fortran_int_t n,
+ const std::complex<double>* a, const fortran_int_t lda,
+ std::complex<double>* x, const fortran_int_t incx ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &blas_option< Diag >::value, &n, a, &lda, x, &incx );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,9 +63,10 @@
 // * float value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, int m, int n, int k, float alpha,
- const float* a, int lda, const float* b, int ldb, float beta,
- float* c, int ldc ) {
+inline void gemm( Order, TransA, 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 ) {
     cblas_sgemm( cblas_option< Order >::value, cblas_option< TransA >::value,
             cblas_option< TransB >::value, m, n, k, alpha, a, lda, b, ldb,
             beta, c, ldc );
@@ -77,9 +78,10 @@
 // * double value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, int m, int n, int k, double alpha,
- const double* a, int lda, const double* b, int ldb, double beta,
- double* c, int ldc ) {
+inline void gemm( Order, TransA, 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 ) {
     cblas_dgemm( cblas_option< Order >::value, cblas_option< TransA >::value,
             cblas_option< TransB >::value, m, n, k, alpha, a, lda, b, ldb,
             beta, c, ldc );
@@ -91,10 +93,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, int m, int n, int k,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void gemm( Order, TransA, TransB, const int m, const int n,
+ const int k, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda,
+ const std::complex<float>* b, const int ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     cblas_cgemm( cblas_option< Order >::value, cblas_option< TransA >::value,
             cblas_option< TransB >::value, m, n, k, &alpha, a, lda, b, ldb,
             &beta, c, ldc );
@@ -106,10 +110,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, int m, int n, int k,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, std::complex<double> beta,
- std::complex<double>* c, int ldc ) {
+inline void gemm( Order, TransA, TransB, const int m, const int n,
+ const int k, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda,
+ const std::complex<double>* b, const int ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const int ldc ) {
     cblas_zgemm( cblas_option< Order >::value, cblas_option< TransA >::value,
             cblas_option< TransB >::value, m, n, k, &alpha, a, lda, b, ldb,
             &beta, c, ldc );
@@ -122,9 +128,10 @@
 // * float value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, int m, int n, int k, float alpha,
- const float* a, int lda, const float* b, int ldb, float beta,
- float* c, int ldc ) {
+inline void gemm( Order, TransA, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSgemm( blas_option< TransA >::value, blas_option< TransB >::value,
             m, n, k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -136,9 +143,10 @@
 // * double value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, int m, int n, int k, double alpha,
- const double* a, int lda, const double* b, int ldb, double beta,
- double* c, int ldc ) {
+inline void gemm( Order, TransA, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDgemm( blas_option< TransA >::value, blas_option< TransB >::value,
             m, n, k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -150,10 +158,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, int m, int n, int k,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void gemm( Order, TransA, TransB, const int m, const int n,
+ const int k, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda,
+ const std::complex<float>* b, const int ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCgemm( blas_option< TransA >::value, blas_option< TransB >::value,
             m, n, k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -165,10 +175,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, int m, int n, int k,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, std::complex<double> beta,
- std::complex<double>* c, int ldc ) {
+inline void gemm( Order, TransA, TransB, const int m, const int n,
+ const int k, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda,
+ const std::complex<double>* b, const int ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasZgemm( blas_option< TransA >::value, blas_option< TransB >::value,
             m, n, k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -181,10 +193,11 @@
 // * float value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, fortran_int_t m, fortran_int_t n,
- fortran_int_t k, float alpha, const float* a, fortran_int_t lda,
- const float* b, fortran_int_t ldb, float beta, float* c,
- fortran_int_t ldc ) {
+inline void gemm( Order, TransA, TransB, const fortran_int_t m,
+ const fortran_int_t n, const fortran_int_t k, const float alpha,
+ const float* a, const fortran_int_t lda, const float* b,
+ const fortran_int_t ldb, const float beta, float* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value,
             &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -196,10 +209,11 @@
 // * double value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, fortran_int_t m, fortran_int_t n,
- fortran_int_t k, double alpha, const double* a, fortran_int_t lda,
- const double* b, fortran_int_t ldb, double beta, double* c,
- fortran_int_t ldc ) {
+inline void gemm( Order, TransA, TransB, const fortran_int_t m,
+ const fortran_int_t n, const fortran_int_t k, const double alpha,
+ const double* a, const fortran_int_t lda, const double* b,
+ const fortran_int_t ldb, const double beta, double* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value,
             &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -211,11 +225,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, fortran_int_t m, fortran_int_t n,
- fortran_int_t k, std::complex<float> alpha,
- const std::complex<float>* a, fortran_int_t lda,
- const std::complex<float>* b, fortran_int_t ldb,
- std::complex<float> beta, std::complex<float>* c, fortran_int_t ldc ) {
+inline void gemm( Order, TransA, TransB, const fortran_int_t m,
+ const fortran_int_t n, const fortran_int_t k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const fortran_int_t lda, const std::complex<float>* b,
+ const fortran_int_t ldb, const std::complex<float> beta,
+ std::complex<float>* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value,
             &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -227,12 +242,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, fortran_int_t m, fortran_int_t n,
- fortran_int_t k, std::complex<double> alpha,
- const std::complex<double>* a, fortran_int_t lda,
- const std::complex<double>* b, fortran_int_t ldb,
- std::complex<double> beta, std::complex<double>* c,
- fortran_int_t ldc ) {
+inline void gemm( Order, TransA, TransB, const fortran_int_t m,
+ const fortran_int_t n, const fortran_int_t k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const fortran_int_t lda, const std::complex<double>* b,
+ const fortran_int_t ldb, const std::complex<double> beta,
+ std::complex<double>* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value,
             &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,10 +63,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemm( Order, char side, UpLo, int m, int n,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void hemm( Order, const char side, UpLo, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* b, const int ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     cblas_chemm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta,
             c, ldc );
@@ -78,10 +79,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemm( Order, char side, UpLo, int m, int n,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, std::complex<double> beta,
- std::complex<double>* c, int ldc ) {
+inline void hemm( Order, const char side, UpLo, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* b, const int ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const int ldc ) {
     cblas_zhemm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta,
             c, ldc );
@@ -94,10 +96,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemm( Order, char side, UpLo, int m, int n,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void hemm( Order, const char side, UpLo, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* b, const int ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasChemm( side, blas_option< UpLo >::value, m, n, alpha, a, lda, b,
             ldb, beta, c, ldc );
@@ -109,10 +112,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemm( Order, char side, UpLo, int m, int n,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, std::complex<double> beta,
- std::complex<double>* c, int ldc ) {
+inline void hemm( Order, const char side, UpLo, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* b, const int ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -124,10 +128,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
- std::complex<float> alpha, const std::complex<float>* a,
- fortran_int_t lda, const std::complex<float>* b, fortran_int_t ldb,
- std::complex<float> beta, std::complex<float>* c, fortran_int_t ldc ) {
+inline void hemm( Order, const char side, UpLo, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<float> alpha,
+ const std::complex<float>* a, const fortran_int_t lda,
+ const std::complex<float>* b, const fortran_int_t ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHEMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
             b, &ldb, &beta, c, &ldc );
@@ -139,11 +145,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void hemm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
- std::complex<double> alpha, const std::complex<double>* a,
- fortran_int_t lda, const std::complex<double>* b, fortran_int_t ldb,
- std::complex<double> beta, std::complex<double>* c,
- fortran_int_t ldc ) {
+inline void hemm( Order, const char side, UpLo, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<double> alpha,
+ const std::complex<double>* a, const fortran_int_t lda,
+ const std::complex<double>* b, const fortran_int_t ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHEMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
             b, &ldb, &beta, c, &ldc );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -64,10 +64,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, int n, int k,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, float beta,
- std::complex<float>* c, int ldc ) {
+inline void her2k( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* b, const int ldb,
+ const float beta, std::complex<float>* c, const int ldc ) {
     cblas_cher2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, beta,
             c, ldc );
@@ -79,10 +79,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, int n, int k,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, double beta,
- std::complex<double>* c, int ldc ) {
+inline void her2k( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* b, const int ldb,
+ const double beta, std::complex<double>* c, const int ldc ) {
     cblas_zher2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, beta,
             c, ldc );
@@ -95,10 +95,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, int n, int k,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, float beta,
- std::complex<float>* c, int ldc ) {
+inline void her2k( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* b, const int ldb,
+ const float beta, std::complex<float>* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCher2k( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -110,10 +110,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, int n, int k,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, double beta,
- std::complex<double>* c, int ldc ) {
+inline void her2k( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* b, const int ldb,
+ const double beta, std::complex<double>* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -125,10 +125,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- std::complex<float> alpha, const std::complex<float>* a,
- fortran_int_t lda, const std::complex<float>* b, fortran_int_t ldb,
- float beta, std::complex<float>* c, fortran_int_t ldc ) {
+inline void her2k( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<float> alpha,
+ const std::complex<float>* a, const fortran_int_t lda,
+ const std::complex<float>* b, const fortran_int_t ldb,
+ const float beta, std::complex<float>* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHER2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -140,10 +141,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- std::complex<double> alpha, const std::complex<double>* a,
- fortran_int_t lda, const std::complex<double>* b, fortran_int_t ldb,
- double beta, std::complex<double>* c, fortran_int_t ldc ) {
+inline void her2k( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<double> alpha,
+ const std::complex<double>* a, const fortran_int_t lda,
+ const std::complex<double>* b, const fortran_int_t ldb,
+ const double beta, std::complex<double>* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHER2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -64,9 +64,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, int n, int k, float alpha,
- const std::complex<float>* a, int lda, float beta,
- std::complex<float>* c, int ldc ) {
+inline void herk( Order, UpLo, Trans, const int n, const int k,
+ const float alpha, const std::complex<float>* a, const int lda,
+ const float beta, std::complex<float>* c, const int ldc ) {
     cblas_cherk( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc );
 }
@@ -77,9 +77,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, int n, int k, double alpha,
- const std::complex<double>* a, int lda, double beta,
- std::complex<double>* c, int ldc ) {
+inline void herk( Order, UpLo, Trans, const int n, const int k,
+ const double alpha, const std::complex<double>* a, const int lda,
+ const double beta, std::complex<double>* c, const int ldc ) {
     cblas_zherk( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc );
 }
@@ -91,9 +91,9 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, int n, int k, float alpha,
- const std::complex<float>* a, int lda, float beta,
- std::complex<float>* c, int ldc ) {
+inline void herk( Order, UpLo, Trans, const int n, const int k,
+ const float alpha, const std::complex<float>* a, const int lda,
+ const float beta, std::complex<float>* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCherk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, beta, c, ldc );
@@ -105,9 +105,9 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, int n, int k, double alpha,
- const std::complex<double>* a, int lda, double beta,
- std::complex<double>* c, int ldc ) {
+inline void herk( Order, UpLo, Trans, const int n, const int k,
+ const double alpha, const std::complex<double>* a, const int lda,
+ const double beta, std::complex<double>* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -119,9 +119,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- float alpha, const std::complex<float>* a, fortran_int_t lda,
- float beta, std::complex<float>* c, fortran_int_t ldc ) {
+inline void herk( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const float alpha,
+ const std::complex<float>* a, const fortran_int_t lda,
+ const float beta, std::complex<float>* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CHERK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
             &k, &alpha, a, &lda, &beta, c, &ldc );
@@ -133,9 +134,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- double alpha, const std::complex<double>* a, fortran_int_t lda,
- double beta, std::complex<double>* c, fortran_int_t ldc ) {
+inline void herk( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const double alpha,
+ const std::complex<double>* a, const fortran_int_t lda,
+ const double beta, std::complex<double>* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZHERK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
             &k, &alpha, a, &lda, &beta, c, &ldc );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -63,9 +63,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, int m, int n, float alpha,
- const float* a, int lda, const float* b, int ldb, float beta,
- float* c, int ldc ) {
+inline void symm( Order, const char side, UpLo, const int m, const int n,
+ const float alpha, const float* a, const int lda, const float* b,
+ const int ldb, const float beta, float* c, const int ldc ) {
     cblas_ssymm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, m, n, alpha, a, lda, b, ldb, beta, c,
             ldc );
@@ -77,9 +77,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, int m, int n, double alpha,
- const double* a, int lda, const double* b, int ldb, double beta,
- double* c, int ldc ) {
+inline void symm( Order, const char side, UpLo, const int m, const int n,
+ const double alpha, const double* a, const int lda, const double* b,
+ const int ldb, const double beta, double* c, const int ldc ) {
     cblas_dsymm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, m, n, alpha, a, lda, b, ldb, beta, c,
             ldc );
@@ -91,10 +91,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, int m, int n,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void symm( Order, const char side, UpLo, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* b, const int ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     cblas_csymm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta,
             c, ldc );
@@ -106,10 +107,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, int m, int n,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, std::complex<double> beta,
- std::complex<double>* c, int ldc ) {
+inline void symm( Order, const char side, UpLo, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* b, const int ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const int ldc ) {
     cblas_zsymm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta,
             c, ldc );
@@ -122,9 +124,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, int m, int n, float alpha,
- const float* a, int lda, const float* b, int ldb, float beta,
- float* c, int ldc ) {
+inline void symm( Order, const char side, UpLo, const int m, const int n,
+ const float alpha, const float* a, const int lda, const float* b,
+ const int ldb, const float beta, float* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSsymm( side, blas_option< UpLo >::value, m, n, alpha, a, lda, b,
             ldb, beta, c, ldc );
@@ -136,9 +138,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, int m, int n, double alpha,
- const double* a, int lda, const double* b, int ldb, double beta,
- double* c, int ldc ) {
+inline void symm( Order, const char side, UpLo, const int m, const int n,
+ const double alpha, const double* a, const int lda, const double* b,
+ const int ldb, const double beta, double* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDsymm( side, blas_option< UpLo >::value, m, n, alpha, a, lda, b,
             ldb, beta, c, ldc );
@@ -150,10 +152,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, int m, int n,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void symm( Order, const char side, UpLo, const int m, const int n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* b, const int ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCsymm( side, blas_option< UpLo >::value, m, n, alpha, a, lda, b,
             ldb, beta, c, ldc );
@@ -165,10 +168,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, int m, int n,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, std::complex<double> beta,
- std::complex<double>* c, int ldc ) {
+inline void symm( Order, const char side, UpLo, const int m, const int n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* b, const int ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -180,9 +184,10 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
- float alpha, const float* a, fortran_int_t lda, const float* b,
- fortran_int_t ldb, float beta, float* c, fortran_int_t ldc ) {
+inline void symm( Order, const char side, UpLo, const fortran_int_t m,
+ const fortran_int_t n, const float alpha, const float* a,
+ const fortran_int_t lda, const float* b, const fortran_int_t ldb,
+ const float beta, float* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSYMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
             b, &ldb, &beta, c, &ldc );
@@ -194,9 +199,10 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
- double alpha, const double* a, fortran_int_t lda, const double* b,
- fortran_int_t ldb, double beta, double* c, fortran_int_t ldc ) {
+inline void symm( Order, const char side, UpLo, const fortran_int_t m,
+ const fortran_int_t n, const double alpha, const double* a,
+ const fortran_int_t lda, const double* b, const fortran_int_t ldb,
+ const double beta, double* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSYMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
             b, &ldb, &beta, c, &ldc );
@@ -208,10 +214,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
- std::complex<float> alpha, const std::complex<float>* a,
- fortran_int_t lda, const std::complex<float>* b, fortran_int_t ldb,
- std::complex<float> beta, std::complex<float>* c, fortran_int_t ldc ) {
+inline void symm( Order, const char side, UpLo, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<float> alpha,
+ const std::complex<float>* a, const fortran_int_t lda,
+ const std::complex<float>* b, const fortran_int_t ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CSYMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
             b, &ldb, &beta, c, &ldc );
@@ -223,11 +231,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo >
-inline void symm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
- std::complex<double> alpha, const std::complex<double>* a,
- fortran_int_t lda, const std::complex<double>* b, fortran_int_t ldb,
- std::complex<double> beta, std::complex<double>* c,
- fortran_int_t ldc ) {
+inline void symm( Order, const char side, UpLo, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<double> alpha,
+ const std::complex<double>* a, const fortran_int_t lda,
+ const std::complex<double>* b, const fortran_int_t ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZSYMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
             b, &ldb, &beta, c, &ldc );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -64,9 +64,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, int n, int k, float alpha,
- const float* a, int lda, const float* b, int ldb, float beta,
- float* c, int ldc ) {
+inline void syr2k( Order, UpLo, Trans, 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 ) {
     cblas_ssyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, alpha, a, lda, b, ldb, beta,
             c, ldc );
@@ -78,9 +78,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, int n, int k, double alpha,
- const double* a, int lda, const double* b, int ldb, double beta,
- double* c, int ldc ) {
+inline void syr2k( Order, UpLo, Trans, 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 ) {
     cblas_dsyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, alpha, a, lda, b, ldb, beta,
             c, ldc );
@@ -92,10 +92,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, int n, int k,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void syr2k( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* b, const int ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     cblas_csyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, &beta,
             c, ldc );
@@ -107,10 +108,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, int n, int k,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, std::complex<double> beta,
- std::complex<double>* c, int ldc ) {
+inline void syr2k( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* b, const int ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const int ldc ) {
     cblas_zsyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, &beta,
             c, ldc );
@@ -123,9 +125,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, int n, int k, float alpha,
- const float* a, int lda, const float* b, int ldb, float beta,
- float* c, int ldc ) {
+inline void syr2k( Order, UpLo, Trans, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -137,9 +139,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, int n, int k, double alpha,
- const double* a, int lda, const double* b, int ldb, double beta,
- double* c, int ldc ) {
+inline void syr2k( Order, UpLo, Trans, 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 ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -151,10 +153,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, int n, int k,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- const std::complex<float>* b, int ldb, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void syr2k( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float>* b, const int ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -166,10 +169,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, int n, int k,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- const std::complex<double>* b, int ldb, std::complex<double> beta,
- std::complex<double>* c, int ldc ) {
+inline void syr2k( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double>* b, const int ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -181,9 +185,10 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- float alpha, const float* a, fortran_int_t lda, const float* b,
- fortran_int_t ldb, float beta, float* c, fortran_int_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const float alpha, const float* a,
+ const fortran_int_t lda, const float* b, const fortran_int_t ldb,
+ const float beta, float* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -195,9 +200,10 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- double alpha, const double* a, fortran_int_t lda, const double* b,
- fortran_int_t ldb, double beta, double* c, fortran_int_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const double alpha, const double* a,
+ const fortran_int_t lda, const double* b, const fortran_int_t ldb,
+ const double beta, double* c, const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -209,10 +215,12 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- std::complex<float> alpha, const std::complex<float>* a,
- fortran_int_t lda, const std::complex<float>* b, fortran_int_t ldb,
- std::complex<float> beta, std::complex<float>* c, fortran_int_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<float> alpha,
+ const std::complex<float>* a, const fortran_int_t lda,
+ const std::complex<float>* b, const fortran_int_t ldb,
+ const std::complex<float> beta, std::complex<float>* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -224,11 +232,12 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- std::complex<double> alpha, const std::complex<double>* a,
- fortran_int_t lda, const std::complex<double>* b, fortran_int_t ldb,
- std::complex<double> beta, std::complex<double>* c,
- fortran_int_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<double> alpha,
+ const std::complex<double>* a, const fortran_int_t lda,
+ const std::complex<double>* b, const fortran_int_t ldb,
+ const std::complex<double> beta, std::complex<double>* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
             &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -64,8 +64,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, int n, int k, float alpha,
- const float* a, int lda, float beta, float* c, int ldc ) {
+inline void syrk( Order, UpLo, Trans, const int n, const int k,
+ const float alpha, const float* a, const int lda, const float beta,
+ float* c, const int ldc ) {
     cblas_ssyrk( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc );
 }
@@ -76,8 +77,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, int n, int k, double alpha,
- const double* a, int lda, double beta, double* c, int ldc ) {
+inline void syrk( Order, UpLo, Trans, const int n, const int k,
+ const double alpha, const double* a, const int lda, const double beta,
+ double* c, const int ldc ) {
     cblas_dsyrk( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc );
 }
@@ -88,9 +90,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, int n, int k, std::complex<float> alpha,
- const std::complex<float>* a, int lda, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void syrk( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     cblas_csyrk( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, &alpha, a, lda, &beta, c,
             ldc );
@@ -102,9 +105,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, int n, int k,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- std::complex<double> beta, std::complex<double>* c, int ldc ) {
+inline void syrk( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double> beta,
+ std::complex<double>* c, const int ldc ) {
     cblas_zsyrk( cblas_option< Order >::value, cblas_option< UpLo >::value,
             cblas_option< Trans >::value, n, k, &alpha, a, lda, &beta, c,
             ldc );
@@ -117,8 +121,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, int n, int k, float alpha,
- const float* a, int lda, float beta, float* c, int ldc ) {
+inline void syrk( Order, UpLo, Trans, const int n, const int k,
+ const float alpha, const float* a, const int lda, const float beta,
+ float* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasSsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, beta, c, ldc );
@@ -130,8 +135,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, int n, int k, double alpha,
- const double* a, int lda, double beta, double* c, int ldc ) {
+inline void syrk( Order, UpLo, Trans, const int n, const int k,
+ const double alpha, const double* a, const int lda, const double beta,
+ double* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, beta, c, ldc );
@@ -143,9 +149,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, int n, int k, std::complex<float> alpha,
- const std::complex<float>* a, int lda, std::complex<float> beta,
- std::complex<float>* c, int ldc ) {
+inline void syrk( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const int lda, const std::complex<float> beta, std::complex<float>* c,
+ const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, beta, c, ldc );
@@ -157,9 +164,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, int n, int k,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- std::complex<double> beta, std::complex<double>* c, int ldc ) {
+inline void syrk( Order, UpLo, Trans, const int n, const int k,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const int lda, const std::complex<double> beta,
+ std::complex<double>* c, const int ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasZsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
             k, alpha, a, lda, beta, c, ldc );
@@ -172,9 +180,10 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- float alpha, const float* a, fortran_int_t lda, float beta, float* c,
- fortran_int_t ldc ) {
+inline void syrk( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const float alpha, const float* a,
+ const fortran_int_t lda, const float beta, float* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_SSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
             &k, &alpha, a, &lda, &beta, c, &ldc );
@@ -186,9 +195,10 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- double alpha, const double* a, fortran_int_t lda, double beta,
- double* c, fortran_int_t ldc ) {
+inline void syrk( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const double alpha, const double* a,
+ const fortran_int_t lda, const double beta, double* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
             &k, &alpha, a, &lda, &beta, c, &ldc );
@@ -200,10 +210,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- std::complex<float> alpha, const std::complex<float>* a,
- fortran_int_t lda, std::complex<float> beta, std::complex<float>* c,
- fortran_int_t ldc ) {
+inline void syrk( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<float> alpha,
+ const std::complex<float>* a, const fortran_int_t lda,
+ const std::complex<float> beta, std::complex<float>* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
             &k, &alpha, a, &lda, &beta, c, &ldc );
@@ -215,10 +226,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
- std::complex<double> alpha, const std::complex<double>* a,
- fortran_int_t lda, std::complex<double> beta, std::complex<double>* c,
- fortran_int_t ldc ) {
+inline void syrk( Order, UpLo, Trans, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<double> alpha,
+ const std::complex<double>* a, const fortran_int_t lda,
+ const std::complex<double> beta, std::complex<double>* c,
+ const fortran_int_t ldc ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
             &k, &alpha, a, &lda, &beta, c, &ldc );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -65,8 +65,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
- float alpha, const float* a, int lda, float* b, int ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const float alpha, const float* a, const int lda,
+ float* b, const int ldb ) {
     cblas_strmm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, cblas_option< TransA >::value,
             cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb );
@@ -78,8 +79,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
- double alpha, const double* a, int lda, double* b, int ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const double alpha, const double* a, const int lda,
+ double* b, const int ldb ) {
     cblas_dtrmm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, cblas_option< TransA >::value,
             cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb );
@@ -91,9 +93,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- std::complex<float>* b, int ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda, std::complex<float>* b,
+ const int ldb ) {
     cblas_ctrmm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, cblas_option< TransA >::value,
             cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb );
@@ -105,9 +108,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- std::complex<double>* b, int ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda, std::complex<double>* b,
+ const int ldb ) {
     cblas_ztrmm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, cblas_option< TransA >::value,
             cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb );
@@ -120,8 +124,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
- float alpha, const float* a, int lda, float* b, int ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const float alpha, const float* a, const int lda,
+ float* b, const int ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasStrmm( side, blas_option< UpLo >::value, blas_option<
             TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -134,8 +139,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
- double alpha, const double* a, int lda, double* b, int ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const double alpha, const double* a, const int lda,
+ double* b, const int ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDtrmm( side, blas_option< UpLo >::value, blas_option<
             TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -148,9 +154,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- std::complex<float>* b, int ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda, std::complex<float>* b,
+ const int ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCtrmm( side, blas_option< UpLo >::value, blas_option<
             TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -163,9 +170,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- std::complex<double>* b, int ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda, std::complex<double>* b,
+ const int ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     // NOT FOUND();
 }
@@ -177,9 +185,10 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
- fortran_int_t n, float alpha, const float* a, fortran_int_t lda,
- float* b, fortran_int_t ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag,
+ const fortran_int_t m, const fortran_int_t n, const float alpha,
+ const float* a, const fortran_int_t lda, float* b,
+ const fortran_int_t ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_STRMM( &side, &blas_option< UpLo >::value, &blas_option<
             TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -192,9 +201,10 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
- fortran_int_t n, double alpha, const double* a, fortran_int_t lda,
- double* b, fortran_int_t ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag,
+ const fortran_int_t m, const fortran_int_t n, const double alpha,
+ const double* a, const fortran_int_t lda, double* b,
+ const fortran_int_t ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DTRMM( &side, &blas_option< UpLo >::value, &blas_option<
             TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -207,10 +217,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
- fortran_int_t n, std::complex<float> alpha,
- const std::complex<float>* a, fortran_int_t lda,
- std::complex<float>* b, fortran_int_t ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag,
+ const fortran_int_t m, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const fortran_int_t lda, std::complex<float>* b,
+ const fortran_int_t ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CTRMM( &side, &blas_option< UpLo >::value, &blas_option<
             TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -223,10 +234,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
- fortran_int_t n, std::complex<double> alpha,
- const std::complex<double>* a, fortran_int_t lda,
- std::complex<double>* b, fortran_int_t ldb ) {
+inline void trmm( Order, const char side, UpLo, TransA, Diag,
+ const fortran_int_t m, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const fortran_int_t lda, std::complex<double>* b,
+ const fortran_int_t ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZTRMM( &side, &blas_option< UpLo >::value, &blas_option<
             TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -65,8 +65,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
- float alpha, const float* a, int lda, float* b, int ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const float alpha, const float* a, const int lda,
+ float* b, const int ldb ) {
     cblas_strsm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, cblas_option< TransA >::value,
             cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb );
@@ -78,8 +79,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
- double alpha, const double* a, int lda, double* b, int ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const double alpha, const double* a, const int lda,
+ double* b, const int ldb ) {
     cblas_dtrsm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, cblas_option< TransA >::value,
             cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb );
@@ -91,9 +93,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- std::complex<float>* b, int ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda, std::complex<float>* b,
+ const int ldb ) {
     cblas_ctrsm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, cblas_option< TransA >::value,
             cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb );
@@ -105,9 +108,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- std::complex<double>* b, int ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda, std::complex<double>* b,
+ const int ldb ) {
     cblas_ztrsm( cblas_option< Order >::value, cblas_option< Side >::value,
             cblas_option< UpLo >::value, cblas_option< TransA >::value,
             cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb );
@@ -120,8 +124,9 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
- float alpha, const float* a, int lda, float* b, int ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const float alpha, const float* a, const int lda,
+ float* b, const int ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasStrsm( side, blas_option< UpLo >::value, blas_option<
             TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -134,8 +139,9 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
- double alpha, const double* a, int lda, double* b, int ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const double alpha, const double* a, const int lda,
+ double* b, const int ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasDtrsm( side, blas_option< UpLo >::value, blas_option<
             TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -148,9 +154,10 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
- std::complex<float> alpha, const std::complex<float>* a, int lda,
- std::complex<float>* b, int ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const std::complex<float> alpha,
+ const std::complex<float>* a, const int lda, std::complex<float>* b,
+ const int ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasCtrsm( side, blas_option< UpLo >::value, blas_option<
             TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -163,9 +170,10 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
- std::complex<double> alpha, const std::complex<double>* a, int lda,
- std::complex<double>* b, int ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag, const int m,
+ const int n, const std::complex<double> alpha,
+ const std::complex<double>* a, const int lda, std::complex<double>* b,
+ const int ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     cublasZtrsm( side, blas_option< UpLo >::value, blas_option<
             TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -179,9 +187,10 @@
 // * float value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
- fortran_int_t n, float alpha, const float* a, fortran_int_t lda,
- float* b, fortran_int_t ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag,
+ const fortran_int_t m, const fortran_int_t n, const float alpha,
+ const float* a, const fortran_int_t lda, float* b,
+ const fortran_int_t ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_STRSM( &side, &blas_option< UpLo >::value, &blas_option<
             TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -194,9 +203,10 @@
 // * double value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
- fortran_int_t n, double alpha, const double* a, fortran_int_t lda,
- double* b, fortran_int_t ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag,
+ const fortran_int_t m, const fortran_int_t n, const double alpha,
+ const double* a, const fortran_int_t lda, double* b,
+ const fortran_int_t ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_DTRSM( &side, &blas_option< UpLo >::value, &blas_option<
             TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -209,10 +219,11 @@
 // * complex<float> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
- fortran_int_t n, std::complex<float> alpha,
- const std::complex<float>* a, fortran_int_t lda,
- std::complex<float>* b, fortran_int_t ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag,
+ const fortran_int_t m, const fortran_int_t n,
+ const std::complex<float> alpha, const std::complex<float>* a,
+ const fortran_int_t lda, std::complex<float>* b,
+ const fortran_int_t ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_CTRSM( &side, &blas_option< UpLo >::value, &blas_option<
             TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -225,10 +236,11 @@
 // * complex<double> value-type.
 //
 template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
- fortran_int_t n, std::complex<double> alpha,
- const std::complex<double>* a, fortran_int_t lda,
- std::complex<double>* b, fortran_int_t ldb ) {
+inline void trsm( Order, const char side, UpLo, TransA, Diag,
+ const fortran_int_t m, const fortran_int_t n,
+ const std::complex<double> alpha, const std::complex<double>* a,
+ const fortran_int_t lda, std::complex<double>* b,
+ const fortran_int_t ldb ) {
     BOOST_STATIC_ASSERT( (is_same<Order, tag::column_major>::value) );
     BLAS_ZTRSM( &side, &blas_option< UpLo >::value, &blas_option<
             TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,38 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_HPP
+
+#include <boost/numeric/bindings/lapack/auxiliary/larf.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/larfb.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/larfg.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/larft.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/larfx.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/largv.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/larnv.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/larrb.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/larre.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/langb.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lange.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lanhb.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lanhe.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lanhp.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lanhs.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lansb.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lansp.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lansy.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lantb.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lantr.hpp>
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,209 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANGB_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANGB_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for langb is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t langb( const char norm, const fortran_int_t n,
+ const fortran_int_t kl, const fortran_int_t ku, const float* ab,
+ const fortran_int_t ldab, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANGB( &norm, &n, &kl, &ku, ab, &ldab, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t langb( const char norm, const fortran_int_t n,
+ const fortran_int_t kl, const fortran_int_t ku, const double* ab,
+ const fortran_int_t ldab, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANGB( &norm, &n, &kl, &ku, ab, &ldab, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t langb( const char norm, const fortran_int_t n,
+ const fortran_int_t kl, const fortran_int_t ku,
+ const std::complex<float>* ab, const fortran_int_t ldab,
+ float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANGB( &norm, &n, &kl, &ku, ab, &ldab, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t langb( const char norm, const fortran_int_t n,
+ const fortran_int_t kl, const fortran_int_t ku,
+ const std::complex<double>* ab, const fortran_int_t ldab,
+ double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANGB( &norm, &n, &kl, &ku, ab, &ldab, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to langb.
+//
+template< typename Value >
+struct langb_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAB, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
+ BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
+ bandwidth_upper(ab)+1 );
+ return detail::langb( norm, n, bandwidth_lower(ab),
+ bandwidth_upper(ab), begin_value(ab), stride_major(ab),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAB >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, n, ab, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAB >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, optimal_workspace work ) {
+ return invoke( norm, n, ab, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the langb_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for langb. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAB, typename Workspace >
+inline std::ptrdiff_t langb( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, Workspace work ) {
+ return langb_impl< typename value< MatrixAB >::type >::invoke( norm,
+ n, ab, work );
+}
+
+//
+// Overloaded function for langb. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAB >
+inline std::ptrdiff_t langb( const char norm, const fortran_int_t n,
+ const MatrixAB& ab ) {
+ return langb_impl< typename value< MatrixAB >::type >::invoke( norm,
+ n, ab, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lange.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lange.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,205 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANGE_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANGE_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lange is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t lange( const char norm, const fortran_int_t m,
+ const fortran_int_t n, const float* a, const fortran_int_t lda,
+ float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANGE( &norm, &m, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t lange( const char norm, const fortran_int_t m,
+ const fortran_int_t n, const double* a, const fortran_int_t lda,
+ double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANGE( &norm, &m, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t lange( const char norm, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<float>* a,
+ const fortran_int_t lda, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANGE( &norm, &m, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t lange( const char norm, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<double>* a,
+ const fortran_int_t lda, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANGE( &norm, &m, &n, a, &lda, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lange.
+//
+template< typename Value >
+struct lange_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixA, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_row(a) >= 0 );
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(size_row(a),
+ 1) );
+ return detail::lange( norm, size_row(a), size_column(a),
+ begin_value(a), stride_major(a),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, a, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ optimal_workspace work ) {
+ return invoke( norm, a, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lange_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lange. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixA, typename Workspace >
+inline std::ptrdiff_t lange( const char norm, const MatrixA& a,
+ Workspace work ) {
+ return lange_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, work );
+}
+
+//
+// Overloaded function for lange. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixA >
+inline std::ptrdiff_t lange( const char norm, const MatrixA& a ) {
+ return lange_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,184 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHB_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHB_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lanhb is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lanhb( const char norm, UpLo, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<float>* ab,
+ const fortran_int_t ldab, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANHB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab,
+ work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lanhb( const char norm, UpLo, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<double>* ab,
+ const fortran_int_t ldab, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANHB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab,
+ work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lanhb.
+//
+template< typename Value >
+struct lanhb_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAB, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
+ BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+1 );
+ return detail::lanhb( norm, uplo(), n, bandwidth_lower(ab),
+ begin_value(ab), stride_major(ab),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAB >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, n, ab, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAB >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, optimal_workspace work ) {
+ return invoke( norm, n, ab, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lanhb_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lanhb. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAB, typename Workspace >
+inline std::ptrdiff_t lanhb( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, Workspace work ) {
+ return lanhb_impl< typename value< MatrixAB >::type >::invoke( norm,
+ n, ab, work );
+}
+
+//
+// Overloaded function for lanhb. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAB >
+inline std::ptrdiff_t lanhb( const char norm, const fortran_int_t n,
+ const MatrixAB& ab ) {
+ return lanhb_impl< typename value< MatrixAB >::type >::invoke( norm,
+ n, ab, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,182 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHE_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHE_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lanhe is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lanhe( const char norm, UpLo, const fortran_int_t n,
+ const std::complex<float>* a, const fortran_int_t lda, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANHE( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lanhe( const char norm, UpLo, const fortran_int_t n,
+ const std::complex<double>* a, const fortran_int_t lda,
+ double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANHE( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lanhe.
+//
+template< typename Value >
+struct lanhe_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixA, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( stride_major(a) >= std::max<
+ std::ptrdiff_t >(size_column(a),1) );
+ return detail::lanhe( norm, uplo(), size_column(a), begin_value(a),
+ stride_major(a), begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, a, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ return invoke( norm, a, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lanhe_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lanhe. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixA, typename Workspace >
+inline std::ptrdiff_t lanhe( const char norm, const MatrixA& a,
+ Workspace work ) {
+ return lanhe_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, work );
+}
+
+//
+// Overloaded function for lanhe. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixA >
+inline std::ptrdiff_t lanhe( const char norm, const MatrixA& a ) {
+ return lanhe_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,176 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHP_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHP_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lanhp is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lanhp( const char norm, UpLo, const fortran_int_t n,
+ const std::complex<float>* ap, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANHP( &norm, &lapack_option< UpLo >::value, &n, ap, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lanhp( const char norm, UpLo, const fortran_int_t n,
+ const std::complex<double>* ap, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANHP( &norm, &lapack_option< UpLo >::value, &n, ap, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lanhp.
+//
+template< typename Value >
+struct lanhp_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAP& ap, detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ return detail::lanhp( norm, uplo(), n, begin_value(ap),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAP& ap, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, n, ap, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAP& ap, optimal_workspace work ) {
+ return invoke( norm, n, ap, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lanhp_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lanhp. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAP, typename Workspace >
+inline std::ptrdiff_t lanhp( const char norm, const fortran_int_t n,
+ const MatrixAP& ap, Workspace work ) {
+ return lanhp_impl< typename value< MatrixAP >::type >::invoke( norm,
+ n, ap, work );
+}
+
+//
+// Overloaded function for lanhp. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP >
+inline std::ptrdiff_t lanhp( const char norm, const fortran_int_t n,
+ const MatrixAP& ap ) {
+ return lanhp_impl< typename value< MatrixAP >::type >::invoke( norm,
+ n, ap, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,200 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHS_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHS_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lanhs is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t lanhs( const char norm, const fortran_int_t n,
+ const float* a, const fortran_int_t lda, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANHS( &norm, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t lanhs( const char norm, const fortran_int_t n,
+ const double* a, const fortran_int_t lda, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANHS( &norm, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t lanhs( const char norm, const fortran_int_t n,
+ const std::complex<float>* a, const fortran_int_t lda, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANHS( &norm, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t lanhs( const char norm, const fortran_int_t n,
+ const std::complex<double>* a, const fortran_int_t lda,
+ double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANHS( &norm, &n, a, &lda, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lanhs.
+//
+template< typename Value >
+struct lanhs_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixA, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( stride_major(a) >= std::max<
+ std::ptrdiff_t >(size_column(a),1) );
+ return detail::lanhs( norm, size_column(a), begin_value(a),
+ stride_major(a), begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, a, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ optimal_workspace work ) {
+ return invoke( norm, a, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lanhs_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lanhs. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixA, typename Workspace >
+inline std::ptrdiff_t lanhs( const char norm, const MatrixA& a,
+ Workspace work ) {
+ return lanhs_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, work );
+}
+
+//
+// Overloaded function for lanhs. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixA >
+inline std::ptrdiff_t lanhs( const char norm, const MatrixA& a ) {
+ return lanhs_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,214 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSB_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSB_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lansb is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansb( const char norm, UpLo, const fortran_int_t n,
+ const fortran_int_t k, const float* ab, const fortran_int_t ldab,
+ float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANSB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab,
+ work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansb( const char norm, UpLo, const fortran_int_t n,
+ const fortran_int_t k, const double* ab, const fortran_int_t ldab,
+ double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANSB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab,
+ work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansb( const char norm, UpLo, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<float>* ab,
+ const fortran_int_t ldab, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANSB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab,
+ work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansb( const char norm, UpLo, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<double>* ab,
+ const fortran_int_t ldab, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANSB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab,
+ work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lansb.
+//
+template< typename Value >
+struct lansb_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAB, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
+ BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+1 );
+ return detail::lansb( norm, uplo(), n, bandwidth_lower(ab),
+ begin_value(ab), stride_major(ab),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAB >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, n, ab, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAB >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, optimal_workspace work ) {
+ return invoke( norm, n, ab, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lansb_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lansb. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAB, typename Workspace >
+inline std::ptrdiff_t lansb( const char norm, const fortran_int_t n,
+ const MatrixAB& ab, Workspace work ) {
+ return lansb_impl< typename value< MatrixAB >::type >::invoke( norm,
+ n, ab, work );
+}
+
+//
+// Overloaded function for lansb. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAB >
+inline std::ptrdiff_t lansb( const char norm, const fortran_int_t n,
+ const MatrixAB& ab ) {
+ return lansb_impl< typename value< MatrixAB >::type >::invoke( norm,
+ n, ab, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,202 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSP_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSP_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lansp is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansp( const char norm, UpLo, const fortran_int_t n,
+ const float* ap, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANSP( &norm, &lapack_option< UpLo >::value, &n, ap, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansp( const char norm, UpLo, const fortran_int_t n,
+ const double* ap, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANSP( &norm, &lapack_option< UpLo >::value, &n, ap, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansp( const char norm, UpLo, const fortran_int_t n,
+ const std::complex<float>* ap, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANSP( &norm, &lapack_option< UpLo >::value, &n, ap, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansp( const char norm, UpLo, const fortran_int_t n,
+ const std::complex<double>* ap, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANSP( &norm, &lapack_option< UpLo >::value, &n, ap, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lansp.
+//
+template< typename Value >
+struct lansp_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAP& ap, detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ return detail::lansp( norm, uplo(), n, begin_value(ap),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAP& ap, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, n, ap, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
+ const MatrixAP& ap, optimal_workspace work ) {
+ return invoke( norm, n, ap, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lansp_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lansp. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAP, typename Workspace >
+inline std::ptrdiff_t lansp( const char norm, const fortran_int_t n,
+ const MatrixAP& ap, Workspace work ) {
+ return lansp_impl< typename value< MatrixAP >::type >::invoke( norm,
+ n, ap, work );
+}
+
+//
+// Overloaded function for lansp. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP >
+inline std::ptrdiff_t lansp( const char norm, const fortran_int_t n,
+ const MatrixAP& ap ) {
+ return lansp_impl< typename value< MatrixAP >::type >::invoke( norm,
+ n, ap, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansy.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansy.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,208 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSY_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSY_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lansy is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansy( const char norm, UpLo, const fortran_int_t n,
+ const float* a, const fortran_int_t lda, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANSY( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansy( const char norm, UpLo, const fortran_int_t n,
+ const double* a, const fortran_int_t lda, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANSY( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansy( const char norm, UpLo, const fortran_int_t n,
+ const std::complex<float>* a, const fortran_int_t lda, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANSY( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t lansy( const char norm, UpLo, const fortran_int_t n,
+ const std::complex<double>* a, const fortran_int_t lda,
+ double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANSY( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lansy.
+//
+template< typename Value >
+struct lansy_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixA, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( stride_major(a) >= std::max<
+ std::ptrdiff_t >(size_column(a),1) );
+ return detail::lansy( norm, uplo(), size_column(a), begin_value(a),
+ stride_major(a), begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, a, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ return invoke( norm, a, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lansy_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lansy. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixA, typename Workspace >
+inline std::ptrdiff_t lansy( const char norm, const MatrixA& a,
+ Workspace work ) {
+ return lansy_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, work );
+}
+
+//
+// Overloaded function for lansy. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixA >
+inline std::ptrdiff_t lansy( const char norm, const MatrixA& a ) {
+ return lansy_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,224 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTB_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTB_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/diag_tag.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lantb is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename Diag >
+inline std::ptrdiff_t lantb( const char norm, const char uplo, Diag,
+ const fortran_int_t n, const fortran_int_t k, const float* ab,
+ const fortran_int_t ldab, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANTB( &norm, &uplo, &lapack_option< Diag >::value, &n, &k, ab,
+ &ldab, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename Diag >
+inline std::ptrdiff_t lantb( const char norm, const char uplo, Diag,
+ const fortran_int_t n, const fortran_int_t k, const double* ab,
+ const fortran_int_t ldab, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANTB( &norm, &uplo, &lapack_option< Diag >::value, &n, &k, ab,
+ &ldab, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename Diag >
+inline std::ptrdiff_t lantb( const char norm, const char uplo, Diag,
+ const fortran_int_t n, const fortran_int_t k,
+ const std::complex<float>* ab, const fortran_int_t ldab,
+ float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANTB( &norm, &uplo, &lapack_option< Diag >::value, &n, &k, ab,
+ &ldab, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename Diag >
+inline std::ptrdiff_t lantb( const char norm, const char uplo, Diag,
+ const fortran_int_t n, const fortran_int_t k,
+ const std::complex<double>* ab, const fortran_int_t ldab,
+ double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANTB( &norm, &uplo, &lapack_option< Diag >::value, &n, &k, ab,
+ &ldab, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lantb.
+//
+template< typename Value >
+struct lantb_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAB, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const char uplo,
+ const fortran_int_t n, const fortran_int_t k,
+ const MatrixAB& ab, detail::workspace1< WORK > work ) {
+ typedef typename result_of::diag_tag< MatrixAB >::type diag;
+ BOOST_ASSERT( k >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
+ BOOST_ASSERT( stride_major(ab) >= k+1 );
+ return detail::lantb( norm, uplo, diag(), n, k, begin_value(ab),
+ stride_major(ab), begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAB >
+ static std::ptrdiff_t invoke( const char norm, const char uplo,
+ const fortran_int_t n, const fortran_int_t k,
+ const MatrixAB& ab, minimal_workspace work ) {
+ typedef typename result_of::diag_tag< MatrixAB >::type diag;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, uplo, n, k, ab, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAB >
+ static std::ptrdiff_t invoke( const char norm, const char uplo,
+ const fortran_int_t n, const fortran_int_t k,
+ const MatrixAB& ab, optimal_workspace work ) {
+ typedef typename result_of::diag_tag< MatrixAB >::type diag;
+ return invoke( norm, uplo, n, k, ab, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lantb_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lantb. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAB, typename Workspace >
+inline std::ptrdiff_t lantb( const char norm, const char uplo,
+ const fortran_int_t n, const fortran_int_t k,
+ const MatrixAB& ab, Workspace work ) {
+ return lantb_impl< typename value< MatrixAB >::type >::invoke( norm,
+ uplo, n, k, ab, work );
+}
+
+//
+// Overloaded function for lantb. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAB >
+inline std::ptrdiff_t lantb( const char norm, const char uplo,
+ const fortran_int_t n, const fortran_int_t k,
+ const MatrixAB& ab ) {
+ return lantb_impl< typename value< MatrixAB >::type >::invoke( norm,
+ uplo, n, k, ab, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantr.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantr.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,222 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTR_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTR_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/diag_tag.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lantr is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t lantr( const char norm, UpLo, Diag,
+ const fortran_int_t m, const fortran_int_t n, const float* a,
+ const fortran_int_t lda, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANTR( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &m, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t lantr( const char norm, UpLo, Diag,
+ const fortran_int_t m, const fortran_int_t n, const double* a,
+ const fortran_int_t lda, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANTR( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &m, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t lantr( const char norm, UpLo, Diag,
+ const fortran_int_t m, const fortran_int_t n,
+ const std::complex<float>* a, const fortran_int_t lda, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANTR( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &m, &n, a, &lda, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t lantr( const char norm, UpLo, Diag,
+ const fortran_int_t m, const fortran_int_t n,
+ const std::complex<double>* a, const fortran_int_t lda,
+ double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANTR( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &m, &n, a, &lda, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lantr.
+//
+template< typename Value >
+struct lantr_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixA, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ typedef typename result_of::diag_tag< MatrixA >::type diag;
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_row(a) >= 0 );
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(size_row(a),
+ 1) );
+ return detail::lantr( norm, uplo(), diag(), size_row(a),
+ size_column(a), begin_value(a), stride_major(a),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ typedef typename result_of::diag_tag< MatrixA >::type diag;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, a, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixA >
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ typedef typename result_of::diag_tag< MatrixA >::type diag;
+ return invoke( norm, a, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lantr_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lantr. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixA, typename Workspace >
+inline std::ptrdiff_t lantr( const char norm, const MatrixA& a,
+ Workspace work ) {
+ return lantr_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, work );
+}
+
+//
+// Overloaded function for lantr. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixA >
+inline std::ptrdiff_t lantr( const char norm, const MatrixA& a ) {
+ return lantr_impl< typename value< MatrixA >::type >::invoke( norm,
+ a, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larf.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larf.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,377 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARF_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARF_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for larf is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t larf( const char side, const fortran_int_t m,
+ const fortran_int_t n, const float* v, const fortran_int_t incv,
+ const float tau, float* c, const fortran_int_t ldc, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLARF( &side, &m, &n, v, &incv, &tau, c, &ldc, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t larf( const char side, const fortran_int_t m,
+ const fortran_int_t n, const double* v, const fortran_int_t incv,
+ const double tau, double* c, const fortran_int_t ldc, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLARF( &side, &m, &n, v, &incv, &tau, c, &ldc, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t larf( const char side, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<float>* v,
+ const fortran_int_t incv, const std::complex<float> tau,
+ std::complex<float>* c, const fortran_int_t ldc,
+ std::complex<float>* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLARF( &side, &m, &n, v, &incv, &tau, c, &ldc, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t larf( const char side, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<double>* v,
+ const fortran_int_t incv, const std::complex<double> tau,
+ std::complex<double>* c, const fortran_int_t ldc,
+ std::complex<double>* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLARF( &side, &m, &n, v, &incv, &tau, c, &ldc, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to larf.
+//
+template< typename Value, typename Enable = void >
+struct larf_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct larf_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorV, typename MatrixC, typename WORK >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const real_type tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorV >::type >::type,
+ typename remove_const< typename value<
+ MatrixC >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
+ size_column(c), size_row(c) ));
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
+ BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ size_row(c)) );
+ return detail::larf( side, size_row(c), size_column(c),
+ begin_value(v), stride(v), tau, begin_value(c),
+ stride_major(c), begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename VectorV, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const real_type tau, MatrixC& c, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work( side,
+ size_column(c), size_row(c) ) );
+ return invoke( side, v, tau, c, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename VectorV, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const real_type tau, MatrixC& c, optimal_workspace work ) {
+ return invoke( side, v, tau, c, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const char side,
+ const std::ptrdiff_t n, const std::ptrdiff_t m ) {
+ return ( side == 'L' ? n : m );
+ }
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct larf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorV, typename MatrixC, typename WORK >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const value_type tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorV >::type >::type,
+ typename remove_const< typename value<
+ MatrixC >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( side,
+ size_column(c), size_row(c) ));
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
+ BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ size_row(c)) );
+ return detail::larf( side, size_row(c), size_column(c),
+ begin_value(v), stride(v), tau, begin_value(c),
+ stride_major(c), begin_value(work.select(value_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename VectorV, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const value_type tau, MatrixC& c, minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work( side,
+ size_column(c), size_row(c) ) );
+ return invoke( side, v, tau, c, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename VectorV, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const value_type tau, MatrixC& c, optimal_workspace work ) {
+ return invoke( side, v, tau, c, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const char side,
+ const std::ptrdiff_t n, const std::ptrdiff_t m ) {
+ return ( side == 'L' ? n : m );
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the larf_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for larf. Its overload differs for
+// * MatrixC&
+// * User-defined workspace
+//
+template< typename VectorV, typename MatrixC, typename Workspace >
+inline std::ptrdiff_t larf( const char side, const VectorV& v,
+ const typename remove_imaginary< typename value<
+ VectorV >::type >::type tau, MatrixC& c, Workspace work ) {
+ return larf_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, work );
+}
+
+//
+// Overloaded function for larf. Its overload differs for
+// * MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename VectorV, typename MatrixC >
+inline std::ptrdiff_t larf( const char side, const VectorV& v,
+ const typename remove_imaginary< typename value<
+ VectorV >::type >::type tau, MatrixC& c ) {
+ return larf_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, optimal_workspace() );
+}
+
+//
+// Overloaded function for larf. Its overload differs for
+// * const MatrixC&
+// * User-defined workspace
+//
+template< typename VectorV, typename MatrixC, typename Workspace >
+inline std::ptrdiff_t larf( const char side, const VectorV& v,
+ const typename remove_imaginary< typename value<
+ VectorV >::type >::type tau, const MatrixC& c, Workspace work ) {
+ return larf_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, work );
+}
+
+//
+// Overloaded function for larf. Its overload differs for
+// * const MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename VectorV, typename MatrixC >
+inline std::ptrdiff_t larf( const char side, const VectorV& v,
+ const typename remove_imaginary< typename value<
+ VectorV >::type >::type tau, const MatrixC& c ) {
+ return larf_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, optimal_workspace() );
+}
+//
+// Overloaded function for larf. Its overload differs for
+// * MatrixC&
+// * User-defined workspace
+//
+template< typename VectorV, typename MatrixC, typename Workspace >
+inline std::ptrdiff_t larf( const char side, const VectorV& v,
+ const typename value< VectorV >::type tau, MatrixC& c,
+ Workspace work ) {
+ return larf_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, work );
+}
+
+//
+// Overloaded function for larf. Its overload differs for
+// * MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename VectorV, typename MatrixC >
+inline std::ptrdiff_t larf( const char side, const VectorV& v,
+ const typename value< VectorV >::type tau, MatrixC& c ) {
+ return larf_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, optimal_workspace() );
+}
+
+//
+// Overloaded function for larf. Its overload differs for
+// * const MatrixC&
+// * User-defined workspace
+//
+template< typename VectorV, typename MatrixC, typename Workspace >
+inline std::ptrdiff_t larf( const char side, const VectorV& v,
+ const typename value< VectorV >::type tau, const MatrixC& c,
+ Workspace work ) {
+ return larf_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, work );
+}
+
+//
+// Overloaded function for larf. Its overload differs for
+// * const MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename VectorV, typename MatrixC >
+inline std::ptrdiff_t larf( const char side, const VectorV& v,
+ const typename value< VectorV >::type tau, const MatrixC& c ) {
+ return larf_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfb.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfb.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,372 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFB_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFB_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/trans_tag.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for larfb is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename Trans >
+inline std::ptrdiff_t larfb( const char side, Trans, const char direct,
+ const char storev, const fortran_int_t m, const fortran_int_t n,
+ const fortran_int_t k, const float* v, const fortran_int_t ldv,
+ const float* t, const fortran_int_t ldt, float* c,
+ const fortran_int_t ldc, float* work, const fortran_int_t ldwork ) {
+ fortran_int_t info(0);
+ LAPACK_SLARFB( &side, &lapack_option< Trans >::value, &direct, &storev,
+ &m, &n, &k, v, &ldv, t, &ldt, c, &ldc, work, &ldwork );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename Trans >
+inline std::ptrdiff_t larfb( const char side, Trans, const char direct,
+ const char storev, const fortran_int_t m, const fortran_int_t n,
+ const fortran_int_t k, const double* v, const fortran_int_t ldv,
+ const double* t, const fortran_int_t ldt, double* c,
+ const fortran_int_t ldc, double* work, const fortran_int_t ldwork ) {
+ fortran_int_t info(0);
+ LAPACK_DLARFB( &side, &lapack_option< Trans >::value, &direct, &storev,
+ &m, &n, &k, v, &ldv, t, &ldt, c, &ldc, work, &ldwork );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename Trans >
+inline std::ptrdiff_t larfb( const char side, Trans, const char direct,
+ const char storev, const fortran_int_t m, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<float>* v,
+ const fortran_int_t ldv, const std::complex<float>* t,
+ const fortran_int_t ldt, std::complex<float>* c,
+ const fortran_int_t ldc, std::complex<float>* work,
+ const fortran_int_t ldwork ) {
+ fortran_int_t info(0);
+ LAPACK_CLARFB( &side, &lapack_option< Trans >::value, &direct, &storev,
+ &m, &n, &k, v, &ldv, t, &ldt, c, &ldc, work, &ldwork );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename Trans >
+inline std::ptrdiff_t larfb( const char side, Trans, const char direct,
+ const char storev, const fortran_int_t m, const fortran_int_t n,
+ const fortran_int_t k, const std::complex<double>* v,
+ const fortran_int_t ldv, const std::complex<double>* t,
+ const fortran_int_t ldt, std::complex<double>* c,
+ const fortran_int_t ldc, std::complex<double>* work,
+ const fortran_int_t ldwork ) {
+ fortran_int_t info(0);
+ LAPACK_ZLARFB( &side, &lapack_option< Trans >::value, &direct, &storev,
+ &m, &n, &k, v, &ldv, t, &ldt, c, &ldc, work, &ldwork );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to larfb.
+//
+template< typename Value, typename Enable = void >
+struct larfb_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct larfb_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixV, typename MatrixT, typename MatrixC,
+ typename WORK >
+ static std::ptrdiff_t invoke( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
+ detail::workspace1< WORK > work ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixV >::type >::type,
+ typename remove_const< typename value<
+ MatrixT >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixV >::type >::type,
+ typename remove_const< typename value<
+ MatrixC >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( direct == 'F' || direct == 'B' );
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
+ BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
+ BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
+ BOOST_ASSERT( storev == 'C' || storev == 'R' );
+ BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ size_row(c)) );
+ BOOST_ASSERT( stride_major(t) >= size_column(t) );
+ return detail::larfb( side, trans(), direct, storev, size_row(c),
+ size_column(c), size_column(t), begin_value(v),
+ stride_major(v), begin_value(t), stride_major(t),
+ begin_value(c), stride_major(c), begin_value(work),
+ stride_major(work) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixV, typename MatrixT, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
+ minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( side, direct, storev, v, t, c, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixV, typename MatrixT, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
+ optimal_workspace work ) {
+ return invoke( side, direct, storev, v, t, c, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct larfb_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixV, typename MatrixT, typename MatrixC,
+ typename WORK >
+ static std::ptrdiff_t invoke( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
+ detail::workspace1< WORK > work ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixV >::type >::type,
+ typename remove_const< typename value<
+ MatrixT >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixV >::type >::type,
+ typename remove_const< typename value<
+ MatrixC >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( direct == 'F' || direct == 'B' );
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
+ BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
+ BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
+ BOOST_ASSERT( storev == 'C' || storev == 'R' );
+ BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ size_row(c)) );
+ BOOST_ASSERT( stride_major(t) >= size_column(t) );
+ return detail::larfb( side, trans(), direct, storev, size_row(c),
+ size_column(c), size_column(t), begin_value(v),
+ stride_major(v), begin_value(t), stride_major(t),
+ begin_value(c), stride_major(c), begin_value(work),
+ stride_major(work) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixV, typename MatrixT, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
+ minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( side, direct, storev, v, t, c, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixV, typename MatrixT, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
+ optimal_workspace work ) {
+ return invoke( side, direct, storev, v, t, c, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the larfb_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for larfb. Its overload differs for
+// * MatrixC&
+// * User-defined workspace
+//
+template< typename MatrixV, typename MatrixT, typename MatrixC,
+ typename Workspace >
+inline std::ptrdiff_t larfb( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
+ Workspace work ) {
+ return larfb_impl< typename value< MatrixV >::type >::invoke( side,
+ direct, storev, v, t, c, work );
+}
+
+//
+// Overloaded function for larfb. Its overload differs for
+// * MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename MatrixV, typename MatrixT, typename MatrixC >
+inline std::ptrdiff_t larfb( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c ) {
+ return larfb_impl< typename value< MatrixV >::type >::invoke( side,
+ direct, storev, v, t, c, optimal_workspace() );
+}
+
+//
+// Overloaded function for larfb. Its overload differs for
+// * const MatrixC&
+// * User-defined workspace
+//
+template< typename MatrixV, typename MatrixT, typename MatrixC,
+ typename Workspace >
+inline std::ptrdiff_t larfb( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t,
+ const MatrixC& c, Workspace work ) {
+ return larfb_impl< typename value< MatrixV >::type >::invoke( side,
+ direct, storev, v, t, c, work );
+}
+
+//
+// Overloaded function for larfb. Its overload differs for
+// * const MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename MatrixV, typename MatrixT, typename MatrixC >
+inline std::ptrdiff_t larfb( const char side, const char direct,
+ const char storev, const MatrixV& v, const MatrixT& t,
+ const MatrixC& c ) {
+ return larfb_impl< typename value< MatrixV >::type >::invoke( side,
+ direct, storev, v, t, c, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfg.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfg.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,220 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFG_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFG_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for larfg is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t larfg( const fortran_int_t n, float& alpha, float* x,
+ const fortran_int_t incx, float& tau ) {
+ fortran_int_t info(0);
+ LAPACK_SLARFG( &n, &alpha, x, &incx, &tau );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t larfg( const fortran_int_t n, double& alpha, double* x,
+ const fortran_int_t incx, double& tau ) {
+ fortran_int_t info(0);
+ LAPACK_DLARFG( &n, &alpha, x, &incx, &tau );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t larfg( const fortran_int_t n, std::complex<float>& alpha,
+ std::complex<float>* x, const fortran_int_t incx,
+ std::complex<float>& tau ) {
+ fortran_int_t info(0);
+ LAPACK_CLARFG( &n, &alpha, x, &incx, &tau );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t larfg( const fortran_int_t n,
+ std::complex<double>& alpha, std::complex<double>* x,
+ const fortran_int_t incx, std::complex<double>& tau ) {
+ fortran_int_t info(0);
+ LAPACK_ZLARFG( &n, &alpha, x, &incx, &tau );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to larfg.
+//
+template< typename Value, typename Enable = void >
+struct larfg_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct larfg_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorX >
+ static std::ptrdiff_t invoke( const fortran_int_t n, real_type& alpha,
+ VectorX& x, real_type& tau ) {
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ return detail::larfg( n, alpha, begin_value(x), stride(x), tau );
+ }
+
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct larfg_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorX >
+ static std::ptrdiff_t invoke( const fortran_int_t n, value_type& alpha,
+ VectorX& x, value_type& tau ) {
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ return detail::larfg( n, alpha, begin_value(x), stride(x), tau );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the larfg_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for larfg. Its overload differs for
+// * VectorX&
+//
+template< typename VectorX >
+inline std::ptrdiff_t larfg( const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorX >::type >::type& alpha, VectorX& x, typename remove_imaginary<
+ typename value< VectorX >::type >::type& tau ) {
+ return larfg_impl< typename value< VectorX >::type >::invoke( n,
+ alpha, x, tau );
+}
+
+//
+// Overloaded function for larfg. Its overload differs for
+// * const VectorX&
+//
+template< typename VectorX >
+inline std::ptrdiff_t larfg( const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorX >::type >::type& alpha, const VectorX& x,
+ typename remove_imaginary< typename value<
+ VectorX >::type >::type& tau ) {
+ return larfg_impl< typename value< VectorX >::type >::invoke( n,
+ alpha, x, tau );
+}
+//
+// Overloaded function for larfg. Its overload differs for
+// * VectorX&
+//
+template< typename VectorX >
+inline std::ptrdiff_t larfg( const fortran_int_t n, typename value<
+ VectorX >::type& alpha, VectorX& x, typename value<
+ VectorX >::type& tau ) {
+ return larfg_impl< typename value< VectorX >::type >::invoke( n,
+ alpha, x, tau );
+}
+
+//
+// Overloaded function for larfg. Its overload differs for
+// * const VectorX&
+//
+template< typename VectorX >
+inline std::ptrdiff_t larfg( const fortran_int_t n, typename value<
+ VectorX >::type& alpha, const VectorX& x, typename value<
+ VectorX >::type& tau ) {
+ return larfg_impl< typename value< VectorX >::type >::invoke( n,
+ alpha, x, tau );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larft.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larft.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,215 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFT_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFT_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for larft is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t larft( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k, float* v,
+ const fortran_int_t ldv, const float* tau, float* t,
+ const fortran_int_t ldt ) {
+ fortran_int_t info(0);
+ LAPACK_SLARFT( &direct, &storev, &n, &k, v, &ldv, tau, t, &ldt );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t larft( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k, double* v,
+ const fortran_int_t ldv, const double* tau, double* t,
+ const fortran_int_t ldt ) {
+ fortran_int_t info(0);
+ LAPACK_DLARFT( &direct, &storev, &n, &k, v, &ldv, tau, t, &ldt );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t larft( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k, std::complex<float>* v,
+ const fortran_int_t ldv, const std::complex<float>* tau,
+ std::complex<float>* t, const fortran_int_t ldt ) {
+ fortran_int_t info(0);
+ LAPACK_CLARFT( &direct, &storev, &n, &k, v, &ldv, tau, t, &ldt );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t larft( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k, std::complex<double>* v,
+ const fortran_int_t ldv, const std::complex<double>* tau,
+ std::complex<double>* t, const fortran_int_t ldt ) {
+ fortran_int_t info(0);
+ LAPACK_ZLARFT( &direct, &storev, &n, &k, v, &ldv, tau, t, &ldt );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to larft.
+//
+template< typename Value >
+struct larft_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixV, typename VectorTAU, typename MatrixT >
+ static std::ptrdiff_t invoke( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k, MatrixV& v,
+ const VectorTAU& tau, MatrixT& t ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixV >::type >::type,
+ typename remove_const< typename value<
+ VectorTAU >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixV >::type >::type,
+ typename remove_const< typename value<
+ MatrixT >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixV >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixT >::value) );
+ BOOST_ASSERT( direct == 'F' || direct == 'B' );
+ BOOST_ASSERT( k >= 1 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size(tau) >= k );
+ BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
+ BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
+ BOOST_ASSERT( storev == 'C' || storev == 'R' );
+ BOOST_ASSERT( stride_major(t) >= k );
+ return detail::larft( direct, storev, n, k, begin_value(v),
+ stride_major(v), begin_value(tau), begin_value(t),
+ stride_major(t) );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the larft_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for larft. Its overload differs for
+// * MatrixV&
+// * MatrixT&
+//
+template< typename MatrixV, typename VectorTAU, typename MatrixT >
+inline std::ptrdiff_t larft( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k, MatrixV& v,
+ const VectorTAU& tau, MatrixT& t ) {
+ return larft_impl< typename value< MatrixV >::type >::invoke( direct,
+ storev, n, k, v, tau, t );
+}
+
+//
+// Overloaded function for larft. Its overload differs for
+// * const MatrixV&
+// * MatrixT&
+//
+template< typename MatrixV, typename VectorTAU, typename MatrixT >
+inline std::ptrdiff_t larft( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k,
+ const MatrixV& v, const VectorTAU& tau, MatrixT& t ) {
+ return larft_impl< typename value< MatrixV >::type >::invoke( direct,
+ storev, n, k, v, tau, t );
+}
+
+//
+// Overloaded function for larft. Its overload differs for
+// * MatrixV&
+// * const MatrixT&
+//
+template< typename MatrixV, typename VectorTAU, typename MatrixT >
+inline std::ptrdiff_t larft( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k, MatrixV& v,
+ const VectorTAU& tau, const MatrixT& t ) {
+ return larft_impl< typename value< MatrixV >::type >::invoke( direct,
+ storev, n, k, v, tau, t );
+}
+
+//
+// Overloaded function for larft. Its overload differs for
+// * const MatrixV&
+// * const MatrixT&
+//
+template< typename MatrixV, typename VectorTAU, typename MatrixT >
+inline std::ptrdiff_t larft( const char direct, const char storev,
+ const fortran_int_t n, const fortran_int_t k,
+ const MatrixV& v, const VectorTAU& tau, const MatrixT& t ) {
+ return larft_impl< typename value< MatrixV >::type >::invoke( direct,
+ storev, n, k, v, tau, t );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfx.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,372 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFX_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFX_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for larfx is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t larfx( const char side, const fortran_int_t m,
+ const fortran_int_t n, const float* v, const float tau, float* c,
+ const fortran_int_t ldc, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLARFX( &side, &m, &n, v, &tau, c, &ldc, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t larfx( const char side, const fortran_int_t m,
+ const fortran_int_t n, const double* v, const double tau, double* c,
+ const fortran_int_t ldc, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLARFX( &side, &m, &n, v, &tau, c, &ldc, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t larfx( const char side, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<float>* v,
+ const std::complex<float> tau, std::complex<float>* c,
+ const fortran_int_t ldc, std::complex<float>* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLARFX( &side, &m, &n, v, &tau, c, &ldc, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t larfx( const char side, const fortran_int_t m,
+ const fortran_int_t n, const std::complex<double>* v,
+ const std::complex<double> tau, std::complex<double>* c,
+ const fortran_int_t ldc, std::complex<double>* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLARFX( &side, &m, &n, v, &tau, c, &ldc, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to larfx.
+//
+template< typename Value, typename Enable = void >
+struct larfx_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct larfx_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorV, typename MatrixC, typename WORK >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const real_type tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorV >::type >::type,
+ typename remove_const< typename value<
+ MatrixC >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
+ BOOST_ASSERT( stride_major(c) >= (ERROR) );
+ return detail::larfx( side, size_row(c), size_column(c),
+ begin_value(v), tau, begin_value(c), stride_major(c),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename VectorV, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const real_type tau, MatrixC& c, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( side, v, tau, c, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename VectorV, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const real_type tau, MatrixC& c, optimal_workspace work ) {
+ return invoke( side, v, tau, c, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct larfx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorV, typename MatrixC, typename WORK >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const value_type tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorV >::type >::type,
+ typename remove_const< typename value<
+ MatrixC >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
+ BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ size_row(c)) );
+ return detail::larfx( side, size_row(c), size_column(c),
+ begin_value(v), tau, begin_value(c), stride_major(c),
+ begin_value(work.select(value_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename VectorV, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const value_type tau, MatrixC& c, minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( side, v, tau, c, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename VectorV, typename MatrixC >
+ static std::ptrdiff_t invoke( const char side, const VectorV& v,
+ const value_type tau, MatrixC& c, optimal_workspace work ) {
+ return invoke( side, v, tau, c, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the larfx_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for larfx. Its overload differs for
+// * MatrixC&
+// * User-defined workspace
+//
+template< typename VectorV, typename MatrixC, typename Workspace >
+inline std::ptrdiff_t larfx( const char side, const VectorV& v,
+ const typename remove_imaginary< typename value<
+ VectorV >::type >::type tau, MatrixC& c, Workspace work ) {
+ return larfx_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, work );
+}
+
+//
+// Overloaded function for larfx. Its overload differs for
+// * MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename VectorV, typename MatrixC >
+inline std::ptrdiff_t larfx( const char side, const VectorV& v,
+ const typename remove_imaginary< typename value<
+ VectorV >::type >::type tau, MatrixC& c ) {
+ return larfx_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, optimal_workspace() );
+}
+
+//
+// Overloaded function for larfx. Its overload differs for
+// * const MatrixC&
+// * User-defined workspace
+//
+template< typename VectorV, typename MatrixC, typename Workspace >
+inline std::ptrdiff_t larfx( const char side, const VectorV& v,
+ const typename remove_imaginary< typename value<
+ VectorV >::type >::type tau, const MatrixC& c, Workspace work ) {
+ return larfx_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, work );
+}
+
+//
+// Overloaded function for larfx. Its overload differs for
+// * const MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename VectorV, typename MatrixC >
+inline std::ptrdiff_t larfx( const char side, const VectorV& v,
+ const typename remove_imaginary< typename value<
+ VectorV >::type >::type tau, const MatrixC& c ) {
+ return larfx_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, optimal_workspace() );
+}
+//
+// Overloaded function for larfx. Its overload differs for
+// * MatrixC&
+// * User-defined workspace
+//
+template< typename VectorV, typename MatrixC, typename Workspace >
+inline std::ptrdiff_t larfx( const char side, const VectorV& v,
+ const typename value< VectorV >::type tau, MatrixC& c,
+ Workspace work ) {
+ return larfx_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, work );
+}
+
+//
+// Overloaded function for larfx. Its overload differs for
+// * MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename VectorV, typename MatrixC >
+inline std::ptrdiff_t larfx( const char side, const VectorV& v,
+ const typename value< VectorV >::type tau, MatrixC& c ) {
+ return larfx_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, optimal_workspace() );
+}
+
+//
+// Overloaded function for larfx. Its overload differs for
+// * const MatrixC&
+// * User-defined workspace
+//
+template< typename VectorV, typename MatrixC, typename Workspace >
+inline std::ptrdiff_t larfx( const char side, const VectorV& v,
+ const typename value< VectorV >::type tau, const MatrixC& c,
+ Workspace work ) {
+ return larfx_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, work );
+}
+
+//
+// Overloaded function for larfx. Its overload differs for
+// * const MatrixC&
+// * Default workspace-type (optimal)
+//
+template< typename VectorV, typename MatrixC >
+inline std::ptrdiff_t larfx( const char side, const VectorV& v,
+ const typename value< VectorV >::type tau, const MatrixC& c ) {
+ return larfx_impl< typename value< VectorV >::type >::invoke( side,
+ v, tau, c, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/largv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/largv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,300 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARGV_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARGV_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for largv is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t largv( const fortran_int_t n, float* x,
+ const fortran_int_t incx, float* y, const fortran_int_t incy,
+ float* c, const fortran_int_t incc ) {
+ fortran_int_t info(0);
+ LAPACK_SLARGV( &n, x, &incx, y, &incy, c, &incc );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t largv( const fortran_int_t n, double* x,
+ const fortran_int_t incx, double* y, const fortran_int_t incy,
+ double* c, const fortran_int_t incc ) {
+ fortran_int_t info(0);
+ LAPACK_DLARGV( &n, x, &incx, y, &incy, c, &incc );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t largv( const fortran_int_t n, std::complex<float>* x,
+ const fortran_int_t incx, std::complex<float>* y,
+ const fortran_int_t incy, float* c, const fortran_int_t incc ) {
+ fortran_int_t info(0);
+ LAPACK_CLARGV( &n, x, &incx, y, &incy, c, &incc );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t largv( const fortran_int_t n, std::complex<double>* x,
+ const fortran_int_t incx, std::complex<double>* y,
+ const fortran_int_t incy, double* c, const fortran_int_t incc ) {
+ fortran_int_t info(0);
+ LAPACK_ZLARGV( &n, x, &incx, y, &incy, c, &incc );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to largv.
+//
+template< typename Value, typename Enable = void >
+struct largv_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct largv_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorX, typename VectorY, typename VectorC >
+ static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
+ VectorY& y, VectorC& c ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorX >::type >::type,
+ typename remove_const< typename value<
+ VectorY >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorX >::type >::type,
+ typename remove_const< typename value<
+ VectorC >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
+ BOOST_ASSERT( size(c) >= 1+(n-1)*stride(c) );
+ BOOST_ASSERT( size(x) >= 1+(n-1)*stride(x) );
+ BOOST_ASSERT( size(y) >= 1+(n-1)*stride(y) );
+ return detail::largv( n, begin_value(x), stride(x), begin_value(y),
+ stride(y), begin_value(c), stride(c) );
+ }
+
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct largv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorX, typename VectorY, typename VectorC >
+ static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
+ VectorY& y, VectorC& c ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorX >::type >::type,
+ typename remove_const< typename value<
+ VectorY >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
+ BOOST_ASSERT( size(c) >= 1+(n-1)*stride(c) );
+ BOOST_ASSERT( size(x) >= 1+(n-1)*stride(x) );
+ BOOST_ASSERT( size(y) >= 1+(n-1)*stride(y) );
+ return detail::largv( n, begin_value(x), stride(x), begin_value(y),
+ stride(y), begin_value(c), stride(c) );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the largv_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for largv. Its overload differs for
+// * VectorX&
+// * VectorY&
+// * VectorC&
+//
+template< typename VectorX, typename VectorY, typename VectorC >
+inline std::ptrdiff_t largv( const fortran_int_t n, VectorX& x,
+ VectorY& y, VectorC& c ) {
+ return largv_impl< typename value< VectorX >::type >::invoke( n, x,
+ y, c );
+}
+
+//
+// Overloaded function for largv. Its overload differs for
+// * const VectorX&
+// * VectorY&
+// * VectorC&
+//
+template< typename VectorX, typename VectorY, typename VectorC >
+inline std::ptrdiff_t largv( const fortran_int_t n, const VectorX& x,
+ VectorY& y, VectorC& c ) {
+ return largv_impl< typename value< VectorX >::type >::invoke( n, x,
+ y, c );
+}
+
+//
+// Overloaded function for largv. Its overload differs for
+// * VectorX&
+// * const VectorY&
+// * VectorC&
+//
+template< typename VectorX, typename VectorY, typename VectorC >
+inline std::ptrdiff_t largv( const fortran_int_t n, VectorX& x,
+ const VectorY& y, VectorC& c ) {
+ return largv_impl< typename value< VectorX >::type >::invoke( n, x,
+ y, c );
+}
+
+//
+// Overloaded function for largv. Its overload differs for
+// * const VectorX&
+// * const VectorY&
+// * VectorC&
+//
+template< typename VectorX, typename VectorY, typename VectorC >
+inline std::ptrdiff_t largv( const fortran_int_t n, const VectorX& x,
+ const VectorY& y, VectorC& c ) {
+ return largv_impl< typename value< VectorX >::type >::invoke( n, x,
+ y, c );
+}
+
+//
+// Overloaded function for largv. Its overload differs for
+// * VectorX&
+// * VectorY&
+// * const VectorC&
+//
+template< typename VectorX, typename VectorY, typename VectorC >
+inline std::ptrdiff_t largv( const fortran_int_t n, VectorX& x,
+ VectorY& y, const VectorC& c ) {
+ return largv_impl< typename value< VectorX >::type >::invoke( n, x,
+ y, c );
+}
+
+//
+// Overloaded function for largv. Its overload differs for
+// * const VectorX&
+// * VectorY&
+// * const VectorC&
+//
+template< typename VectorX, typename VectorY, typename VectorC >
+inline std::ptrdiff_t largv( const fortran_int_t n, const VectorX& x,
+ VectorY& y, const VectorC& c ) {
+ return largv_impl< typename value< VectorX >::type >::invoke( n, x,
+ y, c );
+}
+
+//
+// Overloaded function for largv. Its overload differs for
+// * VectorX&
+// * const VectorY&
+// * const VectorC&
+//
+template< typename VectorX, typename VectorY, typename VectorC >
+inline std::ptrdiff_t largv( const fortran_int_t n, VectorX& x,
+ const VectorY& y, const VectorC& c ) {
+ return largv_impl< typename value< VectorX >::type >::invoke( n, x,
+ y, c );
+}
+
+//
+// Overloaded function for largv. Its overload differs for
+// * const VectorX&
+// * const VectorY&
+// * const VectorC&
+//
+template< typename VectorX, typename VectorY, typename VectorC >
+inline std::ptrdiff_t largv( const fortran_int_t n, const VectorX& x,
+ const VectorY& y, const VectorC& c ) {
+ return largv_impl< typename value< VectorX >::type >::invoke( n, x,
+ y, c );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larnv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larnv.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,187 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARNV_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARNV_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for larnv is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t larnv( const fortran_int_t idist, fortran_int_t* iseed,
+ const fortran_int_t n, float* x ) {
+ fortran_int_t info(0);
+ LAPACK_SLARNV( &idist, iseed, &n, x );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t larnv( const fortran_int_t idist, fortran_int_t* iseed,
+ const fortran_int_t n, double* x ) {
+ fortran_int_t info(0);
+ LAPACK_DLARNV( &idist, iseed, &n, x );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t larnv( const fortran_int_t idist, fortran_int_t* iseed,
+ const fortran_int_t n, std::complex<float>* x ) {
+ fortran_int_t info(0);
+ LAPACK_CLARNV( &idist, iseed, &n, x );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t larnv( const fortran_int_t idist, fortran_int_t* iseed,
+ const fortran_int_t n, std::complex<double>* x ) {
+ fortran_int_t info(0);
+ LAPACK_ZLARNV( &idist, iseed, &n, x );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to larnv.
+//
+template< typename Value >
+struct larnv_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorISEED, typename VectorX >
+ static std::ptrdiff_t invoke( const fortran_int_t idist,
+ VectorISEED& iseed, const fortran_int_t n, VectorX& x ) {
+ BOOST_STATIC_ASSERT( (is_mutable< VectorISEED >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_ASSERT( size(iseed) >= 4 );
+ BOOST_ASSERT( size(x) >= n );
+ return detail::larnv( idist, begin_value(iseed), n, begin_value(x) );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the larnv_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for larnv. Its overload differs for
+// * VectorISEED&
+// * VectorX&
+//
+template< typename VectorISEED, typename VectorX >
+inline std::ptrdiff_t larnv( const fortran_int_t idist,
+ VectorISEED& iseed, const fortran_int_t n, VectorX& x ) {
+ return larnv_impl< typename value< VectorX >::type >::invoke( idist,
+ iseed, n, x );
+}
+
+//
+// Overloaded function for larnv. Its overload differs for
+// * const VectorISEED&
+// * VectorX&
+//
+template< typename VectorISEED, typename VectorX >
+inline std::ptrdiff_t larnv( const fortran_int_t idist,
+ const VectorISEED& iseed, const fortran_int_t n, VectorX& x ) {
+ return larnv_impl< typename value< VectorX >::type >::invoke( idist,
+ iseed, n, x );
+}
+
+//
+// Overloaded function for larnv. Its overload differs for
+// * VectorISEED&
+// * const VectorX&
+//
+template< typename VectorISEED, typename VectorX >
+inline std::ptrdiff_t larnv( const fortran_int_t idist,
+ VectorISEED& iseed, const fortran_int_t n, const VectorX& x ) {
+ return larnv_impl< typename value< VectorX >::type >::invoke( idist,
+ iseed, n, x );
+}
+
+//
+// Overloaded function for larnv. Its overload differs for
+// * const VectorISEED&
+// * const VectorX&
+//
+template< typename VectorISEED, typename VectorX >
+inline std::ptrdiff_t larnv( const fortran_int_t idist,
+ const VectorISEED& iseed, const fortran_int_t n,
+ const VectorX& x ) {
+ return larnv_impl< typename value< VectorX >::type >::invoke( idist,
+ iseed, n, x );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larrb.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larrb.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,619 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARRB_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARRB_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for larrb is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t larrb( const fortran_int_t n, const float* d,
+ const float* lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const float rtol1, const float rtol2,
+ const fortran_int_t offset, float* w, float* wgap, float* werr,
+ float* work, fortran_int_t* iwork, const float pivmin,
+ const float spdiam, const fortran_int_t twist ) {
+ fortran_int_t info(0);
+ LAPACK_SLARRB( &n, d, lld, &ifirst, &ilast, &rtol1, &rtol2, &offset, w,
+ wgap, werr, work, iwork, &pivmin, &spdiam, &twist, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t larrb( const fortran_int_t n, const double* d,
+ const double* lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const double rtol1, const double rtol2,
+ const fortran_int_t offset, double* w, double* wgap, double* werr,
+ double* work, fortran_int_t* iwork, const double pivmin,
+ const double spdiam, const fortran_int_t twist ) {
+ fortran_int_t info(0);
+ LAPACK_DLARRB( &n, d, lld, &ifirst, &ilast, &rtol1, &rtol2, &offset, w,
+ wgap, werr, work, iwork, &pivmin, &spdiam, &twist, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to larrb.
+//
+template< typename Value >
+struct larrb_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename WORK,
+ typename IWORK >
+ static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const real_type rtol1,
+ const real_type rtol2, const fortran_int_t offset, VectorW& w,
+ VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin,
+ const real_type spdiam, const fortran_int_t twist,
+ detail::workspace2< WORK, IWORK > work ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorLLD >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorW >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorWGAP >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorWERR >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorWGAP >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorWERR >::value) );
+ BOOST_ASSERT( size(d) >= n );
+ BOOST_ASSERT( size(lld) >= n-1 );
+ BOOST_ASSERT( size(w) >= n );
+ BOOST_ASSERT( size(werr) >= n );
+ BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ min_size_iwork( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ return detail::larrb( n, begin_value(d), begin_value(lld), ifirst,
+ ilast, rtol1, rtol2, offset, begin_value(w),
+ begin_value(wgap), begin_value(werr),
+ begin_value(work.select(real_type())),
+ begin_value(work.select(fortran_int_t())), pivmin, spdiam,
+ twist );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+ static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const real_type rtol1,
+ const real_type rtol2, const fortran_int_t offset, VectorW& w,
+ VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin,
+ const real_type spdiam, const fortran_int_t twist,
+ minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ bindings::detail::array< fortran_int_t > tmp_iwork(
+ min_size_iwork( n ) );
+ return invoke( n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w,
+ wgap, werr, pivmin, spdiam, twist, workspace( tmp_work,
+ tmp_iwork ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+ static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const real_type rtol1,
+ const real_type rtol2, const fortran_int_t offset, VectorW& w,
+ VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin,
+ const real_type spdiam, const fortran_int_t twist,
+ optimal_workspace work ) {
+ return invoke( n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w,
+ wgap, werr, pivmin, spdiam, twist, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 2*n;
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array iwork.
+ //
+ static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) {
+ return 2*n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the larrb_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * VectorW&
+// * VectorWGAP&
+// * VectorWERR&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename Workspace >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ VectorW& w, VectorWGAP& wgap, VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist, Workspace work ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, work );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * VectorW&
+// * VectorWGAP&
+// * VectorWERR&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ VectorW& w, VectorWGAP& wgap, VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, optimal_workspace() );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * const VectorW&
+// * VectorWGAP&
+// * VectorWERR&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename Workspace >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ const VectorW& w, VectorWGAP& wgap, VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist, Workspace work ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, work );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * const VectorW&
+// * VectorWGAP&
+// * VectorWERR&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ const VectorW& w, VectorWGAP& wgap, VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, optimal_workspace() );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * VectorW&
+// * const VectorWGAP&
+// * VectorWERR&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename Workspace >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ VectorW& w, const VectorWGAP& wgap, VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist, Workspace work ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, work );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * VectorW&
+// * const VectorWGAP&
+// * VectorWERR&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ VectorW& w, const VectorWGAP& wgap, VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, optimal_workspace() );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * const VectorW&
+// * const VectorWGAP&
+// * VectorWERR&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename Workspace >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ const VectorW& w, const VectorWGAP& wgap, VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist, Workspace work ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, work );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * const VectorW&
+// * const VectorWGAP&
+// * VectorWERR&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ const VectorW& w, const VectorWGAP& wgap, VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, optimal_workspace() );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * VectorW&
+// * VectorWGAP&
+// * const VectorWERR&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename Workspace >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ VectorW& w, VectorWGAP& wgap, const VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist, Workspace work ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, work );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * VectorW&
+// * VectorWGAP&
+// * const VectorWERR&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ VectorW& w, VectorWGAP& wgap, const VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, optimal_workspace() );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * const VectorW&
+// * VectorWGAP&
+// * const VectorWERR&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename Workspace >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ const VectorW& w, VectorWGAP& wgap, const VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist, Workspace work ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, work );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * const VectorW&
+// * VectorWGAP&
+// * const VectorWERR&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ const VectorW& w, VectorWGAP& wgap, const VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, optimal_workspace() );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * VectorW&
+// * const VectorWGAP&
+// * const VectorWERR&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename Workspace >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ VectorW& w, const VectorWGAP& wgap, const VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist, Workspace work ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, work );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * VectorW&
+// * const VectorWGAP&
+// * const VectorWERR&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ VectorW& w, const VectorWGAP& wgap, const VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, optimal_workspace() );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * const VectorW&
+// * const VectorWGAP&
+// * const VectorWERR&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR, typename Workspace >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ const VectorW& w, const VectorWGAP& wgap, const VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist, Workspace work ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, work );
+}
+
+//
+// Overloaded function for larrb. Its overload differs for
+// * const VectorW&
+// * const VectorWGAP&
+// * const VectorWERR&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorLLD, typename VectorW,
+ typename VectorWGAP, typename VectorWERR >
+inline std::ptrdiff_t larrb( const fortran_int_t n, const VectorD& d,
+ const VectorLLD& lld, const fortran_int_t ifirst,
+ const fortran_int_t ilast, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const fortran_int_t offset,
+ const VectorW& w, const VectorWGAP& wgap, const VectorWERR& werr,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type pivmin, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spdiam,
+ const fortran_int_t twist ) {
+ return larrb_impl< typename value< VectorD >::type >::invoke( n, d,
+ lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin,
+ spdiam, twist, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larre.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larre.hpp 2010-01-12 05:22:44 EST (Tue, 12 Jan 2010)
@@ -0,0 +1,80114 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARRE_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARRE_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for larre is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ float& vl, float& vu, const fortran_int_t il, const fortran_int_t iu,
+ float* d, float* e, float* e2, const float rtol1, const float rtol2,
+ const float spltol, fortran_int_t& nsplit, fortran_int_t* isplit,
+ fortran_int_t& m, float* w, float* werr, float* wgap,
+ fortran_int_t* iblock, fortran_int_t* indexw, float* gers,
+ float& pivmin, float* work, fortran_int_t* iwork ) {
+ fortran_int_t info(0);
+ LAPACK_SLARRE( &range, &n, &vl, &vu, &il, &iu, d, e, e2, &rtol1, &rtol2,
+ &spltol, &nsplit, isplit, &m, w, werr, wgap, iblock, indexw, gers,
+ &pivmin, work, iwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ double& vl, double& vu, const fortran_int_t il,
+ const fortran_int_t iu, double* d, double* e, double* e2,
+ const double rtol1, const double rtol2, const double spltol,
+ fortran_int_t& nsplit, fortran_int_t* isplit, fortran_int_t& m,
+ double* w, double* werr, double* wgap, fortran_int_t* iblock,
+ fortran_int_t* indexw, double* gers, double& pivmin, double* work,
+ fortran_int_t* iwork ) {
+ fortran_int_t info(0);
+ LAPACK_DLARRE( &range, &n, &vl, &vu, &il, &iu, d, e, e2, &rtol1, &rtol2,
+ &spltol, &nsplit, isplit, &m, w, werr, wgap, iblock, indexw, gers,
+ &pivmin, work, iwork, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to larre.
+//
+template< typename Value >
+struct larre_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename WORK, typename IWORK >
+ static std::ptrdiff_t invoke( const char range, const fortran_int_t n,
+ real_type& vl, real_type& vu, const fortran_int_t il,
+ const fortran_int_t iu, VectorD& d, VectorE& e, VectorE2& e2,
+ const real_type rtol1, const real_type rtol2,
+ const real_type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin,
+ detail::workspace2< WORK, IWORK > work ) {
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorE >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorE2 >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorW >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorWERR >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorWGAP >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorGERS >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorISPLIT >::type >::type,
+ typename remove_const< typename value<
+ VectorIBLOCK >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorISPLIT >::type >::type,
+ typename remove_const< typename value<
+ VectorINDEXW >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorE2 >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorISPLIT >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorWERR >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorWGAP >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorIBLOCK >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorINDEXW >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorGERS >::value) );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( size(d) >= n );
+ BOOST_ASSERT( size(e) >= n );
+ BOOST_ASSERT( size(e2) >= n );
+ BOOST_ASSERT( size(gers) >= 2*n );
+ BOOST_ASSERT( size(indexw) >= n );
+ BOOST_ASSERT( size(isplit) >= n );
+ BOOST_ASSERT( size(w) >= n );
+ BOOST_ASSERT( size(werr) >= n );
+ BOOST_ASSERT( size(wgap) >= n );
+ BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ min_size_iwork( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ return detail::larre( range, n, vl, vu, il, iu, begin_value(d),
+ begin_value(e), begin_value(e2), rtol1, rtol2, spltol, nsplit,
+ begin_value(isplit), m, begin_value(w), begin_value(werr),
+ begin_value(wgap), begin_value(iblock), begin_value(indexw),
+ begin_value(gers), pivmin,
+ begin_value(work.select(real_type())),
+ begin_value(work.select(fortran_int_t())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+ static std::ptrdiff_t invoke( const char range, const fortran_int_t n,
+ real_type& vl, real_type& vu, const fortran_int_t il,
+ const fortran_int_t iu, VectorD& d, VectorE& e, VectorE2& e2,
+ const real_type rtol1, const real_type rtol2,
+ const real_type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin,
+ minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ bindings::detail::array< fortran_int_t > tmp_iwork(
+ min_size_iwork( n ) );
+ return invoke( range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2,
+ spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw,
+ gers, pivmin, workspace( tmp_work, tmp_iwork ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+ static std::ptrdiff_t invoke( const char range, const fortran_int_t n,
+ real_type& vl, real_type& vu, const fortran_int_t il,
+ const fortran_int_t iu, VectorD& d, VectorE& e, VectorE2& e2,
+ const real_type rtol1, const real_type rtol2,
+ const real_type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin,
+ optimal_workspace work ) {
+ return invoke( range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2,
+ spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw,
+ gers, pivmin, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 6*n;
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array iwork.
+ //
+ static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) {
+ return 5*n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the larre_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, const VectorWERR& werr, VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, const VectorWERR& werr,
+ VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * const VectorWERR&
+// * VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ const VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ const VectorW& w, VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, const VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, const VectorISPLIT& isplit,
+ fortran_int_t& m, const VectorW& w, VectorWERR& werr,
+ const VectorWGAP& wgap, VectorIBLOCK& iblock, VectorINDEXW& indexw,
+ VectorGERS& gers, typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+// * const VectorE2&
+// * const VectorISPLIT&
+// * const VectorW&
+// * VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, const VectorE& e, const VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ const VectorISPLIT& isplit, fortran_int_t& m, const VectorW& w,
+ VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * const VectorD&
+// * VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const VectorD& d, VectorE& e, VectorE2& e2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol1, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol2,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type spltol, fortran_int_t& nsplit,
+ VectorISPLIT& isplit, fortran_int_t& m, VectorW& w,
+ const VectorWERR& werr, const VectorWGAP& wgap, VectorIBLOCK& iblock,
+ VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary<
+ typename value< VectorD >::type >::type& pivmin ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin,
+ optimal_workspace() );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW,
+ typename VectorGERS, typename Workspace >
+inline std::ptrdiff_t larre( const char range, const fortran_int_t n,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& vl, typename remove_imaginary<
+ typename value< VectorD >::type >::type& vu,
+ const fortran_int_t il, const fortran_int_t iu, VectorD& d,
+ const VectorE& e, VectorE2& e2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type rtol1,
+ const typename remove_imaginary< typename value<
+ VectorD >::type >::type rtol2, const typename remove_imaginary<
+ typename value< VectorD >::type >::type spltol,
+ fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m,
+ VectorW& w, const VectorWERR& werr, const VectorWGAP& wgap,
+ VectorIBLOCK& iblock, VectorINDEXW& indexw, VectorGERS& gers,
+ typename remove_imaginary< typename value<
+ VectorD >::type >::type& pivmin, Workspace work ) {
+ return larre_impl< typename value< VectorD >::type >::invoke( range,
+ n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit,
+ m, w, werr, wgap, iblock, indexw, gers, pivmin, work );
+}
+
+//
+// Overloaded function for larre. Its overload differs for
+// * VectorD&
+// * const VectorE&
+// * VectorE2&
+// * VectorISPLIT&
+// * VectorW&
+// * const VectorWERR&
+// * const VectorWGAP&
+// * VectorIBLOCK&
+// * VectorINDEXW&
+// * VectorGERS&
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorISPLIT, typename VectorW, typename VectorWERR,
+ typenam