Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r56293 - in sandbox/numeric_bindings/boost/numeric/bindings: blas/level1 blas/level2 blas/level3 lapack lapack/computational lapack/driver
From: rutger_at_[hidden]
Date: 2009-09-18 05:41:23


Author: rutger
Date: 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
New Revision: 56293
URL: http://svn.boost.org/trac/boost/changeset/56293

Log:
minor update(s)

Removed:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/keywords.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/solve.hpp
Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/drot.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/srot.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp | 4
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp | 76 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp | 86 ++++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp | 70 +++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp | 68 +++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp | 96 +++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp | 68 +++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebak.hpp | 62 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebal.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp | 65 ++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp | 60 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp | 56 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp | 62 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp | 58 ++++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp | 58 ++++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp | 62 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp | 58 ++++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp | 94 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp | 58 ++++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp | 60 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp | 66 +++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp | 70 +++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp | 77 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp | 76 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp | 76 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp | 114 ++++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp | 110 +++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp | 76 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp | 34 +++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp | 58 +++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp | 38 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp | 32 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp | 32 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp | 100 ++++++++++++++++--------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp | 54 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp | 34 +++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp | 96 +++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp | 78 +++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp | 72 +++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp | 46 ++++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp | 49 +++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp | 64 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp | 56 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp | 68 +++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp | 28 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp | 30 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp | 31 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp | 30 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp | 30 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp | 30 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp | 30 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp | 28 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp | 39 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp | 39 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp | 39 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp | 39 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp | 39 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp | 62 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp | 90 ++++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp | 42 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp | 42 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp | 58 ++++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp | 60 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp | 49 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp | 88 ++++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp | 42 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp | 42 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp | 56 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp | 82 +++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp | 86 +++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp | 88 ++++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp | 56 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp | 70 +++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp | 87 ++++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp | 70 +++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stemr.hpp | 95 +++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp | 22 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp | 62 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp | 28 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp | 94 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp | 28 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp | 60 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp | 66 +++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp | 92 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp | 70 +++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp | 93 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp | 78 +++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp | 118 ++++++++++++++++++-----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp | 112 ++++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp | 102 ++++++++++++++++--------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp | 112 +++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp | 83 +++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp | 42 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp | 56 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp | 62 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp | 79 +++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp | 58 +++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp | 85 +++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp | 93 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp | 78 ++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp | 42 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp | 65 ++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp | 58 ++++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp | 38 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp | 50 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp | 50 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp | 48 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp | 29 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp | 28 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp | 60 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp | 109 +++++++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp | 81 ++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp | 94 +++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp | 81 +++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp | 104 ++++++++++++++++--------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp | 92 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp | 70 +++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp | 78 ++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp | 75 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp | 76 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp | 77 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp | 76 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp | 96 +++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp | 110 ++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp | 126 +++++++++++++++++++------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp | 92 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp | 131 ++++++++++++++++++++-------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp | 78 +++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp | 78 +++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp | 109 +++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp | 57 +++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp | 111 +++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp | 48 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp | 58 +++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp | 46 +++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp | 56 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp | 66 ++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp | 60 ++++++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp | 54 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp | 48 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp | 63 ++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp | 56 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp | 49 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp | 40 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp | 57 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp | 32 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp | 54 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp | 24 ++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp | 75 ++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp | 51 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp | 97 +++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp | 92 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp | 85 ++++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp | 50 ++++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp | 85 ++++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp | 30 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp | 37 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp | 41 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp | 54 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp | 21 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp | 28 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp | 42 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp | 30 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp | 38 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sposv.hpp | 22 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp | 54 +++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp | 88 ++++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp | 25 ++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp | 33 +++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp | 44 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp | 42 +++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp | 28 +++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp | 52 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp | 45 +++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp | 36 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp | 38 ++++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp | 53 ++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp | 70 +++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp | 97 +++++++++++++++--------------
   283 files changed, 7578 insertions(+), 6236 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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -48,7 +48,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef value_type return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX >
     static return_type invoke( const VectorX& x ) {
         return detail::asum( traits::vector_size(x),
@@ -56,7 +56,7 @@
     }
 };
 
-// generic template function for calling to asum
+// generic template function to call asum
 template< typename VectorX >
 inline typename asum_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -63,7 +63,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY >
     static return_type invoke( const value_type a, const VectorX& x,
             VectorY& y ) {
@@ -76,7 +76,7 @@
     }
 };
 
-// generic template function for calling to axpy
+// generic template function to call axpy
 template< typename VectorX, typename VectorY >
 inline typename axpy_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -63,7 +63,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, const VectorY& y ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -75,7 +75,7 @@
     }
 };
 
-// generic template function for calling to copy
+// generic template function to call copy
 template< typename VectorX, typename VectorY >
 inline typename copy_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -49,7 +49,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef value_type return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, const VectorY& y ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -61,7 +61,7 @@
     }
 };
 
-// generic template function for calling to dot
+// generic template function to call dot
 template< typename VectorX, typename VectorY >
 inline typename dot_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -53,7 +53,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef value_type return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, const VectorY& y ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -65,7 +65,7 @@
     }
 };
 
-// generic template function for calling to dotc
+// generic template function to call dotc
 template< typename VectorX, typename VectorY >
 inline typename dotc_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -53,7 +53,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef value_type return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, const VectorY& y ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -65,7 +65,7 @@
     }
 };
 
-// generic template function for calling to dotu
+// generic template function to call dotu
 template< typename VectorX, typename VectorY >
 inline typename dotu_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/drot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/drot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/drot.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -46,7 +46,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorCX, typename VectorCY >
     static return_type invoke( const integer_t n, const VectorCX& cx,
             const VectorCY& cy, const real_type c, const real_type s ) {
@@ -59,7 +59,7 @@
     }
 };
 
-// generic template function for calling to drot
+// generic template function to call drot
 template< typename VectorCX, typename VectorCY >
 inline typename drot_impl< typename traits::vector_traits<
         VectorCX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -48,7 +48,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef value_type return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX >
     static return_type invoke( const VectorX& x ) {
         return detail::nrm2( traits::vector_size(x),
@@ -56,7 +56,7 @@
     }
 };
 
-// generic template function for calling to nrm2
+// generic template function to call nrm2
 template< typename VectorX >
 inline typename nrm2_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -49,7 +49,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, VectorY& y,
             const real_type c, const real_type s ) {
@@ -62,7 +62,7 @@
     }
 };
 
-// generic template function for calling to rot
+// generic template function to call rot
 template< typename VectorX, typename VectorY >
 inline typename rot_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -59,7 +59,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< >
     static return_type invoke( value_type& a, value_type& b, real_type& c,
             value_type& s ) {
@@ -67,7 +67,7 @@
     }
 };
 
-// generic template function for calling to rotg
+// generic template function to call rotg
 template< >
 inline typename rotg_impl< typename traits::TODO_traits<
         TODO >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -49,7 +49,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY, typename VectorPARAM >
     static return_type invoke( const integer_t n, VectorX& x,
             const integer_t incx, VectorY& y, const integer_t incy,
@@ -66,7 +66,7 @@
     }
 };
 
-// generic template function for calling to rotm
+// generic template function to call rotm
 template< typename VectorX, typename VectorY, typename VectorPARAM >
 inline typename rotm_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -49,7 +49,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorDPARAM >
     static return_type invoke( real_type& d1, real_type& d2, real_type& x1,
             const real_type y1, VectorDPARAM& dparam ) {
@@ -57,7 +57,7 @@
     }
 };
 
-// generic template function for calling to rotmg
+// generic template function to call rotmg
 template< typename VectorDPARAM >
 inline typename rotmg_impl< typename traits::vector_traits<
         VectorDPARAM >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -59,7 +59,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX >
     static return_type invoke( const value_type a, const VectorX& x ) {
         detail::scal( traits::vector_size(x), a,
@@ -67,7 +67,7 @@
     }
 };
 
-// generic template function for calling to scal
+// generic template function to call scal
 template< typename VectorX >
 inline typename scal_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -44,7 +44,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef value_type return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorSX, typename VectorSY >
     static return_type invoke( const integer_t n, const VectorSX& sx,
             const integer_t incx, const VectorSY& sy, const integer_t incy ) {
@@ -56,7 +56,7 @@
     }
 };
 
-// generic template function for calling to sdot
+// generic template function to call sdot
 template< typename VectorSX, typename VectorSY >
 inline typename sdot_impl< typename traits::vector_traits<
         VectorSX >::value_type >::return_type

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/srot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/srot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/srot.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -46,7 +46,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorCX, typename VectorCY >
     static return_type invoke( const integer_t n, const VectorCX& cx,
             const VectorCY& cy, const real_type c, const real_type s ) {
@@ -59,7 +59,7 @@
     }
 };
 
-// generic template function for calling to srot
+// generic template function to call srot
 template< typename VectorCX, typename VectorCY >
 inline typename srot_impl< typename traits::vector_traits<
         VectorCX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -61,7 +61,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY >
     static return_type invoke( VectorX& x, VectorY& y ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -73,7 +73,7 @@
     }
 };
 
-// generic template function for calling to swap
+// generic template function to call swap
 template< typename VectorX, typename VectorY >
 inline typename swap_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -79,7 +79,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const char trans, const integer_t kl,
             const integer_t ku, const value_type alpha, const MatrixA& a,
@@ -98,7 +98,7 @@
     }
 };
 
-// generic template function for calling to gbmv
+// generic template function to call gbmv
 template< typename MatrixA, typename VectorX, typename VectorY >
 inline typename gbmv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -80,7 +80,7 @@
         invoke( );
     }
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const char trans, const value_type alpha,
             const MatrixA& a, const VectorX& x, const value_type beta,
@@ -99,7 +99,7 @@
     }
 };
 
-// generic template function for calling to gemv
+// generic template function to call gemv
 template< typename MatrixA, typename VectorX, typename VectorY >
 inline typename gemv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -51,7 +51,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
@@ -69,7 +69,7 @@
     }
 };
 
-// generic template function for calling to ger
+// generic template function to call ger
 template< typename VectorX, typename VectorY, typename MatrixA >
 inline typename ger_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -57,7 +57,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
@@ -75,7 +75,7 @@
     }
 };
 
-// generic template function for calling to gerc
+// generic template function to call gerc
 template< typename VectorX, typename VectorY, typename MatrixA >
 inline typename gerc_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -57,7 +57,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
@@ -75,7 +75,7 @@
     }
 };
 
-// generic template function for calling to geru
+// generic template function to call geru
 template< typename VectorX, typename VectorY, typename MatrixA >
 inline typename geru_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -59,7 +59,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const integer_t k, const value_type alpha,
             const MatrixA& a, const VectorX& x, const value_type beta,
@@ -78,7 +78,7 @@
     }
 };
 
-// generic template function for calling to hbmv
+// generic template function to call hbmv
 template< typename MatrixA, typename VectorX, typename VectorY >
 inline typename hbmv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -59,7 +59,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const VectorX& x, const value_type beta, VectorY& y ) {
@@ -77,7 +77,7 @@
     }
 };
 
-// generic template function for calling to hemv
+// generic template function to call hemv
 template< typename MatrixA, typename VectorX, typename VectorY >
 inline typename hemv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -53,7 +53,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixA& a ) {
@@ -67,7 +67,7 @@
     }
 };
 
-// generic template function for calling to her
+// generic template function to call her
 template< typename VectorX, typename MatrixA >
 inline typename her_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -57,7 +57,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
@@ -75,7 +75,7 @@
     }
 };
 
-// generic template function for calling to her2
+// generic template function to call her2
 template< typename VectorX, typename VectorY, typename MatrixA >
 inline typename her2_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -59,7 +59,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixAP, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixAP& ap,
             const VectorX& x, const value_type beta, VectorY& y ) {
@@ -77,7 +77,7 @@
     }
 };
 
-// generic template function for calling to hpmv
+// generic template function to call hpmv
 template< typename MatrixAP, typename VectorX, typename VectorY >
 inline typename hpmv_impl< typename traits::matrix_traits<
         MatrixAP >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -53,7 +53,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixAP& ap ) {
@@ -67,7 +67,7 @@
     }
 };
 
-// generic template function for calling to hpr
+// generic template function to call hpr
 template< typename VectorX, typename MatrixAP >
 inline typename hpr_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -57,7 +57,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY, typename MatrixAP >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixAP& ap ) {
@@ -75,7 +75,7 @@
     }
 };
 
-// generic template function for calling to hpr2
+// generic template function to call hpr2
 template< typename VectorX, typename VectorY, typename MatrixAP >
 inline typename hpr2_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -53,7 +53,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const integer_t k, const real_type alpha,
             const MatrixA& a, const VectorX& x, const real_type beta,
@@ -72,7 +72,7 @@
     }
 };
 
-// generic template function for calling to sbmv
+// generic template function to call sbmv
 template< typename MatrixA, typename VectorX, typename VectorY >
 inline typename sbmv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -51,7 +51,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixAP, typename VectorX, typename VectorY >
     static return_type invoke( const real_type alpha, const MatrixAP& ap,
             const VectorX& x, const real_type beta, VectorY& y ) {
@@ -69,7 +69,7 @@
     }
 };
 
-// generic template function for calling to spmv
+// generic template function to call spmv
 template< typename MatrixAP, typename VectorX, typename VectorY >
 inline typename spmv_impl< typename traits::matrix_traits<
         MatrixAP >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -49,7 +49,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixAP& ap ) {
@@ -63,7 +63,7 @@
     }
 };
 
-// generic template function for calling to spr
+// generic template function to call spr
 template< typename VectorX, typename MatrixAP >
 inline typename spr_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -51,7 +51,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixAP& ap ) {
@@ -69,7 +69,7 @@
     }
 };
 
-// generic template function for calling to spr2
+// generic template function to call spr2
 template< typename VectorX, typename VectorY, typename MatrixAP >
 inline typename spr2_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -53,7 +53,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const real_type alpha, const MatrixA& a,
             const VectorX& x, const real_type beta, VectorY& y ) {
@@ -71,7 +71,7 @@
     }
 };
 
-// generic template function for calling to symv
+// generic template function to call symv
 template< typename MatrixA, typename VectorX, typename VectorY >
 inline typename symv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -50,7 +50,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixA& a ) {
@@ -64,7 +64,7 @@
     }
 };
 
-// generic template function for calling to syr
+// generic template function to call syr
 template< typename VectorX, typename MatrixA >
 inline typename syr_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -51,7 +51,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
@@ -69,7 +69,7 @@
     }
 };
 
-// generic template function for calling to syr2
+// generic template function to call syr2
 template< typename VectorX, typename VectorY, typename MatrixA >
 inline typename syr2_impl< typename traits::vector_traits<
         VectorX >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -65,7 +65,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const char trans, const char diag,
             const integer_t k, const MatrixA& a, VectorX& x ) {
@@ -79,7 +79,7 @@
     }
 };
 
-// generic template function for calling to tbmv
+// generic template function to call tbmv
 template< typename MatrixA, typename VectorX >
 inline typename tbmv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -65,7 +65,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const char trans, const char diag,
             const integer_t k, const MatrixA& a, VectorX& x ) {
@@ -79,7 +79,7 @@
     }
 };
 
-// generic template function for calling to tbsv
+// generic template function to call tbsv
 template< typename MatrixA, typename VectorX >
 inline typename tbsv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -64,7 +64,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixAP, typename VectorX >
     static return_type invoke( const char trans, const char diag,
             const MatrixAP& ap, VectorX& x ) {
@@ -77,7 +77,7 @@
     }
 };
 
-// generic template function for calling to tpmv
+// generic template function to call tpmv
 template< typename MatrixAP, typename VectorX >
 inline typename tpmv_impl< typename traits::matrix_traits<
         MatrixAP >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -64,7 +64,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixAP, typename VectorX >
     static return_type invoke( const char trans, const char diag,
             const MatrixAP& ap, VectorX& x ) {
@@ -77,7 +77,7 @@
     }
 };
 
-// generic template function for calling to tpsv
+// generic template function to call tpsv
 template< typename MatrixAP, typename VectorX >
 inline typename tpsv_impl< typename traits::matrix_traits<
         MatrixAP >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -65,7 +65,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const char trans, const char diag,
             const MatrixA& a, VectorX& x ) {
@@ -79,7 +79,7 @@
     }
 };
 
-// generic template function for calling to trmv
+// generic template function to call trmv
 template< typename MatrixA, typename VectorX >
 inline typename trmv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -65,7 +65,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const char trans, const char diag,
             const MatrixA& a, VectorX& x ) {
@@ -79,7 +79,7 @@
     }
 };
 
-// generic template function for calling to trsv
+// generic template function to call trsv
 template< typename MatrixA, typename VectorX >
 inline typename trsv_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -79,7 +79,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const char transa, const char transb,
             const value_type alpha, const MatrixA& a, const MatrixB& b,
@@ -100,7 +100,7 @@
     }
 };
 
-// generic template function for calling to gemm
+// generic template function to call gemm
 template< typename MatrixA, typename MatrixB, typename MatrixC >
 inline typename gemm_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -61,7 +61,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, const MatrixB& b, const value_type beta,
@@ -81,7 +81,7 @@
     }
 };
 
-// generic template function for calling to hemm
+// generic template function to call hemm
 template< typename MatrixA, typename MatrixB, typename MatrixC >
 inline typename hemm_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -59,7 +59,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const char trans, const value_type alpha,
             const MatrixA& a, const MatrixB& b, const real_type beta,
@@ -80,7 +80,7 @@
     }
 };
 
-// generic template function for calling to her2k
+// generic template function to call her2k
 template< typename MatrixA, typename MatrixB, typename MatrixC >
 inline typename her2k_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -55,7 +55,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixC >
     static return_type invoke( const char trans, const real_type alpha,
             const MatrixA& a, const real_type beta, MatrixC& c ) {
@@ -71,7 +71,7 @@
     }
 };
 
-// generic template function for calling to herk
+// generic template function to call herk
 template< typename MatrixA, typename MatrixC >
 inline typename herk_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -77,7 +77,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, const MatrixB& b, const value_type beta,
@@ -97,7 +97,7 @@
     }
 };
 
-// generic template function for calling to symm
+// generic template function to call symm
 template< typename MatrixA, typename MatrixB, typename MatrixC >
 inline typename symm_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -77,7 +77,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const char trans, const value_type alpha,
             const MatrixA& a, const MatrixB& b, const value_type beta,
@@ -98,7 +98,7 @@
     }
 };
 
-// generic template function for calling to syr2k
+// generic template function to call syr2k
 template< typename MatrixA, typename MatrixB, typename MatrixC >
 inline typename syr2k_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -73,7 +73,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixC >
     static return_type invoke( const char trans, const value_type alpha,
             const MatrixA& a, const value_type beta, MatrixC& c ) {
@@ -89,7 +89,7 @@
     }
 };
 
-// generic template function for calling to syrk
+// generic template function to call syrk
 template< typename MatrixA, typename MatrixC >
 inline typename syrk_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -73,7 +73,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixB >
     static return_type invoke( const char side, const char transa,
             const char diag, const value_type alpha, const MatrixA& a,
@@ -89,7 +89,7 @@
     }
 };
 
-// generic template function for calling to trmm
+// generic template function to call trmm
 template< typename MatrixA, typename MatrixB >
 inline typename trmm_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

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 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -73,7 +73,7 @@
     typedef typename traits::type_traits<ValueType>::real_type real_type;
     typedef void return_type;
 
- // templated specialization
+ // static template member function
     template< typename MatrixA, typename MatrixB >
     static return_type invoke( const char side, const char transa,
             const char diag, const value_type alpha, const MatrixA& a,
@@ -89,7 +89,7 @@
     }
 };
 
-// generic template function for calling to trsm
+// generic template function to call trsm
 template< typename MatrixA, typename MatrixB >
 inline typename trsm_impl< typename traits::matrix_traits<
         MatrixA >::value_type >::return_type

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,22 +33,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void bdsdc( const char uplo, const char compq, const integer_t n,
- float* d, float* e, float* u, const integer_t ldu, float* vt,
- const integer_t ldvt, float* q, integer_t* iq, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SBDSDC( &uplo, &compq, &n, d, e, u, &ldu, vt, &ldvt, q, iq,
- work, iwork, &info );
- }
- inline void bdsdc( const char uplo, const char compq, const integer_t n,
- double* d, double* e, double* u, const integer_t ldu, double* vt,
- const integer_t ldvt, double* q, integer_t* iq, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DBDSDC( &uplo, &compq, &n, d, e, u, &ldu, vt, &ldvt, q, iq,
- work, iwork, &info );
- }
+
+inline void bdsdc( const char uplo, const char compq, const integer_t n,
+ float* d, float* e, float* u, const integer_t ldu, float* vt,
+ const integer_t ldvt, float* q, integer_t* iq, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_SBDSDC( &uplo, &compq, &n, d, e, u, &ldu, vt, &ldvt, q, iq, work,
+ iwork, &info );
 }
 
+inline void bdsdc( const char uplo, const char compq, const integer_t n,
+ double* d, double* e, double* u, const integer_t ldu, double* vt,
+ const integer_t ldvt, double* q, integer_t* iq, double* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_DBDSDC( &uplo, &compq, &n, d, e, u, &ldu, vt, &ldvt, q, iq, work,
+ iwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct bdsdc_impl {
@@ -157,6 +160,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,42 +36,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void bdsqr( const char uplo, const integer_t n,
- const integer_t ncvt, const integer_t nru, const integer_t ncc,
- float* d, float* e, float* vt, const integer_t ldvt, float* u,
- const integer_t ldu, float* c, const integer_t ldc, float* work,
- integer_t& info ) {
- LAPACK_SBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu,
- c, &ldc, work, &info );
- }
- inline void bdsqr( const char uplo, const integer_t n,
- const integer_t ncvt, const integer_t nru, const integer_t ncc,
- double* d, double* e, double* vt, const integer_t ldvt, double* u,
- const integer_t ldu, double* c, const integer_t ldc, double* work,
- integer_t& info ) {
- LAPACK_DBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu,
- c, &ldc, work, &info );
- }
- inline void bdsqr( const char uplo, const integer_t n,
- const integer_t ncvt, const integer_t nru, const integer_t ncc,
- float* d, float* e, traits::complex_f* vt, const integer_t ldvt,
- traits::complex_f* u, const integer_t ldu, traits::complex_f* c,
- const integer_t ldc, float* rwork, integer_t& info ) {
- LAPACK_CBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e,
- traits::complex_ptr(vt), &ldvt, traits::complex_ptr(u), &ldu,
- traits::complex_ptr(c), &ldc, rwork, &info );
- }
- inline void bdsqr( const char uplo, const integer_t n,
- const integer_t ncvt, const integer_t nru, const integer_t ncc,
- double* d, double* e, traits::complex_d* vt, const integer_t ldvt,
- traits::complex_d* u, const integer_t ldu, traits::complex_d* c,
- const integer_t ldc, double* rwork, integer_t& info ) {
- LAPACK_ZBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e,
- traits::complex_ptr(vt), &ldvt, traits::complex_ptr(u), &ldu,
- traits::complex_ptr(c), &ldc, rwork, &info );
- }
+
+inline void bdsqr( const char uplo, const integer_t n, const integer_t ncvt,
+ const integer_t nru, const integer_t ncc, float* d, float* e,
+ float* vt, const integer_t ldvt, float* u, const integer_t ldu,
+ float* c, const integer_t ldc, float* work, integer_t& info ) {
+ LAPACK_SBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu, c,
+ &ldc, work, &info );
 }
 
+inline void bdsqr( const char uplo, const integer_t n, const integer_t ncvt,
+ const integer_t nru, const integer_t ncc, double* d, double* e,
+ double* vt, const integer_t ldvt, double* u, const integer_t ldu,
+ double* c, const integer_t ldc, double* work, integer_t& info ) {
+ LAPACK_DBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu, c,
+ &ldc, work, &info );
+}
+
+inline void bdsqr( const char uplo, const integer_t n, const integer_t ncvt,
+ const integer_t nru, const integer_t ncc, float* d, float* e,
+ traits::complex_f* vt, const integer_t ldvt, traits::complex_f* u,
+ const integer_t ldu, traits::complex_f* c, const integer_t ldc,
+ float* rwork, integer_t& info ) {
+ LAPACK_CBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e,
+ traits::complex_ptr(vt), &ldvt, traits::complex_ptr(u), &ldu,
+ traits::complex_ptr(c), &ldc, rwork, &info );
+}
+
+inline void bdsqr( const char uplo, const integer_t n, const integer_t ncvt,
+ const integer_t nru, const integer_t ncc, double* d, double* e,
+ traits::complex_d* vt, const integer_t ldvt, traits::complex_d* u,
+ const integer_t ldu, traits::complex_d* c, const integer_t ldc,
+ double* rwork, integer_t& info ) {
+ LAPACK_ZBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e,
+ traits::complex_ptr(vt), &ldvt, traits::complex_ptr(u), &ldu,
+ traits::complex_ptr(c), &ldc, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct bdsqr_impl{};
@@ -246,6 +249,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,46 +36,51 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gbbrd( const char vect, const integer_t m, const integer_t n,
- const integer_t ncc, const integer_t kl, const integer_t ku,
- float* ab, const integer_t ldab, float* d, float* e, float* q,
- const integer_t ldq, float* pt, const integer_t ldpt, float* c,
- const integer_t ldc, float* work, integer_t& info ) {
- LAPACK_SGBBRD( &vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q,
- &ldq, pt, &ldpt, c, &ldc, work, &info );
- }
- inline void gbbrd( const char vect, const integer_t m, const integer_t n,
- const integer_t ncc, const integer_t kl, const integer_t ku,
- double* ab, const integer_t ldab, double* d, double* e, double* q,
- const integer_t ldq, double* pt, const integer_t ldpt, double* c,
- const integer_t ldc, double* work, integer_t& info ) {
- LAPACK_DGBBRD( &vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q,
- &ldq, pt, &ldpt, c, &ldc, work, &info );
- }
- inline void gbbrd( const char vect, const integer_t m, const integer_t n,
- const integer_t ncc, const integer_t kl, const integer_t ku,
- traits::complex_f* ab, const integer_t ldab, float* d, float* e,
- traits::complex_f* q, const integer_t ldq, traits::complex_f* pt,
- const integer_t ldpt, traits::complex_f* c, const integer_t ldc,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CGBBRD( &vect, &m, &n, &ncc, &kl, &ku, traits::complex_ptr(ab),
- &ldab, d, e, traits::complex_ptr(q), &ldq,
- traits::complex_ptr(pt), &ldpt, traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void gbbrd( const char vect, const integer_t m, const integer_t n,
- const integer_t ncc, const integer_t kl, const integer_t ku,
- traits::complex_d* ab, const integer_t ldab, double* d, double* e,
- traits::complex_d* q, const integer_t ldq, traits::complex_d* pt,
- const integer_t ldpt, traits::complex_d* c, const integer_t ldc,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZGBBRD( &vect, &m, &n, &ncc, &kl, &ku, traits::complex_ptr(ab),
- &ldab, d, e, traits::complex_ptr(q), &ldq,
- traits::complex_ptr(pt), &ldpt, traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void gbbrd( const char vect, const integer_t m, const integer_t n,
+ const integer_t ncc, const integer_t kl, const integer_t ku,
+ float* ab, const integer_t ldab, float* d, float* e, float* q,
+ const integer_t ldq, float* pt, const integer_t ldpt, float* c,
+ const integer_t ldc, float* work, integer_t& info ) {
+ LAPACK_SGBBRD( &vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q, &ldq,
+ pt, &ldpt, c, &ldc, work, &info );
 }
 
+inline void gbbrd( const char vect, const integer_t m, const integer_t n,
+ const integer_t ncc, const integer_t kl, const integer_t ku,
+ double* ab, const integer_t ldab, double* d, double* e, double* q,
+ const integer_t ldq, double* pt, const integer_t ldpt, double* c,
+ const integer_t ldc, double* work, integer_t& info ) {
+ LAPACK_DGBBRD( &vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q, &ldq,
+ pt, &ldpt, c, &ldc, work, &info );
+}
+
+inline void gbbrd( const char vect, const integer_t m, const integer_t n,
+ const integer_t ncc, const integer_t kl, const integer_t ku,
+ traits::complex_f* ab, const integer_t ldab, float* d, float* e,
+ traits::complex_f* q, const integer_t ldq, traits::complex_f* pt,
+ const integer_t ldpt, traits::complex_f* c, const integer_t ldc,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CGBBRD( &vect, &m, &n, &ncc, &kl, &ku, traits::complex_ptr(ab),
+ &ldab, d, e, traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(pt), &ldpt, traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+inline void gbbrd( const char vect, const integer_t m, const integer_t n,
+ const integer_t ncc, const integer_t kl, const integer_t ku,
+ traits::complex_d* ab, const integer_t ldab, double* d, double* e,
+ traits::complex_d* q, const integer_t ldq, traits::complex_d* pt,
+ const integer_t ldpt, traits::complex_d* c, const integer_t ldc,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZGBBRD( &vect, &m, &n, &ncc, &kl, &ku, traits::complex_ptr(ab),
+ &ldab, d, e, traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(pt), &ldpt, traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gbbrd_impl{};
@@ -273,6 +278,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,40 +36,41 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gbcon( const char norm, const integer_t n, const integer_t kl,
- const integer_t ku, const float* ab, const integer_t ldab,
- const integer_t* ipiv, const float anorm, float& rcond,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SGBCON( &norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, &rcond,
- work, iwork, &info );
- }
- inline void gbcon( const char norm, const integer_t n, const integer_t kl,
- const integer_t ku, const double* ab, const integer_t ldab,
- const integer_t* ipiv, const double anorm, double& rcond,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DGBCON( &norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, &rcond,
- work, iwork, &info );
- }
- inline void gbcon( const char norm, const integer_t n, const integer_t kl,
- const integer_t ku, const traits::complex_f* ab,
- const integer_t ldab, const integer_t* ipiv, const float anorm,
- float& rcond, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CGBCON( &norm, &n, &kl, &ku, traits::complex_ptr(ab), &ldab,
- ipiv, &anorm, &rcond, traits::complex_ptr(work), rwork,
- &info );
- }
- inline void gbcon( const char norm, const integer_t n, const integer_t kl,
- const integer_t ku, const traits::complex_d* ab,
- const integer_t ldab, const integer_t* ipiv, const double anorm,
- double& rcond, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZGBCON( &norm, &n, &kl, &ku, traits::complex_ptr(ab), &ldab,
- ipiv, &anorm, &rcond, traits::complex_ptr(work), rwork,
- &info );
- }
+
+inline void gbcon( const char norm, const integer_t n, const integer_t kl,
+ const integer_t ku, const float* ab, const integer_t ldab,
+ const integer_t* ipiv, const float anorm, float& rcond, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_SGBCON( &norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, &rcond, work,
+ iwork, &info );
 }
 
+inline void gbcon( const char norm, const integer_t n, const integer_t kl,
+ const integer_t ku, const double* ab, const integer_t ldab,
+ const integer_t* ipiv, const double anorm, double& rcond,
+ double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGBCON( &norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, &rcond, work,
+ iwork, &info );
+}
+
+inline void gbcon( const char norm, const integer_t n, const integer_t kl,
+ const integer_t ku, const traits::complex_f* ab, const integer_t ldab,
+ const integer_t* ipiv, const float anorm, float& rcond,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CGBCON( &norm, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, ipiv,
+ &anorm, &rcond, traits::complex_ptr(work), rwork, &info );
+}
+
+inline void gbcon( const char norm, const integer_t n, const integer_t kl,
+ const integer_t ku, const traits::complex_d* ab, const integer_t ldab,
+ const integer_t* ipiv, const double anorm, double& rcond,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZGBCON( &norm, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, ipiv,
+ &anorm, &rcond, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gbcon_impl{};
@@ -231,6 +232,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,38 +34,41 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gbequ( const integer_t m, const integer_t n,
- const integer_t kl, const integer_t ku, const float* ab,
- const integer_t ldab, float* r, float* c, float& rowcnd,
- float& colcnd, float& amax, integer_t& info ) {
- LAPACK_SGBEQU( &m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd,
- &amax, &info );
- }
- inline void gbequ( const integer_t m, const integer_t n,
- const integer_t kl, const integer_t ku, const double* ab,
- const integer_t ldab, double* r, double* c, double& rowcnd,
- double& colcnd, double& amax, integer_t& info ) {
- LAPACK_DGBEQU( &m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd,
- &amax, &info );
- }
- inline void gbequ( const integer_t m, const integer_t n,
- const integer_t kl, const integer_t ku,
- const traits::complex_f* ab, const integer_t ldab, float* r,
- float* c, float& rowcnd, float& colcnd, float& amax,
- integer_t& info ) {
- LAPACK_CGBEQU( &m, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, r, c,
- &rowcnd, &colcnd, &amax, &info );
- }
- inline void gbequ( const integer_t m, const integer_t n,
- const integer_t kl, const integer_t ku,
- const traits::complex_d* ab, const integer_t ldab, double* r,
- double* c, double& rowcnd, double& colcnd, double& amax,
- integer_t& info ) {
- LAPACK_ZGBEQU( &m, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, r, c,
- &rowcnd, &colcnd, &amax, &info );
- }
+
+inline void gbequ( const integer_t m, const integer_t n, const integer_t kl,
+ const integer_t ku, const float* ab, const integer_t ldab, float* r,
+ float* c, float& rowcnd, float& colcnd, float& amax,
+ integer_t& info ) {
+ LAPACK_SGBEQU( &m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd, &amax,
+ &info );
+}
+
+inline void gbequ( const integer_t m, const integer_t n, const integer_t kl,
+ const integer_t ku, const double* ab, const integer_t ldab, double* r,
+ double* c, double& rowcnd, double& colcnd, double& amax,
+ integer_t& info ) {
+ LAPACK_DGBEQU( &m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd, &amax,
+ &info );
+}
+
+inline void gbequ( const integer_t m, const integer_t n, const integer_t kl,
+ const integer_t ku, const traits::complex_f* ab, const integer_t ldab,
+ float* r, float* c, float& rowcnd, float& colcnd, float& amax,
+ integer_t& info ) {
+ LAPACK_CGBEQU( &m, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, r, c,
+ &rowcnd, &colcnd, &amax, &info );
 }
 
+inline void gbequ( const integer_t m, const integer_t n, const integer_t kl,
+ const integer_t ku, const traits::complex_d* ab, const integer_t ldab,
+ double* r, double* c, double& rowcnd, double& colcnd, double& amax,
+ integer_t& info ) {
+ LAPACK_ZGBEQU( &m, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, r, c,
+ &rowcnd, &colcnd, &amax, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gbequ_impl{};
@@ -146,6 +149,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,52 +36,55 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gbrfs( const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- const float* ab, const integer_t ldab, const float* afb,
- const integer_t ldafb, const integer_t* ipiv, const float* b,
- const integer_t ldb, float* x, const integer_t ldx, float* ferr,
- float* berr, float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SGBRFS( &trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb, &ldafb,
- ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void gbrfs( const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- const double* ab, const integer_t ldab, const double* afb,
- const integer_t ldafb, const integer_t* ipiv, const double* b,
- const integer_t ldb, double* x, const integer_t ldx, double* ferr,
- double* berr, double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DGBRFS( &trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb, &ldafb,
- ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void gbrfs( const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- const traits::complex_f* ab, const integer_t ldab,
- const traits::complex_f* afb, const integer_t ldafb,
- const integer_t* ipiv, const traits::complex_f* b,
- const integer_t ldb, traits::complex_f* x, const integer_t ldx,
- float* ferr, float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CGBRFS( &trans, &n, &kl, &ku, &nrhs, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(afb), &ldafb, ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
- inline void gbrfs( const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- const traits::complex_d* ab, const integer_t ldab,
- const traits::complex_d* afb, const integer_t ldafb,
- const integer_t* ipiv, const traits::complex_d* b,
- const integer_t ldb, traits::complex_d* x, const integer_t ldx,
- double* ferr, double* berr, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZGBRFS( &trans, &n, &kl, &ku, &nrhs, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(afb), &ldafb, ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void gbrfs( const char trans, const integer_t n, const integer_t kl,
+ const integer_t ku, const integer_t nrhs, const float* ab,
+ const integer_t ldab, const float* afb, const integer_t ldafb,
+ const integer_t* ipiv, const float* b, const integer_t ldb, float* x,
+ const integer_t ldx, float* ferr, float* berr, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_SGBRFS( &trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb, &ldafb, ipiv,
+ b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void gbrfs( const char trans, const integer_t n, const integer_t kl,
+ const integer_t ku, const integer_t nrhs, const double* ab,
+ const integer_t ldab, const double* afb, const integer_t ldafb,
+ const integer_t* ipiv, const double* b, const integer_t ldb,
+ double* x, const integer_t ldx, double* ferr, double* berr,
+ double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGBRFS( &trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb, &ldafb, ipiv,
+ b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void gbrfs( const char trans, const integer_t n, const integer_t kl,
+ const integer_t ku, const integer_t nrhs, const traits::complex_f* ab,
+ const integer_t ldab, const traits::complex_f* afb,
+ const integer_t ldafb, const integer_t* ipiv,
+ const traits::complex_f* b, const integer_t ldb, traits::complex_f* x,
+ const integer_t ldx, float* ferr, float* berr,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CGBRFS( &trans, &n, &kl, &ku, &nrhs, traits::complex_ptr(ab),
+ &ldab, traits::complex_ptr(afb), &ldafb, ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx, ferr,
+ berr, traits::complex_ptr(work), rwork, &info );
 }
 
+inline void gbrfs( const char trans, const integer_t n, const integer_t kl,
+ const integer_t ku, const integer_t nrhs, const traits::complex_d* ab,
+ const integer_t ldab, const traits::complex_d* afb,
+ const integer_t ldafb, const integer_t* ipiv,
+ const traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
+ const integer_t ldx, double* ferr, double* berr,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZGBRFS( &trans, &n, &kl, &ku, &nrhs, traits::complex_ptr(ab),
+ &ldab, traits::complex_ptr(afb), &ldafb, ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx, ferr,
+ berr, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gbrfs_impl{};
@@ -304,6 +307,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,30 +31,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gbtrf( const integer_t m, const integer_t n,
- const integer_t kl, const integer_t ku, float* ab,
- const integer_t ldab, integer_t* ipiv, integer_t& info ) {
- LAPACK_SGBTRF( &m, &n, &kl, &ku, ab, &ldab, ipiv, &info );
- }
- inline void gbtrf( const integer_t m, const integer_t n,
- const integer_t kl, const integer_t ku, double* ab,
- const integer_t ldab, integer_t* ipiv, integer_t& info ) {
- LAPACK_DGBTRF( &m, &n, &kl, &ku, ab, &ldab, ipiv, &info );
- }
- inline void gbtrf( const integer_t m, const integer_t n,
- const integer_t kl, const integer_t ku, traits::complex_f* ab,
- const integer_t ldab, integer_t* ipiv, integer_t& info ) {
- LAPACK_CGBTRF( &m, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, ipiv,
- &info );
- }
- inline void gbtrf( const integer_t m, const integer_t n,
- const integer_t kl, const integer_t ku, traits::complex_d* ab,
- const integer_t ldab, integer_t* ipiv, integer_t& info ) {
- LAPACK_ZGBTRF( &m, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, ipiv,
- &info );
- }
+
+inline void gbtrf( const integer_t m, const integer_t n, const integer_t kl,
+ const integer_t ku, float* ab, const integer_t ldab, integer_t* ipiv,
+ integer_t& info ) {
+ LAPACK_SGBTRF( &m, &n, &kl, &ku, ab, &ldab, ipiv, &info );
+}
+
+inline void gbtrf( const integer_t m, const integer_t n, const integer_t kl,
+ const integer_t ku, double* ab, const integer_t ldab, integer_t* ipiv,
+ integer_t& info ) {
+ LAPACK_DGBTRF( &m, &n, &kl, &ku, ab, &ldab, ipiv, &info );
+}
+
+inline void gbtrf( const integer_t m, const integer_t n, const integer_t kl,
+ const integer_t ku, traits::complex_f* ab, const integer_t ldab,
+ integer_t* ipiv, integer_t& info ) {
+ LAPACK_CGBTRF( &m, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, ipiv,
+ &info );
 }
 
+inline void gbtrf( const integer_t m, const integer_t n, const integer_t kl,
+ const integer_t ku, traits::complex_d* ab, const integer_t ldab,
+ integer_t* ipiv, integer_t& info ) {
+ LAPACK_ZGBTRF( &m, &n, &kl, &ku, traits::complex_ptr(ab), &ldab, ipiv,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct gbtrf_impl {
@@ -91,6 +96,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,38 +31,41 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gbtrs( const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- const float* ab, const integer_t ldab, const integer_t* ipiv,
- float* b, const integer_t ldb, integer_t& info ) {
- LAPACK_SGBTRS( &trans, &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb,
- &info );
- }
- inline void gbtrs( const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- const double* ab, const integer_t ldab, const integer_t* ipiv,
- double* b, const integer_t ldb, integer_t& info ) {
- LAPACK_DGBTRS( &trans, &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb,
- &info );
- }
- inline void gbtrs( const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- const traits::complex_f* ab, const integer_t ldab,
- const integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_CGBTRS( &trans, &n, &kl, &ku, &nrhs, traits::complex_ptr(ab),
- &ldab, ipiv, traits::complex_ptr(b), &ldb, &info );
- }
- inline void gbtrs( const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- const traits::complex_d* ab, const integer_t ldab,
- const integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_ZGBTRS( &trans, &n, &kl, &ku, &nrhs, traits::complex_ptr(ab),
- &ldab, ipiv, traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void gbtrs( const char trans, const integer_t n, const integer_t kl,
+ const integer_t ku, const integer_t nrhs, const float* ab,
+ const integer_t ldab, const integer_t* ipiv, float* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_SGBTRS( &trans, &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb,
+ &info );
+}
+
+inline void gbtrs( const char trans, const integer_t n, const integer_t kl,
+ const integer_t ku, const integer_t nrhs, const double* ab,
+ const integer_t ldab, const integer_t* ipiv, double* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_DGBTRS( &trans, &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb,
+ &info );
+}
+
+inline void gbtrs( const char trans, const integer_t n, const integer_t kl,
+ const integer_t ku, const integer_t nrhs, const traits::complex_f* ab,
+ const integer_t ldab, const integer_t* ipiv, traits::complex_f* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_CGBTRS( &trans, &n, &kl, &ku, &nrhs, traits::complex_ptr(ab),
+ &ldab, ipiv, traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void gbtrs( const char trans, const integer_t n, const integer_t kl,
+ const integer_t ku, const integer_t nrhs, const traits::complex_d* ab,
+ const integer_t ldab, const integer_t* ipiv, traits::complex_d* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_ZGBTRS( &trans, &n, &kl, &ku, &nrhs, traits::complex_ptr(ab),
+ &ldab, ipiv, traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct gbtrs_impl {
@@ -106,6 +109,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebak.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebak.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebak.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,36 +34,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gebak( const char job, const char side, const integer_t n,
- const integer_t ilo, const integer_t ihi, const float* scale,
- const integer_t m, float* v, const integer_t ldv,
- integer_t& info ) {
- LAPACK_SGEBAK( &job, &side, &n, &ilo, &ihi, scale, &m, v, &ldv,
- &info );
- }
- inline void gebak( const char job, const char side, const integer_t n,
- const integer_t ilo, const integer_t ihi, const double* scale,
- const integer_t m, double* v, const integer_t ldv,
- integer_t& info ) {
- LAPACK_DGEBAK( &job, &side, &n, &ilo, &ihi, scale, &m, v, &ldv,
- &info );
- }
- inline void gebak( const char job, const char side, const integer_t n,
- const integer_t ilo, const integer_t ihi, const float* scale,
- const integer_t m, traits::complex_f* v, const integer_t ldv,
- integer_t& info ) {
- LAPACK_CGEBAK( &job, &side, &n, &ilo, &ihi, scale, &m,
- traits::complex_ptr(v), &ldv, &info );
- }
- inline void gebak( const char job, const char side, const integer_t n,
- const integer_t ilo, const integer_t ihi, const double* scale,
- const integer_t m, traits::complex_d* v, const integer_t ldv,
- integer_t& info ) {
- LAPACK_ZGEBAK( &job, &side, &n, &ilo, &ihi, scale, &m,
- traits::complex_ptr(v), &ldv, &info );
- }
+
+inline void gebak( const char job, const char side, const integer_t n,
+ const integer_t ilo, const integer_t ihi, const float* scale,
+ const integer_t m, float* v, const integer_t ldv, integer_t& info ) {
+ LAPACK_SGEBAK( &job, &side, &n, &ilo, &ihi, scale, &m, v, &ldv, &info );
+}
+
+inline void gebak( const char job, const char side, const integer_t n,
+ const integer_t ilo, const integer_t ihi, const double* scale,
+ const integer_t m, double* v, const integer_t ldv, integer_t& info ) {
+ LAPACK_DGEBAK( &job, &side, &n, &ilo, &ihi, scale, &m, v, &ldv, &info );
+}
+
+inline void gebak( const char job, const char side, const integer_t n,
+ const integer_t ilo, const integer_t ihi, const float* scale,
+ const integer_t m, traits::complex_f* v, const integer_t ldv,
+ integer_t& info ) {
+ LAPACK_CGEBAK( &job, &side, &n, &ilo, &ihi, scale, &m,
+ traits::complex_ptr(v), &ldv, &info );
+}
+
+inline void gebak( const char job, const char side, const integer_t n,
+ const integer_t ilo, const integer_t ihi, const double* scale,
+ const integer_t m, traits::complex_d* v, const integer_t ldv,
+ integer_t& info ) {
+ LAPACK_ZGEBAK( &job, &side, &n, &ilo, &ihi, scale, &m,
+ traits::complex_ptr(v), &ldv, &info );
 }
 
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gebak_impl{};
@@ -138,6 +139,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebal.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebal.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebal.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,30 +34,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gebal( const char job, const integer_t n, float* a,
- const integer_t lda, integer_t& ilo, integer_t& ihi, float* scale,
- integer_t& info ) {
- LAPACK_SGEBAL( &job, &n, a, &lda, &ilo, &ihi, scale, &info );
- }
- inline void gebal( const char job, const integer_t n, double* a,
- const integer_t lda, integer_t& ilo, integer_t& ihi,
- double* scale, integer_t& info ) {
- LAPACK_DGEBAL( &job, &n, a, &lda, &ilo, &ihi, scale, &info );
- }
- inline void gebal( const char job, const integer_t n,
- traits::complex_f* a, const integer_t lda, integer_t& ilo,
- integer_t& ihi, float* scale, integer_t& info ) {
- LAPACK_CGEBAL( &job, &n, traits::complex_ptr(a), &lda, &ilo, &ihi,
- scale, &info );
- }
- inline void gebal( const char job, const integer_t n,
- traits::complex_d* a, const integer_t lda, integer_t& ilo,
- integer_t& ihi, double* scale, integer_t& info ) {
- LAPACK_ZGEBAL( &job, &n, traits::complex_ptr(a), &lda, &ilo, &ihi,
- scale, &info );
- }
+
+inline void gebal( const char job, const integer_t n, float* a,
+ const integer_t lda, integer_t& ilo, integer_t& ihi, float* scale,
+ integer_t& info ) {
+ LAPACK_SGEBAL( &job, &n, a, &lda, &ilo, &ihi, scale, &info );
+}
+
+inline void gebal( const char job, const integer_t n, double* a,
+ const integer_t lda, integer_t& ilo, integer_t& ihi, double* scale,
+ integer_t& info ) {
+ LAPACK_DGEBAL( &job, &n, a, &lda, &ilo, &ihi, scale, &info );
+}
+
+inline void gebal( const char job, const integer_t n, traits::complex_f* a,
+ const integer_t lda, integer_t& ilo, integer_t& ihi, float* scale,
+ integer_t& info ) {
+ LAPACK_CGEBAL( &job, &n, traits::complex_ptr(a), &lda, &ilo, &ihi, scale,
+ &info );
 }
 
+inline void gebal( const char job, const integer_t n, traits::complex_d* a,
+ const integer_t lda, integer_t& ilo, integer_t& ihi, double* scale,
+ integer_t& info ) {
+ LAPACK_ZGEBAL( &job, &n, traits::complex_ptr(a), &lda, &ilo, &ihi, scale,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gebal_impl{};
@@ -118,6 +123,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,37 +37,39 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gebrd( const integer_t m, const integer_t n, float* a,
- const integer_t lda, float* d, float* e, float* tauq, float* taup,
- float* work, const integer_t lwork, integer_t& info ) {
- LAPACK_SGEBRD( &m, &n, a, &lda, d, e, tauq, taup, work, &lwork,
- &info );
- }
- inline void gebrd( const integer_t m, const integer_t n, double* a,
- const integer_t lda, double* d, double* e, double* tauq,
- double* taup, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DGEBRD( &m, &n, a, &lda, d, e, tauq, taup, work, &lwork,
- &info );
- }
- inline void gebrd( const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, float* d, float* e,
- traits::complex_f* tauq, traits::complex_f* taup,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGEBRD( &m, &n, traits::complex_ptr(a), &lda, d, e,
- traits::complex_ptr(tauq), traits::complex_ptr(taup),
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void gebrd( const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, double* d, double* e,
- traits::complex_d* tauq, traits::complex_d* taup,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGEBRD( &m, &n, traits::complex_ptr(a), &lda, d, e,
- traits::complex_ptr(tauq), traits::complex_ptr(taup),
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void gebrd( const integer_t m, const integer_t n, float* a,
+ const integer_t lda, float* d, float* e, float* tauq, float* taup,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SGEBRD( &m, &n, a, &lda, d, e, tauq, taup, work, &lwork, &info );
 }
 
+inline void gebrd( const integer_t m, const integer_t n, double* a,
+ const integer_t lda, double* d, double* e, double* tauq, double* taup,
+ double* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_DGEBRD( &m, &n, a, &lda, d, e, tauq, taup, work, &lwork, &info );
+}
+
+inline void gebrd( const integer_t m, const integer_t n, traits::complex_f* a,
+ const integer_t lda, float* d, float* e, traits::complex_f* tauq,
+ traits::complex_f* taup, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CGEBRD( &m, &n, traits::complex_ptr(a), &lda, d, e,
+ traits::complex_ptr(tauq), traits::complex_ptr(taup),
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+inline void gebrd( const integer_t m, const integer_t n, traits::complex_d* a,
+ const integer_t lda, double* d, double* e, traits::complex_d* tauq,
+ traits::complex_d* taup, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGEBRD( &m, &n, traits::complex_ptr(a), &lda, d, e,
+ traits::complex_ptr(tauq), traits::complex_ptr(taup),
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gebrd_impl{};
@@ -255,6 +257,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,34 +36,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gecon( const char norm, const integer_t n, const float* a,
- const integer_t lda, const float anorm, float& rcond, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SGECON( &norm, &n, a, &lda, &anorm, &rcond, work, iwork,
- &info );
- }
- inline void gecon( const char norm, const integer_t n, const double* a,
- const integer_t lda, const double anorm, double& rcond,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DGECON( &norm, &n, a, &lda, &anorm, &rcond, work, iwork,
- &info );
- }
- inline void gecon( const char norm, const integer_t n,
- const traits::complex_f* a, const integer_t lda,
- const float anorm, float& rcond, traits::complex_f* work,
- float* rwork, integer_t& info ) {
- LAPACK_CGECON( &norm, &n, traits::complex_ptr(a), &lda, &anorm,
- &rcond, traits::complex_ptr(work), rwork, &info );
- }
- inline void gecon( const char norm, const integer_t n,
- const traits::complex_d* a, const integer_t lda,
- const double anorm, double& rcond, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZGECON( &norm, &n, traits::complex_ptr(a), &lda, &anorm,
- &rcond, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void gecon( const char norm, const integer_t n, const float* a,
+ const integer_t lda, const float anorm, float& rcond, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_SGECON( &norm, &n, a, &lda, &anorm, &rcond, work, iwork, &info );
 }
 
+inline void gecon( const char norm, const integer_t n, const double* a,
+ const integer_t lda, const double anorm, double& rcond, double* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_DGECON( &norm, &n, a, &lda, &anorm, &rcond, work, iwork, &info );
+}
+
+inline void gecon( const char norm, const integer_t n,
+ const traits::complex_f* a, const integer_t lda, const float anorm,
+ float& rcond, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CGECON( &norm, &n, traits::complex_ptr(a), &lda, &anorm, &rcond,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+inline void gecon( const char norm, const integer_t n,
+ const traits::complex_d* a, const integer_t lda, const double anorm,
+ double& rcond, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZGECON( &norm, &n, traits::complex_ptr(a), &lda, &anorm, &rcond,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gecon_impl{};
@@ -210,6 +213,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,32 +34,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void geequ( const integer_t m, const integer_t n, const float* a,
- const integer_t lda, float* r, float* c, float& rowcnd,
- float& colcnd, float& amax, integer_t& info ) {
- LAPACK_SGEEQU( &m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &info );
- }
- inline void geequ( const integer_t m, const integer_t n, const double* a,
- const integer_t lda, double* r, double* c, double& rowcnd,
- double& colcnd, double& amax, integer_t& info ) {
- LAPACK_DGEEQU( &m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &info );
- }
- inline void geequ( const integer_t m, const integer_t n,
- const traits::complex_f* a, const integer_t lda, float* r,
- float* c, float& rowcnd, float& colcnd, float& amax,
- integer_t& info ) {
- LAPACK_CGEEQU( &m, &n, traits::complex_ptr(a), &lda, r, c, &rowcnd,
- &colcnd, &amax, &info );
- }
- inline void geequ( const integer_t m, const integer_t n,
- const traits::complex_d* a, const integer_t lda, double* r,
- double* c, double& rowcnd, double& colcnd, double& amax,
- integer_t& info ) {
- LAPACK_ZGEEQU( &m, &n, traits::complex_ptr(a), &lda, r, c, &rowcnd,
- &colcnd, &amax, &info );
- }
+
+inline void geequ( const integer_t m, const integer_t n, const float* a,
+ const integer_t lda, float* r, float* c, float& rowcnd, float& colcnd,
+ float& amax, integer_t& info ) {
+ LAPACK_SGEEQU( &m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &info );
 }
 
+inline void geequ( const integer_t m, const integer_t n, const double* a,
+ const integer_t lda, double* r, double* c, double& rowcnd,
+ double& colcnd, double& amax, integer_t& info ) {
+ LAPACK_DGEEQU( &m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &info );
+}
+
+inline void geequ( const integer_t m, const integer_t n,
+ const traits::complex_f* a, const integer_t lda, float* r, float* c,
+ float& rowcnd, float& colcnd, float& amax, integer_t& info ) {
+ LAPACK_CGEEQU( &m, &n, traits::complex_ptr(a), &lda, r, c, &rowcnd,
+ &colcnd, &amax, &info );
+}
+
+inline void geequ( const integer_t m, const integer_t n,
+ const traits::complex_d* a, const integer_t lda, double* r, double* c,
+ double& rowcnd, double& colcnd, double& amax, integer_t& info ) {
+ LAPACK_ZGEEQU( &m, &n, traits::complex_ptr(a), &lda, r, c, &rowcnd,
+ &colcnd, &amax, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct geequ_impl{};
@@ -136,6 +139,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,34 +37,39 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gehrd( const integer_t n, const integer_t ilo,
- const integer_t ihi, float* a, const integer_t lda, float* tau,
- float* work, const integer_t lwork, integer_t& info ) {
- LAPACK_SGEHRD( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info );
- }
- inline void gehrd( const integer_t n, const integer_t ilo,
- const integer_t ihi, double* a, const integer_t lda, double* tau,
- double* work, const integer_t lwork, integer_t& info ) {
- LAPACK_DGEHRD( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info );
- }
- inline void gehrd( const integer_t n, const integer_t ilo,
- const integer_t ihi, traits::complex_f* a, const integer_t lda,
- traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CGEHRD( &n, &ilo, &ihi, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void gehrd( const integer_t n, const integer_t ilo,
- const integer_t ihi, traits::complex_d* a, const integer_t lda,
- traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZGEHRD( &n, &ilo, &ihi, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void gehrd( const integer_t n, const integer_t ilo,
+ const integer_t ihi, float* a, const integer_t lda, float* tau,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SGEHRD( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void gehrd( const integer_t n, const integer_t ilo,
+ const integer_t ihi, double* a, const integer_t lda, double* tau,
+ double* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_DGEHRD( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info );
+}
+
+inline void gehrd( const integer_t n, const integer_t ilo,
+ const integer_t ihi, traits::complex_f* a, const integer_t lda,
+ traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CGEHRD( &n, &ilo, &ihi, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void gehrd( const integer_t n, const integer_t ilo,
+ const integer_t ihi, traits::complex_d* a, const integer_t lda,
+ traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGEHRD( &n, &ilo, &ihi, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gehrd_impl{};
@@ -203,6 +208,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,32 +37,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gelqf( const integer_t m, const integer_t n, float* a,
- const integer_t lda, float* tau, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGELQF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void gelqf( const integer_t m, const integer_t n, double* a,
- const integer_t lda, double* tau, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DGELQF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void gelqf( const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* tau,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGELQF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void gelqf( const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* tau,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGELQF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void gelqf( const integer_t m, const integer_t n, float* a,
+ const integer_t lda, float* tau, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGELQF( &m, &n, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void gelqf( const integer_t m, const integer_t n, double* a,
+ const integer_t lda, double* tau, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DGELQF( &m, &n, a, &lda, tau, work, &lwork, &info );
+}
+
+inline void gelqf( const integer_t m, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CGELQF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void gelqf( const integer_t m, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGELQF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gelqf_impl{};
@@ -202,6 +207,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,32 +37,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void geqlf( const integer_t m, const integer_t n, float* a,
- const integer_t lda, float* tau, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGEQLF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void geqlf( const integer_t m, const integer_t n, double* a,
- const integer_t lda, double* tau, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DGEQLF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void geqlf( const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* tau,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGEQLF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void geqlf( const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* tau,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGEQLF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void geqlf( const integer_t m, const integer_t n, float* a,
+ const integer_t lda, float* tau, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGEQLF( &m, &n, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void geqlf( const integer_t m, const integer_t n, double* a,
+ const integer_t lda, double* tau, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DGEQLF( &m, &n, a, &lda, tau, work, &lwork, &info );
+}
+
+inline void geqlf( const integer_t m, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CGEQLF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void geqlf( const integer_t m, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGEQLF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct geqlf_impl{};
@@ -202,6 +207,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,34 +37,39 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void geqp3( const integer_t m, const integer_t n, float* a,
- const integer_t lda, integer_t* jpvt, float* tau, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGEQP3( &m, &n, a, &lda, jpvt, tau, work, &lwork, &info );
- }
- inline void geqp3( const integer_t m, const integer_t n, double* a,
- const integer_t lda, integer_t* jpvt, double* tau, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DGEQP3( &m, &n, a, &lda, jpvt, tau, work, &lwork, &info );
- }
- inline void geqp3( const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, integer_t* jpvt,
- traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, float* rwork, integer_t& info ) {
- LAPACK_CGEQP3( &m, &n, traits::complex_ptr(a), &lda, jpvt,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- rwork, &info );
- }
- inline void geqp3( const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, integer_t* jpvt,
- traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, double* rwork, integer_t& info ) {
- LAPACK_ZGEQP3( &m, &n, traits::complex_ptr(a), &lda, jpvt,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- rwork, &info );
- }
+
+inline void geqp3( const integer_t m, const integer_t n, float* a,
+ const integer_t lda, integer_t* jpvt, float* tau, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SGEQP3( &m, &n, a, &lda, jpvt, tau, work, &lwork, &info );
 }
 
+inline void geqp3( const integer_t m, const integer_t n, double* a,
+ const integer_t lda, integer_t* jpvt, double* tau, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DGEQP3( &m, &n, a, &lda, jpvt, tau, work, &lwork, &info );
+}
+
+inline void geqp3( const integer_t m, const integer_t n, traits::complex_f* a,
+ const integer_t lda, integer_t* jpvt, traits::complex_f* tau,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ integer_t& info ) {
+ LAPACK_CGEQP3( &m, &n, traits::complex_ptr(a), &lda, jpvt,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ rwork, &info );
+}
+
+inline void geqp3( const integer_t m, const integer_t n, traits::complex_d* a,
+ const integer_t lda, integer_t* jpvt, traits::complex_d* tau,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZGEQP3( &m, &n, traits::complex_ptr(a), &lda, jpvt,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct geqp3_impl{};
@@ -223,6 +228,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,32 +37,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void geqrf( const integer_t m, const integer_t n, float* a,
- const integer_t lda, float* tau, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGEQRF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void geqrf( const integer_t m, const integer_t n, double* a,
- const integer_t lda, double* tau, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DGEQRF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void geqrf( const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* tau,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGEQRF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void geqrf( const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* tau,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGEQRF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void geqrf( const integer_t m, const integer_t n, float* a,
+ const integer_t lda, float* tau, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGEQRF( &m, &n, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void geqrf( const integer_t m, const integer_t n, double* a,
+ const integer_t lda, double* tau, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DGEQRF( &m, &n, a, &lda, tau, work, &lwork, &info );
+}
+
+inline void geqrf( const integer_t m, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CGEQRF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void geqrf( const integer_t m, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGEQRF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct geqrf_impl{};
@@ -202,6 +207,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,52 +36,53 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gerfs( const char trans, const integer_t n,
- const integer_t nrhs, const float* a, const integer_t lda,
- const float* af, const integer_t ldaf, const integer_t* ipiv,
- const float* b, const integer_t ldb, float* x,
- const integer_t ldx, float* ferr, float* berr, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SGERFS( &trans, &n, &nrhs, a, &lda, af, &ldaf, ipiv, b, &ldb,
- x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void gerfs( const char trans, const integer_t n,
- const integer_t nrhs, const double* a, const integer_t lda,
- const double* af, const integer_t ldaf, const integer_t* ipiv,
- const double* b, const integer_t ldb, double* x,
- const integer_t ldx, double* ferr, double* berr, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DGERFS( &trans, &n, &nrhs, a, &lda, af, &ldaf, ipiv, b, &ldb,
- x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void gerfs( const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* af,
- const integer_t ldaf, const integer_t* ipiv,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float* ferr,
- float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CGERFS( &trans, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void gerfs( const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* af,
- const integer_t ldaf, const integer_t* ipiv,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double* ferr,
- double* berr, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZGERFS( &trans, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void gerfs( const char trans, const integer_t n, const integer_t nrhs,
+ const float* a, const integer_t lda, const float* af,
+ const integer_t ldaf, const integer_t* ipiv, const float* b,
+ const integer_t ldb, float* x, const integer_t ldx, float* ferr,
+ float* berr, float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SGERFS( &trans, &n, &nrhs, a, &lda, af, &ldaf, ipiv, b, &ldb, x,
+ &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void gerfs( const char trans, const integer_t n, const integer_t nrhs,
+ const double* a, const integer_t lda, const double* af,
+ const integer_t ldaf, const integer_t* ipiv, const double* b,
+ const integer_t ldb, double* x, const integer_t ldx, double* ferr,
+ double* berr, double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGERFS( &trans, &n, &nrhs, a, &lda, af, &ldaf, ipiv, b, &ldb, x,
+ &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void gerfs( const char trans, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* af, const integer_t ldaf,
+ const integer_t* ipiv, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float* ferr, float* berr, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CGERFS( &trans, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void gerfs( const char trans, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* af, const integer_t ldaf,
+ const integer_t* ipiv, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZGERFS( &trans, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gerfs_impl{};
@@ -306,6 +307,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,32 +37,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gerqf( const integer_t m, const integer_t n, float* a,
- const integer_t lda, float* tau, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGERQF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void gerqf( const integer_t m, const integer_t n, double* a,
- const integer_t lda, double* tau, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DGERQF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void gerqf( const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* tau,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGERQF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void gerqf( const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* tau,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGERQF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void gerqf( const integer_t m, const integer_t n, float* a,
+ const integer_t lda, float* tau, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGERQF( &m, &n, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void gerqf( const integer_t m, const integer_t n, double* a,
+ const integer_t lda, double* tau, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DGERQF( &m, &n, a, &lda, tau, work, &lwork, &info );
+}
+
+inline void gerqf( const integer_t m, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CGERQF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void gerqf( const integer_t m, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGERQF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gerqf_impl{};
@@ -202,6 +207,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,26 +31,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void getrf( const integer_t m, const integer_t n, float* a,
- const integer_t lda, integer_t* ipiv, integer_t& info ) {
- LAPACK_SGETRF( &m, &n, a, &lda, ipiv, &info );
- }
- inline void getrf( const integer_t m, const integer_t n, double* a,
- const integer_t lda, integer_t* ipiv, integer_t& info ) {
- LAPACK_DGETRF( &m, &n, a, &lda, ipiv, &info );
- }
- inline void getrf( const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, integer_t* ipiv,
- integer_t& info ) {
- LAPACK_CGETRF( &m, &n, traits::complex_ptr(a), &lda, ipiv, &info );
- }
- inline void getrf( const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, integer_t* ipiv,
- integer_t& info ) {
- LAPACK_ZGETRF( &m, &n, traits::complex_ptr(a), &lda, ipiv, &info );
- }
+
+inline void getrf( const integer_t m, const integer_t n, float* a,
+ const integer_t lda, integer_t* ipiv, integer_t& info ) {
+ LAPACK_SGETRF( &m, &n, a, &lda, ipiv, &info );
+}
+
+inline void getrf( const integer_t m, const integer_t n, double* a,
+ const integer_t lda, integer_t* ipiv, integer_t& info ) {
+ LAPACK_DGETRF( &m, &n, a, &lda, ipiv, &info );
+}
+
+inline void getrf( const integer_t m, const integer_t n, traits::complex_f* a,
+ const integer_t lda, integer_t* ipiv, integer_t& info ) {
+ LAPACK_CGETRF( &m, &n, traits::complex_ptr(a), &lda, ipiv, &info );
 }
 
+inline void getrf( const integer_t m, const integer_t n, traits::complex_d* a,
+ const integer_t lda, integer_t* ipiv, integer_t& info ) {
+ LAPACK_ZGETRF( &m, &n, traits::complex_ptr(a), &lda, ipiv, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct getrf_impl {
@@ -85,6 +88,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,30 +37,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void getri( const integer_t n, float* a, const integer_t lda,
- const integer_t* ipiv, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SGETRI( &n, a, &lda, ipiv, work, &lwork, &info );
- }
- inline void getri( const integer_t n, double* a, const integer_t lda,
- const integer_t* ipiv, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DGETRI( &n, a, &lda, ipiv, work, &lwork, &info );
- }
- inline void getri( const integer_t n, traits::complex_f* a,
- const integer_t lda, const integer_t* ipiv,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGETRI( &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void getri( const integer_t n, traits::complex_d* a,
- const integer_t lda, const integer_t* ipiv,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGETRI( &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void getri( const integer_t n, float* a, const integer_t lda,
+ const integer_t* ipiv, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGETRI( &n, a, &lda, ipiv, work, &lwork, &info );
 }
 
+inline void getri( const integer_t n, double* a, const integer_t lda,
+ const integer_t* ipiv, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DGETRI( &n, a, &lda, ipiv, work, &lwork, &info );
+}
+
+inline void getri( const integer_t n, traits::complex_f* a,
+ const integer_t lda, const integer_t* ipiv, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CGETRI( &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+inline void getri( const integer_t n, traits::complex_d* a,
+ const integer_t lda, const integer_t* ipiv, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGETRI( &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct getri_impl{};
@@ -190,6 +195,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,34 +31,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void getrs( const char trans, const integer_t n,
- const integer_t nrhs, const float* a, const integer_t lda,
- const integer_t* ipiv, float* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_SGETRS( &trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
- }
- inline void getrs( const char trans, const integer_t n,
- const integer_t nrhs, const double* a, const integer_t lda,
- const integer_t* ipiv, double* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_DGETRS( &trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
- }
- inline void getrs( const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, const integer_t* ipiv, traits::complex_f* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_CGETRS( &trans, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void getrs( const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, const integer_t* ipiv, traits::complex_d* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_ZGETRS( &trans, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void getrs( const char trans, const integer_t n, const integer_t nrhs,
+ const float* a, const integer_t lda, const integer_t* ipiv, float* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_SGETRS( &trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
+}
+
+inline void getrs( const char trans, const integer_t n, const integer_t nrhs,
+ const double* a, const integer_t lda, const integer_t* ipiv,
+ double* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_DGETRS( &trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
+}
+
+inline void getrs( const char trans, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* a, const integer_t lda,
+ const integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CGETRS( &trans, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void getrs( const char trans, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda,
+ const integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZGETRS( &trans, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct getrs_impl {
@@ -101,6 +104,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,36 +34,41 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggbak( const char job, const char side, const integer_t n,
- const integer_t ilo, const integer_t ihi, const float* lscale,
- const float* rscale, const integer_t m, float* v,
- const integer_t ldv, integer_t& info ) {
- LAPACK_SGGBAK( &job, &side, &n, &ilo, &ihi, lscale, rscale, &m, v,
- &ldv, &info );
- }
- inline void ggbak( const char job, const char side, const integer_t n,
- const integer_t ilo, const integer_t ihi, const double* lscale,
- const double* rscale, const integer_t m, double* v,
- const integer_t ldv, integer_t& info ) {
- LAPACK_DGGBAK( &job, &side, &n, &ilo, &ihi, lscale, rscale, &m, v,
- &ldv, &info );
- }
- inline void ggbak( const char job, const char side, const integer_t n,
- const integer_t ilo, const integer_t ihi, const float* lscale,
- const float* rscale, const integer_t m, traits::complex_f* v,
- const integer_t ldv, integer_t& info ) {
- LAPACK_CGGBAK( &job, &side, &n, &ilo, &ihi, lscale, rscale, &m,
- traits::complex_ptr(v), &ldv, &info );
- }
- inline void ggbak( const char job, const char side, const integer_t n,
- const integer_t ilo, const integer_t ihi, const double* lscale,
- const double* rscale, const integer_t m, traits::complex_d* v,
- const integer_t ldv, integer_t& info ) {
- LAPACK_ZGGBAK( &job, &side, &n, &ilo, &ihi, lscale, rscale, &m,
- traits::complex_ptr(v), &ldv, &info );
- }
+
+inline void ggbak( const char job, const char side, const integer_t n,
+ const integer_t ilo, const integer_t ihi, const float* lscale,
+ const float* rscale, const integer_t m, float* v, const integer_t ldv,
+ integer_t& info ) {
+ LAPACK_SGGBAK( &job, &side, &n, &ilo, &ihi, lscale, rscale, &m, v, &ldv,
+ &info );
+}
+
+inline void ggbak( const char job, const char side, const integer_t n,
+ const integer_t ilo, const integer_t ihi, const double* lscale,
+ const double* rscale, const integer_t m, double* v,
+ const integer_t ldv, integer_t& info ) {
+ LAPACK_DGGBAK( &job, &side, &n, &ilo, &ihi, lscale, rscale, &m, v, &ldv,
+ &info );
+}
+
+inline void ggbak( const char job, const char side, const integer_t n,
+ const integer_t ilo, const integer_t ihi, const float* lscale,
+ const float* rscale, const integer_t m, traits::complex_f* v,
+ const integer_t ldv, integer_t& info ) {
+ LAPACK_CGGBAK( &job, &side, &n, &ilo, &ihi, lscale, rscale, &m,
+ traits::complex_ptr(v), &ldv, &info );
 }
 
+inline void ggbak( const char job, const char side, const integer_t n,
+ const integer_t ilo, const integer_t ihi, const double* lscale,
+ const double* rscale, const integer_t m, traits::complex_d* v,
+ const integer_t ldv, integer_t& info ) {
+ LAPACK_ZGGBAK( &job, &side, &n, &ilo, &ihi, lscale, rscale, &m,
+ traits::complex_ptr(v), &ldv, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggbak_impl{};
@@ -150,6 +155,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,38 +36,43 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggbal( const char job, const integer_t n, float* a,
- const integer_t lda, float* b, const integer_t ldb,
- integer_t& ilo, integer_t& ihi, float* lscale, float* rscale,
- float* work, integer_t& info ) {
- LAPACK_SGGBAL( &job, &n, a, &lda, b, &ldb, &ilo, &ihi, lscale, rscale,
- work, &info );
- }
- inline void ggbal( const char job, const integer_t n, double* a,
- const integer_t lda, double* b, const integer_t ldb,
- integer_t& ilo, integer_t& ihi, double* lscale, double* rscale,
- double* work, integer_t& info ) {
- LAPACK_DGGBAL( &job, &n, a, &lda, b, &ldb, &ilo, &ihi, lscale, rscale,
- work, &info );
- }
- inline void ggbal( const char job, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* b,
- const integer_t ldb, integer_t& ilo, integer_t& ihi,
- float* lscale, float* rscale, float* work, integer_t& info ) {
- LAPACK_CGGBAL( &job, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, &ilo, &ihi, lscale, rscale,
- work, &info );
- }
- inline void ggbal( const char job, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* b,
- const integer_t ldb, integer_t& ilo, integer_t& ihi,
- double* lscale, double* rscale, double* work, integer_t& info ) {
- LAPACK_ZGGBAL( &job, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, &ilo, &ihi, lscale, rscale,
- work, &info );
- }
+
+inline void ggbal( const char job, const integer_t n, float* a,
+ const integer_t lda, float* b, const integer_t ldb, integer_t& ilo,
+ integer_t& ihi, float* lscale, float* rscale, float* work,
+ integer_t& info ) {
+ LAPACK_SGGBAL( &job, &n, a, &lda, b, &ldb, &ilo, &ihi, lscale, rscale,
+ work, &info );
 }
 
+inline void ggbal( const char job, const integer_t n, double* a,
+ const integer_t lda, double* b, const integer_t ldb, integer_t& ilo,
+ integer_t& ihi, double* lscale, double* rscale, double* work,
+ integer_t& info ) {
+ LAPACK_DGGBAL( &job, &n, a, &lda, b, &ldb, &ilo, &ihi, lscale, rscale,
+ work, &info );
+}
+
+inline void ggbal( const char job, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* b, const integer_t ldb,
+ integer_t& ilo, integer_t& ihi, float* lscale, float* rscale,
+ float* work, integer_t& info ) {
+ LAPACK_CGGBAL( &job, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, &ilo, &ihi, lscale, rscale, work,
+ &info );
+}
+
+inline void ggbal( const char job, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* b, const integer_t ldb,
+ integer_t& ilo, integer_t& ihi, double* lscale, double* rscale,
+ double* work, integer_t& info ) {
+ LAPACK_ZGGBAL( &job, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, &ilo, &ihi, lscale, rscale, work,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggbal_impl{};
@@ -224,6 +229,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,42 +31,46 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gghrd( const char compq, const char compz, const integer_t n,
- const integer_t ilo, const integer_t ihi, float* a,
- const integer_t lda, float* b, const integer_t ldb, float* q,
- const integer_t ldq, float* z, const integer_t ldz,
- integer_t& info ) {
- LAPACK_SGGHRD( &compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q,
- &ldq, z, &ldz, &info );
- }
- inline void gghrd( const char compq, const char compz, const integer_t n,
- const integer_t ilo, const integer_t ihi, double* a,
- const integer_t lda, double* b, const integer_t ldb, double* q,
- const integer_t ldq, double* z, const integer_t ldz,
- integer_t& info ) {
- LAPACK_DGGHRD( &compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q,
- &ldq, z, &ldz, &info );
- }
- inline void gghrd( const char compq, const char compz, const integer_t n,
- const integer_t ilo, const integer_t ihi, traits::complex_f* a,
- const integer_t lda, traits::complex_f* b, const integer_t ldb,
- traits::complex_f* q, const integer_t ldq, traits::complex_f* z,
- const integer_t ldz, integer_t& info ) {
- LAPACK_CGGHRD( &compq, &compz, &n, &ilo, &ihi, traits::complex_ptr(a),
- &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(q),
- &ldq, traits::complex_ptr(z), &ldz, &info );
- }
- inline void gghrd( const char compq, const char compz, const integer_t n,
- const integer_t ilo, const integer_t ihi, traits::complex_d* a,
- const integer_t lda, traits::complex_d* b, const integer_t ldb,
- traits::complex_d* q, const integer_t ldq, traits::complex_d* z,
- const integer_t ldz, integer_t& info ) {
- LAPACK_ZGGHRD( &compq, &compz, &n, &ilo, &ihi, traits::complex_ptr(a),
- &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(q),
- &ldq, traits::complex_ptr(z), &ldz, &info );
- }
+
+inline void gghrd( const char compq, const char compz, const integer_t n,
+ const integer_t ilo, const integer_t ihi, float* a,
+ const integer_t lda, float* b, const integer_t ldb, float* q,
+ const integer_t ldq, float* z, const integer_t ldz, integer_t& info ) {
+ LAPACK_SGGHRD( &compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q, &ldq,
+ z, &ldz, &info );
+}
+
+inline void gghrd( const char compq, const char compz, const integer_t n,
+ const integer_t ilo, const integer_t ihi, double* a,
+ const integer_t lda, double* b, const integer_t ldb, double* q,
+ const integer_t ldq, double* z, const integer_t ldz,
+ integer_t& info ) {
+ LAPACK_DGGHRD( &compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q, &ldq,
+ z, &ldz, &info );
+}
+
+inline void gghrd( const char compq, const char compz, const integer_t n,
+ const integer_t ilo, const integer_t ihi, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* b, const integer_t ldb,
+ traits::complex_f* q, const integer_t ldq, traits::complex_f* z,
+ const integer_t ldz, integer_t& info ) {
+ LAPACK_CGGHRD( &compq, &compz, &n, &ilo, &ihi, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(z), &ldz, &info );
 }
 
+inline void gghrd( const char compq, const char compz, const integer_t n,
+ const integer_t ilo, const integer_t ihi, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* b, const integer_t ldb,
+ traits::complex_d* q, const integer_t ldq, traits::complex_d* z,
+ const integer_t ldz, integer_t& info ) {
+ LAPACK_ZGGHRD( &compq, &compz, &n, &ilo, &ihi, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(z), &ldz, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct gghrd_impl {
@@ -117,6 +121,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,42 +37,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggqrf( const integer_t n, const integer_t m,
- const integer_t p, float* a, const integer_t lda, float* taua,
- float* b, const integer_t ldb, float* taub, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGGQRF( &n, &m, &p, a, &lda, taua, b, &ldb, taub, work, &lwork,
- &info );
- }
- inline void ggqrf( const integer_t n, const integer_t m,
- const integer_t p, double* a, const integer_t lda, double* taua,
- double* b, const integer_t ldb, double* taub, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DGGQRF( &n, &m, &p, a, &lda, taua, b, &ldb, taub, work, &lwork,
- &info );
- }
- inline void ggqrf( const integer_t n, const integer_t m,
- const integer_t p, traits::complex_f* a, const integer_t lda,
- traits::complex_f* taua, traits::complex_f* b,
- const integer_t ldb, traits::complex_f* taub,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGGQRF( &n, &m, &p, traits::complex_ptr(a), &lda,
- traits::complex_ptr(taua), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(taub), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void ggqrf( const integer_t n, const integer_t m,
- const integer_t p, traits::complex_d* a, const integer_t lda,
- traits::complex_d* taua, traits::complex_d* b,
- const integer_t ldb, traits::complex_d* taub,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGGQRF( &n, &m, &p, traits::complex_ptr(a), &lda,
- traits::complex_ptr(taua), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(taub), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void ggqrf( const integer_t n, const integer_t m, const integer_t p,
+ float* a, const integer_t lda, float* taua, float* b,
+ const integer_t ldb, float* taub, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGGQRF( &n, &m, &p, a, &lda, taua, b, &ldb, taub, work, &lwork,
+ &info );
 }
 
+inline void ggqrf( const integer_t n, const integer_t m, const integer_t p,
+ double* a, const integer_t lda, double* taua, double* b,
+ const integer_t ldb, double* taub, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DGGQRF( &n, &m, &p, a, &lda, taua, b, &ldb, taub, work, &lwork,
+ &info );
+}
+
+inline void ggqrf( const integer_t n, const integer_t m, const integer_t p,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* taua,
+ traits::complex_f* b, const integer_t ldb, traits::complex_f* taub,
+ traits::complex_f* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_CGGQRF( &n, &m, &p, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(taua), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(taub), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void ggqrf( const integer_t n, const integer_t m, const integer_t p,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* taua,
+ traits::complex_d* b, const integer_t ldb, traits::complex_d* taub,
+ traits::complex_d* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGGQRF( &n, &m, &p, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(taua), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(taub), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggqrf_impl{};
@@ -257,6 +260,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,42 +37,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggrqf( const integer_t m, const integer_t p,
- const integer_t n, float* a, const integer_t lda, float* taua,
- float* b, const integer_t ldb, float* taub, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGGRQF( &m, &p, &n, a, &lda, taua, b, &ldb, taub, work, &lwork,
- &info );
- }
- inline void ggrqf( const integer_t m, const integer_t p,
- const integer_t n, double* a, const integer_t lda, double* taua,
- double* b, const integer_t ldb, double* taub, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DGGRQF( &m, &p, &n, a, &lda, taua, b, &ldb, taub, work, &lwork,
- &info );
- }
- inline void ggrqf( const integer_t m, const integer_t p,
- const integer_t n, traits::complex_f* a, const integer_t lda,
- traits::complex_f* taua, traits::complex_f* b,
- const integer_t ldb, traits::complex_f* taub,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGGRQF( &m, &p, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(taua), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(taub), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void ggrqf( const integer_t m, const integer_t p,
- const integer_t n, traits::complex_d* a, const integer_t lda,
- traits::complex_d* taua, traits::complex_d* b,
- const integer_t ldb, traits::complex_d* taub,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGGRQF( &m, &p, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(taua), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(taub), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void ggrqf( const integer_t m, const integer_t p, const integer_t n,
+ float* a, const integer_t lda, float* taua, float* b,
+ const integer_t ldb, float* taub, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGGRQF( &m, &p, &n, a, &lda, taua, b, &ldb, taub, work, &lwork,
+ &info );
 }
 
+inline void ggrqf( const integer_t m, const integer_t p, const integer_t n,
+ double* a, const integer_t lda, double* taua, double* b,
+ const integer_t ldb, double* taub, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DGGRQF( &m, &p, &n, a, &lda, taua, b, &ldb, taub, work, &lwork,
+ &info );
+}
+
+inline void ggrqf( const integer_t m, const integer_t p, const integer_t n,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* taua,
+ traits::complex_f* b, const integer_t ldb, traits::complex_f* taub,
+ traits::complex_f* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_CGGRQF( &m, &p, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(taua), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(taub), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void ggrqf( const integer_t m, const integer_t p, const integer_t n,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* taua,
+ traits::complex_d* b, const integer_t ldb, traits::complex_d* taub,
+ traits::complex_d* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGGRQF( &m, &p, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(taua), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(taub), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggrqf_impl{};
@@ -257,6 +260,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,62 +36,63 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggsvp( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t p, const integer_t n, float* a,
- const integer_t lda, float* b, const integer_t ldb,
- const float tola, const float tolb, integer_t& k, integer_t& l,
- float* u, const integer_t ldu, float* v, const integer_t ldv,
- float* q, const integer_t ldq, integer_t* iwork, float* tau,
- float* work, integer_t& info ) {
- LAPACK_SGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, a, &lda, b, &ldb,
- &tola, &tolb, &k, &l, u, &ldu, v, &ldv, q, &ldq, iwork, tau,
- work, &info );
- }
- inline void ggsvp( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t p, const integer_t n,
- double* a, const integer_t lda, double* b, const integer_t ldb,
- const double tola, const double tolb, integer_t& k, integer_t& l,
- double* u, const integer_t ldu, double* v, const integer_t ldv,
- double* q, const integer_t ldq, integer_t* iwork, double* tau,
- double* work, integer_t& info ) {
- LAPACK_DGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, a, &lda, b, &ldb,
- &tola, &tolb, &k, &l, u, &ldu, v, &ldv, q, &ldq, iwork, tau,
- work, &info );
- }
- inline void ggsvp( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t p, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* b,
- const integer_t ldb, const float tola, const float tolb,
- integer_t& k, integer_t& l, traits::complex_f* u,
- const integer_t ldu, traits::complex_f* v, const integer_t ldv,
- traits::complex_f* q, const integer_t ldq, integer_t* iwork,
- float* rwork, traits::complex_f* tau, traits::complex_f* work,
- integer_t& info ) {
- LAPACK_CGGSVP( &jobu, &jobv, &jobq, &m, &p, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &tola, &tolb, &k, &l, traits::complex_ptr(u), &ldu,
- traits::complex_ptr(v), &ldv, traits::complex_ptr(q), &ldq,
- iwork, rwork, traits::complex_ptr(tau),
- traits::complex_ptr(work), &info );
- }
- inline void ggsvp( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t p, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* b,
- const integer_t ldb, const double tola, const double tolb,
- integer_t& k, integer_t& l, traits::complex_d* u,
- const integer_t ldu, traits::complex_d* v, const integer_t ldv,
- traits::complex_d* q, const integer_t ldq, integer_t* iwork,
- double* rwork, traits::complex_d* tau, traits::complex_d* work,
- integer_t& info ) {
- LAPACK_ZGGSVP( &jobu, &jobv, &jobq, &m, &p, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &tola, &tolb, &k, &l, traits::complex_ptr(u), &ldu,
- traits::complex_ptr(v), &ldv, traits::complex_ptr(q), &ldq,
- iwork, rwork, traits::complex_ptr(tau),
- traits::complex_ptr(work), &info );
- }
+
+inline void ggsvp( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t p, const integer_t n, float* a,
+ const integer_t lda, float* b, const integer_t ldb, const float tola,
+ const float tolb, integer_t& k, integer_t& l, float* u,
+ const integer_t ldu, float* v, const integer_t ldv, float* q,
+ const integer_t ldq, integer_t* iwork, float* tau, float* work,
+ integer_t& info ) {
+ LAPACK_SGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, a, &lda, b, &ldb, &tola,
+ &tolb, &k, &l, u, &ldu, v, &ldv, q, &ldq, iwork, tau, work,
+ &info );
 }
 
+inline void ggsvp( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t p, const integer_t n, double* a,
+ const integer_t lda, double* b, const integer_t ldb,
+ const double tola, const double tolb, integer_t& k, integer_t& l,
+ double* u, const integer_t ldu, double* v, const integer_t ldv,
+ double* q, const integer_t ldq, integer_t* iwork, double* tau,
+ double* work, integer_t& info ) {
+ LAPACK_DGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, a, &lda, b, &ldb, &tola,
+ &tolb, &k, &l, u, &ldu, v, &ldv, q, &ldq, iwork, tau, work,
+ &info );
+}
+
+inline void ggsvp( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t p, const integer_t n,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, const float tola, const float tolb, integer_t& k,
+ integer_t& l, traits::complex_f* u, const integer_t ldu,
+ traits::complex_f* v, const integer_t ldv, traits::complex_f* q,
+ const integer_t ldq, integer_t* iwork, float* rwork,
+ traits::complex_f* tau, traits::complex_f* work, integer_t& info ) {
+ LAPACK_CGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, &tola, &tolb, &k, &l,
+ traits::complex_ptr(u), &ldu, traits::complex_ptr(v), &ldv,
+ traits::complex_ptr(q), &ldq, iwork, rwork,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &info );
+}
+
+inline void ggsvp( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t p, const integer_t n,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, const double tola, const double tolb,
+ integer_t& k, integer_t& l, traits::complex_d* u, const integer_t ldu,
+ traits::complex_d* v, const integer_t ldv, traits::complex_d* q,
+ const integer_t ldq, integer_t* iwork, double* rwork,
+ traits::complex_d* tau, traits::complex_d* work, integer_t& info ) {
+ LAPACK_ZGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, &tola, &tolb, &k, &l,
+ traits::complex_ptr(u), &ldu, traits::complex_ptr(v), &ldv,
+ traits::complex_ptr(q), &ldq, iwork, rwork,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggsvp_impl{};
@@ -342,6 +343,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,60 +36,61 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gtrfs( const char trans, const integer_t n,
- const integer_t nrhs, const float* dl, const float* d,
- const float* du, const float* dlf, const float* df,
- const float* duf, const float* du2, const integer_t* ipiv,
- const float* b, const integer_t ldb, float* x,
- const integer_t ldx, float* ferr, float* berr, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SGTRFS( &trans, &n, &nrhs, dl, d, du, dlf, df, duf, du2, ipiv,
- b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void gtrfs( const char trans, const integer_t n,
- const integer_t nrhs, const double* dl, const double* d,
- const double* du, const double* dlf, const double* df,
- const double* duf, const double* du2, const integer_t* ipiv,
- const double* b, const integer_t ldb, double* x,
- const integer_t ldx, double* ferr, double* berr, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DGTRFS( &trans, &n, &nrhs, dl, d, du, dlf, df, duf, du2, ipiv,
- b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void gtrfs( const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_f* dl,
- const traits::complex_f* d, const traits::complex_f* du,
- const traits::complex_f* dlf, const traits::complex_f* df,
- const traits::complex_f* duf, const traits::complex_f* du2,
- const integer_t* ipiv, const traits::complex_f* b,
- const integer_t ldb, traits::complex_f* x, const integer_t ldx,
- float* ferr, float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CGTRFS( &trans, &n, &nrhs, traits::complex_ptr(dl),
- traits::complex_ptr(d), traits::complex_ptr(du),
- traits::complex_ptr(dlf), traits::complex_ptr(df),
- traits::complex_ptr(duf), traits::complex_ptr(du2), ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
- inline void gtrfs( const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_d* dl,
- const traits::complex_d* d, const traits::complex_d* du,
- const traits::complex_d* dlf, const traits::complex_d* df,
- const traits::complex_d* duf, const traits::complex_d* du2,
- const integer_t* ipiv, const traits::complex_d* b,
- const integer_t ldb, traits::complex_d* x, const integer_t ldx,
- double* ferr, double* berr, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZGTRFS( &trans, &n, &nrhs, traits::complex_ptr(dl),
- traits::complex_ptr(d), traits::complex_ptr(du),
- traits::complex_ptr(dlf), traits::complex_ptr(df),
- traits::complex_ptr(duf), traits::complex_ptr(du2), ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void gtrfs( const char trans, const integer_t n, const integer_t nrhs,
+ const float* dl, const float* d, const float* du, const float* dlf,
+ const float* df, const float* duf, const float* du2,
+ const integer_t* ipiv, const float* b, const integer_t ldb, float* x,
+ const integer_t ldx, float* ferr, float* berr, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_SGTRFS( &trans, &n, &nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b,
+ &ldb, x, &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void gtrfs( const char trans, const integer_t n, const integer_t nrhs,
+ const double* dl, const double* d, const double* du,
+ const double* dlf, const double* df, const double* duf,
+ const double* du2, const integer_t* ipiv, const double* b,
+ const integer_t ldb, double* x, const integer_t ldx, double* ferr,
+ double* berr, double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGTRFS( &trans, &n, &nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b,
+ &ldb, x, &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void gtrfs( const char trans, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* dl, const traits::complex_f* d,
+ const traits::complex_f* du, const traits::complex_f* dlf,
+ const traits::complex_f* df, const traits::complex_f* duf,
+ const traits::complex_f* du2, const integer_t* ipiv,
+ const traits::complex_f* b, const integer_t ldb, traits::complex_f* x,
+ const integer_t ldx, float* ferr, float* berr,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CGTRFS( &trans, &n, &nrhs, traits::complex_ptr(dl),
+ traits::complex_ptr(d), traits::complex_ptr(du),
+ traits::complex_ptr(dlf), traits::complex_ptr(df),
+ traits::complex_ptr(duf), traits::complex_ptr(du2), ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx, ferr,
+ berr, traits::complex_ptr(work), rwork, &info );
 }
 
+inline void gtrfs( const char trans, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* dl, const traits::complex_d* d,
+ const traits::complex_d* du, const traits::complex_d* dlf,
+ const traits::complex_d* df, const traits::complex_d* duf,
+ const traits::complex_d* du2, const integer_t* ipiv,
+ const traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
+ const integer_t ldx, double* ferr, double* berr,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZGTRFS( &trans, &n, &nrhs, traits::complex_ptr(dl),
+ traits::complex_ptr(d), traits::complex_ptr(du),
+ traits::complex_ptr(dlf), traits::complex_ptr(df),
+ traits::complex_ptr(duf), traits::complex_ptr(du2), ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx, ferr,
+ berr, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gtrfs_impl{};
@@ -369,6 +370,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,42 +31,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gttrs( const char trans, const integer_t n,
- const integer_t nrhs, const float* dl, const float* d,
- const float* du, const float* du2, const integer_t* ipiv,
- float* b, const integer_t ldb, integer_t& info ) {
- LAPACK_SGTTRS( &trans, &n, &nrhs, dl, d, du, du2, ipiv, b, &ldb,
- &info );
- }
- inline void gttrs( const char trans, const integer_t n,
- const integer_t nrhs, const double* dl, const double* d,
- const double* du, const double* du2, const integer_t* ipiv,
- double* b, const integer_t ldb, integer_t& info ) {
- LAPACK_DGTTRS( &trans, &n, &nrhs, dl, d, du, du2, ipiv, b, &ldb,
- &info );
- }
- inline void gttrs( const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_f* dl,
- const traits::complex_f* d, const traits::complex_f* du,
- const traits::complex_f* du2, const integer_t* ipiv,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CGTTRS( &trans, &n, &nrhs, traits::complex_ptr(dl),
- traits::complex_ptr(d), traits::complex_ptr(du),
- traits::complex_ptr(du2), ipiv, traits::complex_ptr(b), &ldb,
- &info );
- }
- inline void gttrs( const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_d* dl,
- const traits::complex_d* d, const traits::complex_d* du,
- const traits::complex_d* du2, const integer_t* ipiv,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZGTTRS( &trans, &n, &nrhs, traits::complex_ptr(dl),
- traits::complex_ptr(d), traits::complex_ptr(du),
- traits::complex_ptr(du2), ipiv, traits::complex_ptr(b), &ldb,
- &info );
- }
+
+inline void gttrs( const char trans, const integer_t n, const integer_t nrhs,
+ const float* dl, const float* d, const float* du, const float* du2,
+ const integer_t* ipiv, float* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_SGTTRS( &trans, &n, &nrhs, dl, d, du, du2, ipiv, b, &ldb, &info );
+}
+
+inline void gttrs( const char trans, const integer_t n, const integer_t nrhs,
+ const double* dl, const double* d, const double* du,
+ const double* du2, const integer_t* ipiv, double* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_DGTTRS( &trans, &n, &nrhs, dl, d, du, du2, ipiv, b, &ldb, &info );
+}
+
+inline void gttrs( const char trans, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* dl, const traits::complex_f* d,
+ const traits::complex_f* du, const traits::complex_f* du2,
+ const integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CGTTRS( &trans, &n, &nrhs, traits::complex_ptr(dl),
+ traits::complex_ptr(d), traits::complex_ptr(du),
+ traits::complex_ptr(du2), ipiv, traits::complex_ptr(b), &ldb,
+ &info );
 }
 
+inline void gttrs( const char trans, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* dl, const traits::complex_d* d,
+ const traits::complex_d* du, const traits::complex_d* du2,
+ const integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZGTTRS( &trans, &n, &nrhs, traits::complex_ptr(dl),
+ traits::complex_ptr(d), traits::complex_ptr(du),
+ traits::complex_ptr(du2), ipiv, traits::complex_ptr(b), &ldb,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct gttrs_impl {
@@ -123,6 +126,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,26 +33,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hbgst( const char vect, const char uplo, const integer_t n,
- const integer_t ka, const integer_t kb, traits::complex_f* ab,
- const integer_t ldab, const traits::complex_f* bb,
- const integer_t ldbb, traits::complex_f* x, const integer_t ldx,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CHBGST( &vect, &uplo, &n, &ka, &kb, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(bb), &ldbb, traits::complex_ptr(x),
- &ldx, traits::complex_ptr(work), rwork, &info );
- }
- inline void hbgst( const char vect, const char uplo, const integer_t n,
- const integer_t ka, const integer_t kb, traits::complex_d* ab,
- const integer_t ldab, const traits::complex_d* bb,
- const integer_t ldbb, traits::complex_d* x, const integer_t ldx,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZHBGST( &vect, &uplo, &n, &ka, &kb, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(bb), &ldbb, traits::complex_ptr(x),
- &ldx, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void hbgst( const char vect, const char uplo, const integer_t n,
+ const integer_t ka, const integer_t kb, traits::complex_f* ab,
+ const integer_t ldab, const traits::complex_f* bb,
+ const integer_t ldbb, traits::complex_f* x, const integer_t ldx,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CHBGST( &vect, &uplo, &n, &ka, &kb, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(bb), &ldbb, traits::complex_ptr(x), &ldx,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void hbgst( const char vect, const char uplo, const integer_t n,
+ const integer_t ka, const integer_t kb, traits::complex_d* ab,
+ const integer_t ldab, const traits::complex_d* bb,
+ const integer_t ldbb, traits::complex_d* x, const integer_t ldx,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZHBGST( &vect, &uplo, &n, &ka, &kb, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(bb), &ldbb, traits::complex_ptr(x), &ldx,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hbgst_impl {
@@ -149,6 +152,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,24 +33,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hbtrd( const char vect, const char uplo, const integer_t n,
- const integer_t kd, traits::complex_f* ab, const integer_t ldab,
- float* d, float* e, traits::complex_f* q, const integer_t ldq,
- traits::complex_f* work, integer_t& info ) {
- LAPACK_CHBTRD( &vect, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
- d, e, traits::complex_ptr(q), &ldq, traits::complex_ptr(work),
- &info );
- }
- inline void hbtrd( const char vect, const char uplo, const integer_t n,
- const integer_t kd, traits::complex_d* ab, const integer_t ldab,
- double* d, double* e, traits::complex_d* q, const integer_t ldq,
- traits::complex_d* work, integer_t& info ) {
- LAPACK_ZHBTRD( &vect, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
- d, e, traits::complex_ptr(q), &ldq, traits::complex_ptr(work),
- &info );
- }
+
+inline void hbtrd( const char vect, const char uplo, const integer_t n,
+ const integer_t kd, traits::complex_f* ab, const integer_t ldab,
+ float* d, float* e, traits::complex_f* q, const integer_t ldq,
+ traits::complex_f* work, integer_t& info ) {
+ LAPACK_CHBTRD( &vect, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, d,
+ e, traits::complex_ptr(q), &ldq, traits::complex_ptr(work),
+ &info );
 }
 
+inline void hbtrd( const char vect, const char uplo, const integer_t n,
+ const integer_t kd, traits::complex_d* ab, const integer_t ldab,
+ double* d, double* e, traits::complex_d* q, const integer_t ldq,
+ traits::complex_d* work, integer_t& info ) {
+ LAPACK_ZHBTRD( &vect, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, d,
+ e, traits::complex_ptr(q), &ldq, traits::complex_ptr(work),
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hbtrd_impl {
@@ -137,6 +140,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,22 +33,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hecon( const char uplo, const integer_t n,
- const traits::complex_f* a, const integer_t lda,
- const integer_t* ipiv, const float anorm, float& rcond,
- traits::complex_f* work, integer_t& info ) {
- LAPACK_CHECON( &uplo, &n, traits::complex_ptr(a), &lda, ipiv, &anorm,
- &rcond, traits::complex_ptr(work), &info );
- }
- inline void hecon( const char uplo, const integer_t n,
- const traits::complex_d* a, const integer_t lda,
- const integer_t* ipiv, const double anorm, double& rcond,
- traits::complex_d* work, integer_t& info ) {
- LAPACK_ZHECON( &uplo, &n, traits::complex_ptr(a), &lda, ipiv, &anorm,
- &rcond, traits::complex_ptr(work), &info );
- }
+
+inline void hecon( const char uplo, const integer_t n,
+ const traits::complex_f* a, const integer_t lda,
+ const integer_t* ipiv, const float anorm, float& rcond,
+ traits::complex_f* work, integer_t& info ) {
+ LAPACK_CHECON( &uplo, &n, traits::complex_ptr(a), &lda, ipiv, &anorm,
+ &rcond, traits::complex_ptr(work), &info );
 }
 
+inline void hecon( const char uplo, const integer_t n,
+ const traits::complex_d* a, const integer_t lda,
+ const integer_t* ipiv, const double anorm, double& rcond,
+ traits::complex_d* work, integer_t& info ) {
+ LAPACK_ZHECON( &uplo, &n, traits::complex_ptr(a), &lda, ipiv, &anorm,
+ &rcond, traits::complex_ptr(work), &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hecon_impl {
@@ -129,6 +132,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,22 +31,23 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hegst( const integer_t itype, const char uplo,
- const integer_t n, traits::complex_f* a, const integer_t lda,
- const traits::complex_f* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_CHEGST( &itype, &uplo, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void hegst( const integer_t itype, const char uplo,
- const integer_t n, traits::complex_d* a, const integer_t lda,
- const traits::complex_d* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_ZHEGST( &itype, &uplo, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void hegst( const integer_t itype, const char uplo, const integer_t n,
+ traits::complex_f* a, const integer_t lda, const traits::complex_f* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_CHEGST( &itype, &uplo, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void hegst( const integer_t itype, const char uplo, const integer_t n,
+ traits::complex_d* a, const integer_t lda, const traits::complex_d* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_ZHEGST( &itype, &uplo, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hegst_impl {
@@ -84,6 +85,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,34 +33,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void herfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* af,
- const integer_t ldaf, const integer_t* ipiv,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float* ferr,
- float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CHERFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void herfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* af,
- const integer_t ldaf, const integer_t* ipiv,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double* ferr,
- double* berr, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZHERFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void herfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* af, const integer_t ldaf,
+ const integer_t* ipiv, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float* ferr, float* berr, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CHERFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void herfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* af, const integer_t ldaf,
+ const integer_t* ipiv, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZHERFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct herfs_impl {
@@ -185,6 +186,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hetrd( const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, float* d, float* e,
- traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CHETRD( &uplo, &n, traits::complex_ptr(a), &lda, d, e,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void hetrd( const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, double* d, double* e,
- traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZHETRD( &uplo, &n, traits::complex_ptr(a), &lda, d, e,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void hetrd( const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, float* d, float* e, traits::complex_f* tau,
+ traits::complex_f* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_CHETRD( &uplo, &n, traits::complex_ptr(a), &lda, d, e,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void hetrd( const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, double* d, double* e, traits::complex_d* tau,
+ traits::complex_d* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_ZHETRD( &uplo, &n, traits::complex_ptr(a), &lda, d, e,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hetrd_impl {
@@ -143,6 +144,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,20 +33,23 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hetrf( const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, integer_t* ipiv,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CHETRF( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void hetrf( const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, integer_t* ipiv,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZHETRF( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void hetrf( const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, integer_t* ipiv, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CHETRF( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void hetrf( const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, integer_t* ipiv, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZHETRF( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hetrf_impl {
@@ -112,6 +115,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,20 +33,23 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hetri( const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, const integer_t* ipiv,
- traits::complex_f* work, integer_t& info ) {
- LAPACK_CHETRI( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &info );
- }
- inline void hetri( const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, const integer_t* ipiv,
- traits::complex_d* work, integer_t& info ) {
- LAPACK_ZHETRI( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &info );
- }
+
+inline void hetri( const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, const integer_t* ipiv, traits::complex_f* work,
+ integer_t& info ) {
+ LAPACK_CHETRI( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &info );
 }
 
+inline void hetri( const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, const integer_t* ipiv, traits::complex_d* work,
+ integer_t& info ) {
+ LAPACK_ZHETRI( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hetri_impl {
@@ -115,6 +118,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,22 +31,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hetrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, const integer_t* ipiv, traits::complex_f* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_CHETRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void hetrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, const integer_t* ipiv, traits::complex_d* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_ZHETRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void hetrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* a, const integer_t lda,
+ const integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CHETRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void hetrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda,
+ const integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZHETRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hetrs_impl {
@@ -89,6 +92,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,54 +37,57 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hgeqz( const char job, const char compq, const char compz,
- const integer_t n, const integer_t ilo, const integer_t ihi,
- float* h, const integer_t ldh, float* t, const integer_t ldt,
- float* alphar, float* alphai, float* beta, float* q,
- const integer_t ldq, float* z, const integer_t ldz, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi, h, &ldh, t, &ldt,
- alphar, alphai, beta, q, &ldq, z, &ldz, work, &lwork, &info );
- }
- inline void hgeqz( const char job, const char compq, const char compz,
- const integer_t n, const integer_t ilo, const integer_t ihi,
- double* h, const integer_t ldh, double* t, const integer_t ldt,
- double* alphar, double* alphai, double* beta, double* q,
- const integer_t ldq, double* z, const integer_t ldz, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi, h, &ldh, t, &ldt,
- alphar, alphai, beta, q, &ldq, z, &ldz, work, &lwork, &info );
- }
- inline void hgeqz( const char job, const char compq, const char compz,
- const integer_t n, const integer_t ilo, const integer_t ihi,
- traits::complex_f* h, const integer_t ldh, traits::complex_f* t,
- const integer_t ldt, traits::complex_f* alpha,
- traits::complex_f* beta, traits::complex_f* q,
- const integer_t ldq, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t& info ) {
- LAPACK_CHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi,
- traits::complex_ptr(h), &ldh, traits::complex_ptr(t), &ldt,
- traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(q), &ldq, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
- inline void hgeqz( const char job, const char compq, const char compz,
- const integer_t n, const integer_t ilo, const integer_t ihi,
- traits::complex_d* h, const integer_t ldh, traits::complex_d* t,
- const integer_t ldt, traits::complex_d* alpha,
- traits::complex_d* beta, traits::complex_d* q,
- const integer_t ldq, traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t& info ) {
- LAPACK_ZHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi,
- traits::complex_ptr(h), &ldh, traits::complex_ptr(t), &ldt,
- traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(q), &ldq, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
+
+inline void hgeqz( const char job, const char compq, const char compz,
+ const integer_t n, const integer_t ilo, const integer_t ihi, float* h,
+ const integer_t ldh, float* t, const integer_t ldt, float* alphar,
+ float* alphai, float* beta, float* q, const integer_t ldq, float* z,
+ const integer_t ldz, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi, h, &ldh, t, &ldt,
+ alphar, alphai, beta, q, &ldq, z, &ldz, work, &lwork, &info );
+}
+
+inline void hgeqz( const char job, const char compq, const char compz,
+ const integer_t n, const integer_t ilo, const integer_t ihi,
+ double* h, const integer_t ldh, double* t, const integer_t ldt,
+ double* alphar, double* alphai, double* beta, double* q,
+ const integer_t ldq, double* z, const integer_t ldz, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi, h, &ldh, t, &ldt,
+ alphar, alphai, beta, q, &ldq, z, &ldz, work, &lwork, &info );
+}
+
+inline void hgeqz( const char job, const char compq, const char compz,
+ const integer_t n, const integer_t ilo, const integer_t ihi,
+ traits::complex_f* h, const integer_t ldh, traits::complex_f* t,
+ const integer_t ldt, traits::complex_f* alpha,
+ traits::complex_f* beta, traits::complex_f* q, const integer_t ldq,
+ traits::complex_f* z, const integer_t ldz, traits::complex_f* work,
+ const integer_t lwork, float* rwork, integer_t& info ) {
+ LAPACK_CHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi,
+ traits::complex_ptr(h), &ldh, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(alpha), traits::complex_ptr(beta),
+ traits::complex_ptr(q), &ldq, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, &info );
 }
 
+inline void hgeqz( const char job, const char compq, const char compz,
+ const integer_t n, const integer_t ilo, const integer_t ihi,
+ traits::complex_d* h, const integer_t ldh, traits::complex_d* t,
+ const integer_t ldt, traits::complex_d* alpha,
+ traits::complex_d* beta, traits::complex_d* q, const integer_t ldq,
+ traits::complex_d* z, const integer_t ldz, traits::complex_d* work,
+ const integer_t lwork, double* rwork, integer_t& info ) {
+ LAPACK_ZHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi,
+ traits::complex_ptr(h), &ldh, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(alpha), traits::complex_ptr(beta),
+ traits::complex_ptr(q), &ldq, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct hgeqz_impl{};
@@ -345,6 +348,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,32 +33,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* ap,
- const traits::complex_f* afp, const integer_t* ipiv,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float* ferr,
- float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CHPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void hprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* ap,
- const traits::complex_d* afp, const integer_t* ipiv,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double* ferr,
- double* berr, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZHPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void hprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* ap, const traits::complex_f* afp,
+ const integer_t* ipiv, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float* ferr, float* berr, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CHPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void hprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* ap, const traits::complex_d* afp,
+ const integer_t* ipiv, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZHPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hprfs_impl {
@@ -174,6 +175,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,22 +31,23 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* ap,
- const integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_CHPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void hptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* ap,
- const integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_ZHPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void hptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* ap, const integer_t* ipiv,
+ traits::complex_f* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_CHPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+inline void hptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* ap, const integer_t* ipiv,
+ traits::complex_d* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_ZHPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hptrs_impl {
@@ -86,6 +87,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,52 +36,55 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hsein( const char side, const char eigsrc, const char initv,
- logical_t* select, const integer_t n, const float* h,
- const integer_t ldh, float* wr, const float* wi, float* vl,
- const integer_t ldvl, float* vr, const integer_t ldvr,
- const integer_t mm, integer_t& m, float* work, integer_t* ifaill,
- integer_t* ifailr, integer_t& info ) {
- LAPACK_SHSEIN( &side, &eigsrc, &initv, select, &n, h, &ldh, wr, wi,
- vl, &ldvl, vr, &ldvr, &mm, &m, work, ifaill, ifailr, &info );
- }
- inline void hsein( const char side, const char eigsrc, const char initv,
- logical_t* select, const integer_t n, const double* h,
- const integer_t ldh, double* wr, const double* wi, double* vl,
- const integer_t ldvl, double* vr, const integer_t ldvr,
- const integer_t mm, integer_t& m, double* work, integer_t* ifaill,
- integer_t* ifailr, integer_t& info ) {
- LAPACK_DHSEIN( &side, &eigsrc, &initv, select, &n, h, &ldh, wr, wi,
- vl, &ldvl, vr, &ldvr, &mm, &m, work, ifaill, ifailr, &info );
- }
- inline void hsein( const char side, const char eigsrc, const char initv,
- const logical_t* select, const integer_t n,
- const traits::complex_f* h, const integer_t ldh,
- traits::complex_f* w, traits::complex_f* vl, const integer_t ldvl,
- traits::complex_f* vr, const integer_t ldvr, const integer_t mm,
- integer_t& m, traits::complex_f* work, float* rwork,
- integer_t* ifaill, integer_t* ifailr, integer_t& info ) {
- LAPACK_CHSEIN( &side, &eigsrc, &initv, select, &n,
- traits::complex_ptr(h), &ldh, traits::complex_ptr(w),
- traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, &mm, &m, traits::complex_ptr(work), rwork, ifaill,
- ifailr, &info );
- }
- inline void hsein( const char side, const char eigsrc, const char initv,
- const logical_t* select, const integer_t n,
- const traits::complex_d* h, const integer_t ldh,
- traits::complex_d* w, traits::complex_d* vl, const integer_t ldvl,
- traits::complex_d* vr, const integer_t ldvr, const integer_t mm,
- integer_t& m, traits::complex_d* work, double* rwork,
- integer_t* ifaill, integer_t* ifailr, integer_t& info ) {
- LAPACK_ZHSEIN( &side, &eigsrc, &initv, select, &n,
- traits::complex_ptr(h), &ldh, traits::complex_ptr(w),
- traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, &mm, &m, traits::complex_ptr(work), rwork, ifaill,
- ifailr, &info );
- }
+
+inline void hsein( const char side, const char eigsrc, const char initv,
+ logical_t* select, const integer_t n, const float* h,
+ const integer_t ldh, float* wr, const float* wi, float* vl,
+ const integer_t ldvl, float* vr, const integer_t ldvr,
+ const integer_t mm, integer_t& m, float* work, integer_t* ifaill,
+ integer_t* ifailr, integer_t& info ) {
+ LAPACK_SHSEIN( &side, &eigsrc, &initv, select, &n, h, &ldh, wr, wi, vl,
+ &ldvl, vr, &ldvr, &mm, &m, work, ifaill, ifailr, &info );
+}
+
+inline void hsein( const char side, const char eigsrc, const char initv,
+ logical_t* select, const integer_t n, const double* h,
+ const integer_t ldh, double* wr, const double* wi, double* vl,
+ const integer_t ldvl, double* vr, const integer_t ldvr,
+ const integer_t mm, integer_t& m, double* work, integer_t* ifaill,
+ integer_t* ifailr, integer_t& info ) {
+ LAPACK_DHSEIN( &side, &eigsrc, &initv, select, &n, h, &ldh, wr, wi, vl,
+ &ldvl, vr, &ldvr, &mm, &m, work, ifaill, ifailr, &info );
+}
+
+inline void hsein( const char side, const char eigsrc, const char initv,
+ const logical_t* select, const integer_t n,
+ const traits::complex_f* h, const integer_t ldh, traits::complex_f* w,
+ traits::complex_f* vl, const integer_t ldvl, traits::complex_f* vr,
+ const integer_t ldvr, const integer_t mm, integer_t& m,
+ traits::complex_f* work, float* rwork, integer_t* ifaill,
+ integer_t* ifailr, integer_t& info ) {
+ LAPACK_CHSEIN( &side, &eigsrc, &initv, select, &n, traits::complex_ptr(h),
+ &ldh, traits::complex_ptr(w), traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, &mm, &m,
+ traits::complex_ptr(work), rwork, ifaill, ifailr, &info );
 }
 
+inline void hsein( const char side, const char eigsrc, const char initv,
+ const logical_t* select, const integer_t n,
+ const traits::complex_d* h, const integer_t ldh, traits::complex_d* w,
+ traits::complex_d* vl, const integer_t ldvl, traits::complex_d* vr,
+ const integer_t ldvr, const integer_t mm, integer_t& m,
+ traits::complex_d* work, double* rwork, integer_t* ifaill,
+ integer_t* ifailr, integer_t& info ) {
+ LAPACK_ZHSEIN( &side, &eigsrc, &initv, select, &n, traits::complex_ptr(h),
+ &ldh, traits::complex_ptr(w), traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, &mm, &m,
+ traits::complex_ptr(work), rwork, ifaill, ifailr, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct hsein_impl{};
@@ -333,6 +336,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,42 +36,47 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hseqr( const char job, const char compz, const integer_t n,
- const integer_t ilo, const integer_t ihi, float* h,
- const integer_t ldh, float* wr, float* wi, float* z,
- const integer_t ldz, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SHSEQR( &job, &compz, &n, &ilo, &ihi, h, &ldh, wr, wi, z, &ldz,
- work, &lwork, &info );
- }
- inline void hseqr( const char job, const char compz, const integer_t n,
- const integer_t ilo, const integer_t ihi, double* h,
- const integer_t ldh, double* wr, double* wi, double* z,
- const integer_t ldz, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DHSEQR( &job, &compz, &n, &ilo, &ihi, h, &ldh, wr, wi, z, &ldz,
- work, &lwork, &info );
- }
- inline void hseqr( const char job, const char compz, const integer_t n,
- const integer_t ilo, const integer_t ihi, traits::complex_f* h,
- const integer_t ldh, traits::complex_f* w, traits::complex_f* z,
- const integer_t ldz, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CHSEQR( &job, &compz, &n, &ilo, &ihi, traits::complex_ptr(h),
- &ldh, traits::complex_ptr(w), traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void hseqr( const char job, const char compz, const integer_t n,
- const integer_t ilo, const integer_t ihi, traits::complex_d* h,
- const integer_t ldh, traits::complex_d* w, traits::complex_d* z,
- const integer_t ldz, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZHSEQR( &job, &compz, &n, &ilo, &ihi, traits::complex_ptr(h),
- &ldh, traits::complex_ptr(w), traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void hseqr( const char job, const char compz, const integer_t n,
+ const integer_t ilo, const integer_t ihi, float* h,
+ const integer_t ldh, float* wr, float* wi, float* z,
+ const integer_t ldz, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SHSEQR( &job, &compz, &n, &ilo, &ihi, h, &ldh, wr, wi, z, &ldz,
+ work, &lwork, &info );
 }
 
+inline void hseqr( const char job, const char compz, const integer_t n,
+ const integer_t ilo, const integer_t ihi, double* h,
+ const integer_t ldh, double* wr, double* wi, double* z,
+ const integer_t ldz, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DHSEQR( &job, &compz, &n, &ilo, &ihi, h, &ldh, wr, wi, z, &ldz,
+ work, &lwork, &info );
+}
+
+inline void hseqr( const char job, const char compz, const integer_t n,
+ const integer_t ilo, const integer_t ihi, traits::complex_f* h,
+ const integer_t ldh, traits::complex_f* w, traits::complex_f* z,
+ const integer_t ldz, traits::complex_f* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_CHSEQR( &job, &compz, &n, &ilo, &ihi, traits::complex_ptr(h), &ldh,
+ traits::complex_ptr(w), traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+inline void hseqr( const char job, const char compz, const integer_t n,
+ const integer_t ilo, const integer_t ihi, traits::complex_d* h,
+ const integer_t ldh, traits::complex_d* w, traits::complex_d* z,
+ const integer_t ldz, traits::complex_d* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_ZHSEQR( &job, &compz, &n, &ilo, &ihi, traits::complex_ptr(h), &ldh,
+ traits::complex_ptr(w), traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct hseqr_impl{};
@@ -244,6 +249,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,40 +34,43 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void labrd( const integer_t m, const integer_t n,
- const integer_t nb, float* a, const integer_t lda, float* d,
- float* e, float* tauq, float* taup, float* x, const integer_t ldx,
- float* y, const integer_t ldy ) {
- LAPACK_SLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y,
- &ldy );
- }
- inline void labrd( const integer_t m, const integer_t n,
- const integer_t nb, double* a, const integer_t lda, double* d,
- double* e, double* tauq, double* taup, double* x,
- const integer_t ldx, double* y, const integer_t ldy ) {
- LAPACK_DLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y,
- &ldy );
- }
- inline void labrd( const integer_t m, const integer_t n,
- const integer_t nb, traits::complex_f* a, const integer_t lda,
- float* d, float* e, traits::complex_f* tauq,
- traits::complex_f* taup, traits::complex_f* x,
- const integer_t ldx, traits::complex_f* y, const integer_t ldy ) {
- LAPACK_CLABRD( &m, &n, &nb, traits::complex_ptr(a), &lda, d, e,
- traits::complex_ptr(tauq), traits::complex_ptr(taup),
- traits::complex_ptr(x), &ldx, traits::complex_ptr(y), &ldy );
- }
- inline void labrd( const integer_t m, const integer_t n,
- const integer_t nb, traits::complex_d* a, const integer_t lda,
- double* d, double* e, traits::complex_d* tauq,
- traits::complex_d* taup, traits::complex_d* x,
- const integer_t ldx, traits::complex_d* y, const integer_t ldy ) {
- LAPACK_ZLABRD( &m, &n, &nb, traits::complex_ptr(a), &lda, d, e,
- traits::complex_ptr(tauq), traits::complex_ptr(taup),
- traits::complex_ptr(x), &ldx, traits::complex_ptr(y), &ldy );
- }
+
+inline void labrd( const integer_t m, const integer_t n, const integer_t nb,
+ float* a, const integer_t lda, float* d, float* e, float* tauq,
+ float* taup, float* x, const integer_t ldx, float* y,
+ const integer_t ldy ) {
+ LAPACK_SLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy );
+}
+
+inline void labrd( const integer_t m, const integer_t n, const integer_t nb,
+ double* a, const integer_t lda, double* d, double* e, double* tauq,
+ double* taup, double* x, const integer_t ldx, double* y,
+ const integer_t ldy ) {
+ LAPACK_DLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy );
+}
+
+inline void labrd( const integer_t m, const integer_t n, const integer_t nb,
+ traits::complex_f* a, const integer_t lda, float* d, float* e,
+ traits::complex_f* tauq, traits::complex_f* taup,
+ traits::complex_f* x, const integer_t ldx, traits::complex_f* y,
+ const integer_t ldy ) {
+ LAPACK_CLABRD( &m, &n, &nb, traits::complex_ptr(a), &lda, d, e,
+ traits::complex_ptr(tauq), traits::complex_ptr(taup),
+ traits::complex_ptr(x), &ldx, traits::complex_ptr(y), &ldy );
 }
 
+inline void labrd( const integer_t m, const integer_t n, const integer_t nb,
+ traits::complex_d* a, const integer_t lda, double* d, double* e,
+ traits::complex_d* tauq, traits::complex_d* taup,
+ traits::complex_d* x, const integer_t ldx, traits::complex_d* y,
+ const integer_t ldy ) {
+ LAPACK_ZLABRD( &m, &n, &nb, traits::complex_ptr(a), &lda, d, e,
+ traits::complex_ptr(tauq), traits::complex_ptr(taup),
+ traits::complex_ptr(x), &ldx, traits::complex_ptr(y), &ldy );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct labrd_impl{};
@@ -192,6 +195,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,26 +36,31 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void lacon( const integer_t n, float* v, float* x, integer_t* isgn,
- float& est, integer_t& kase ) {
- LAPACK_SLACON( &n, v, x, isgn, &est, &kase );
- }
- inline void lacon( const integer_t n, double* v, double* x,
- integer_t* isgn, double& est, integer_t& kase ) {
- LAPACK_DLACON( &n, v, x, isgn, &est, &kase );
- }
- inline void lacon( const integer_t n, traits::complex_f* v,
- traits::complex_f* x, float& est, integer_t& kase ) {
- LAPACK_CLACON( &n, traits::complex_ptr(v), traits::complex_ptr(x),
- &est, &kase );
- }
- inline void lacon( const integer_t n, traits::complex_d* v,
- traits::complex_d* x, double& est, integer_t& kase ) {
- LAPACK_ZLACON( &n, traits::complex_ptr(v), traits::complex_ptr(x),
- &est, &kase );
- }
+
+inline void lacon( const integer_t n, float* v, float* x, integer_t* isgn,
+ float& est, integer_t& kase ) {
+ LAPACK_SLACON( &n, v, x, isgn, &est, &kase );
 }
 
+inline void lacon( const integer_t n, double* v, double* x, integer_t* isgn,
+ double& est, integer_t& kase ) {
+ LAPACK_DLACON( &n, v, x, isgn, &est, &kase );
+}
+
+inline void lacon( const integer_t n, traits::complex_f* v,
+ traits::complex_f* x, float& est, integer_t& kase ) {
+ LAPACK_CLACON( &n, traits::complex_ptr(v), traits::complex_ptr(x), &est,
+ &kase );
+}
+
+inline void lacon( const integer_t n, traits::complex_d* v,
+ traits::complex_d* x, double& est, integer_t& kase ) {
+ LAPACK_ZLACON( &n, traits::complex_ptr(v), traits::complex_ptr(x), &est,
+ &kase );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct lacon_impl{};
@@ -169,6 +174,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,30 +33,30 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void laebz( const integer_t ijob, const integer_t nitmax,
- const integer_t n, const integer_t mmax, const integer_t minp,
- const integer_t nbmin, const float abstol, const float reltol,
- const float pivmin, const float* d, const float* e,
- const float* e2, integer_t* nval, float* ab, float* c,
- integer_t& mout, integer_t* nab, float* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_SLAEBZ( &ijob, &nitmax, &n, &mmax, &minp, &nbmin, &abstol,
- &reltol, &pivmin, d, e, e2, nval, ab, c, &mout, nab, work,
- iwork, &info );
- }
- inline void laebz( const integer_t ijob, const integer_t nitmax,
- const integer_t n, const integer_t mmax, const integer_t minp,
- const integer_t nbmin, const double abstol, const double reltol,
- const double pivmin, const double* d, const double* e,
- const double* e2, integer_t* nval, double* ab, double* c,
- integer_t& mout, integer_t* nab, double* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_DLAEBZ( &ijob, &nitmax, &n, &mmax, &minp, &nbmin, &abstol,
- &reltol, &pivmin, d, e, e2, nval, ab, c, &mout, nab, work,
- iwork, &info );
- }
+
+inline void laebz( const integer_t ijob, const integer_t nitmax,
+ const integer_t n, const integer_t mmax, const integer_t minp,
+ const integer_t nbmin, const float abstol, const float reltol,
+ const float pivmin, const float* d, const float* e, const float* e2,
+ integer_t* nval, float* ab, float* c, integer_t& mout, integer_t* nab,
+ float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SLAEBZ( &ijob, &nitmax, &n, &mmax, &minp, &nbmin, &abstol, &reltol,
+ &pivmin, d, e, e2, nval, ab, c, &mout, nab, work, iwork, &info );
 }
 
+inline void laebz( const integer_t ijob, const integer_t nitmax,
+ const integer_t n, const integer_t mmax, const integer_t minp,
+ const integer_t nbmin, const double abstol, const double reltol,
+ const double pivmin, const double* d, const double* e,
+ const double* e2, integer_t* nval, double* ab, double* c,
+ integer_t& mout, integer_t* nab, double* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DLAEBZ( &ijob, &nitmax, &n, &mmax, &minp, &nbmin, &abstol, &reltol,
+ &pivmin, d, e, e2, nval, ab, c, &mout, nab, work, iwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct laebz_impl {
@@ -195,6 +195,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,36 +36,39 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void larz( const char side, const integer_t m, const integer_t n,
- const integer_t l, const float* v, const integer_t incv,
- const float tau, float* c, const integer_t ldc, float* work ) {
- LAPACK_SLARZ( &side, &m, &n, &l, v, &incv, &tau, c, &ldc, work );
- }
- inline void larz( const char side, const integer_t m, const integer_t n,
- const integer_t l, const double* v, const integer_t incv,
- const double tau, double* c, const integer_t ldc, double* work ) {
- LAPACK_DLARZ( &side, &m, &n, &l, v, &incv, &tau, c, &ldc, work );
- }
- inline void larz( const char side, const integer_t m, const integer_t n,
- const integer_t l, const traits::complex_f* v,
- const integer_t incv, const traits::complex_f tau,
- traits::complex_f* c, const integer_t ldc,
- traits::complex_f* work ) {
- LAPACK_CLARZ( &side, &m, &n, &l, traits::complex_ptr(v), &incv,
- traits::complex_ptr(&tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work) );
- }
- inline void larz( const char side, const integer_t m, const integer_t n,
- const integer_t l, const traits::complex_d* v,
- const integer_t incv, const traits::complex_d tau,
- traits::complex_d* c, const integer_t ldc,
- traits::complex_d* work ) {
- LAPACK_ZLARZ( &side, &m, &n, &l, traits::complex_ptr(v), &incv,
- traits::complex_ptr(&tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work) );
- }
+
+inline void larz( const char side, const integer_t m, const integer_t n,
+ const integer_t l, const float* v, const integer_t incv,
+ const float tau, float* c, const integer_t ldc, float* work ) {
+ LAPACK_SLARZ( &side, &m, &n, &l, v, &incv, &tau, c, &ldc, work );
 }
 
+inline void larz( const char side, const integer_t m, const integer_t n,
+ const integer_t l, const double* v, const integer_t incv,
+ const double tau, double* c, const integer_t ldc, double* work ) {
+ LAPACK_DLARZ( &side, &m, &n, &l, v, &incv, &tau, c, &ldc, work );
+}
+
+inline void larz( const char side, const integer_t m, const integer_t n,
+ const integer_t l, const traits::complex_f* v, const integer_t incv,
+ const traits::complex_f tau, traits::complex_f* c,
+ const integer_t ldc, traits::complex_f* work ) {
+ LAPACK_CLARZ( &side, &m, &n, &l, traits::complex_ptr(v), &incv,
+ traits::complex_ptr(&tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work) );
+}
+
+inline void larz( const char side, const integer_t m, const integer_t n,
+ const integer_t l, const traits::complex_d* v, const integer_t incv,
+ const traits::complex_d tau, traits::complex_d* c,
+ const integer_t ldc, traits::complex_d* work ) {
+ LAPACK_ZLARZ( &side, &m, &n, &l, traits::complex_ptr(v), &incv,
+ traits::complex_ptr(&tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work) );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct larz_impl{};
@@ -230,6 +233,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,32 +34,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void latrd( const char uplo, const integer_t n, const integer_t nb,
- float* a, const integer_t lda, float* e, float* tau, float* w,
- const integer_t ldw ) {
- LAPACK_SLATRD( &uplo, &n, &nb, a, &lda, e, tau, w, &ldw );
- }
- inline void latrd( const char uplo, const integer_t n, const integer_t nb,
- double* a, const integer_t lda, double* e, double* tau, double* w,
- const integer_t ldw ) {
- LAPACK_DLATRD( &uplo, &n, &nb, a, &lda, e, tau, w, &ldw );
- }
- inline void latrd( const char uplo, const integer_t n, const integer_t nb,
- traits::complex_f* a, const integer_t lda, float* e,
- traits::complex_f* tau, traits::complex_f* w,
- const integer_t ldw ) {
- LAPACK_CLATRD( &uplo, &n, &nb, traits::complex_ptr(a), &lda, e,
- traits::complex_ptr(tau), traits::complex_ptr(w), &ldw );
- }
- inline void latrd( const char uplo, const integer_t n, const integer_t nb,
- traits::complex_d* a, const integer_t lda, double* e,
- traits::complex_d* tau, traits::complex_d* w,
- const integer_t ldw ) {
- LAPACK_ZLATRD( &uplo, &n, &nb, traits::complex_ptr(a), &lda, e,
- traits::complex_ptr(tau), traits::complex_ptr(w), &ldw );
- }
+
+inline void latrd( const char uplo, const integer_t n, const integer_t nb,
+ float* a, const integer_t lda, float* e, float* tau, float* w,
+ const integer_t ldw ) {
+ LAPACK_SLATRD( &uplo, &n, &nb, a, &lda, e, tau, w, &ldw );
+}
+
+inline void latrd( const char uplo, const integer_t n, const integer_t nb,
+ double* a, const integer_t lda, double* e, double* tau, double* w,
+ const integer_t ldw ) {
+ LAPACK_DLATRD( &uplo, &n, &nb, a, &lda, e, tau, w, &ldw );
+}
+
+inline void latrd( const char uplo, const integer_t n, const integer_t nb,
+ traits::complex_f* a, const integer_t lda, float* e,
+ traits::complex_f* tau, traits::complex_f* w, const integer_t ldw ) {
+ LAPACK_CLATRD( &uplo, &n, &nb, traits::complex_ptr(a), &lda, e,
+ traits::complex_ptr(tau), traits::complex_ptr(w), &ldw );
 }
 
+inline void latrd( const char uplo, const integer_t n, const integer_t nb,
+ traits::complex_d* a, const integer_t lda, double* e,
+ traits::complex_d* tau, traits::complex_d* w, const integer_t ldw ) {
+ LAPACK_ZLATRD( &uplo, &n, &nb, traits::complex_ptr(a), &lda, e,
+ traits::complex_ptr(tau), traits::complex_ptr(w), &ldw );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct latrd_impl{};
@@ -142,6 +145,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,38 +34,41 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void latrs( const char uplo, const char trans, const char diag,
- const char normin, const integer_t n, const float* a,
- const integer_t lda, float* x, float& scale, float* cnorm,
- integer_t& info ) {
- LAPACK_SLATRS( &uplo, &trans, &diag, &normin, &n, a, &lda, x, &scale,
- cnorm, &info );
- }
- inline void latrs( const char uplo, const char trans, const char diag,
- const char normin, const integer_t n, const double* a,
- const integer_t lda, double* x, double& scale, double* cnorm,
- integer_t& info ) {
- LAPACK_DLATRS( &uplo, &trans, &diag, &normin, &n, a, &lda, x, &scale,
- cnorm, &info );
- }
- inline void latrs( const char uplo, const char trans, const char diag,
- const char normin, const integer_t n, const traits::complex_f* a,
- const integer_t lda, traits::complex_f* x, float& scale,
- float* cnorm, integer_t& info ) {
- LAPACK_CLATRS( &uplo, &trans, &diag, &normin, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(x), &scale,
- cnorm, &info );
- }
- inline void latrs( const char uplo, const char trans, const char diag,
- const char normin, const integer_t n, const traits::complex_d* a,
- const integer_t lda, traits::complex_d* x, double& scale,
- double* cnorm, integer_t& info ) {
- LAPACK_ZLATRS( &uplo, &trans, &diag, &normin, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(x), &scale,
- cnorm, &info );
- }
+
+inline void latrs( const char uplo, const char trans, const char diag,
+ const char normin, const integer_t n, const float* a,
+ const integer_t lda, float* x, float& scale, float* cnorm,
+ integer_t& info ) {
+ LAPACK_SLATRS( &uplo, &trans, &diag, &normin, &n, a, &lda, x, &scale,
+ cnorm, &info );
+}
+
+inline void latrs( const char uplo, const char trans, const char diag,
+ const char normin, const integer_t n, const double* a,
+ const integer_t lda, double* x, double& scale, double* cnorm,
+ integer_t& info ) {
+ LAPACK_DLATRS( &uplo, &trans, &diag, &normin, &n, a, &lda, x, &scale,
+ cnorm, &info );
+}
+
+inline void latrs( const char uplo, const char trans, const char diag,
+ const char normin, const integer_t n, const traits::complex_f* a,
+ const integer_t lda, traits::complex_f* x, float& scale, float* cnorm,
+ integer_t& info ) {
+ LAPACK_CLATRS( &uplo, &trans, &diag, &normin, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(x), &scale, cnorm, &info );
 }
 
+inline void latrs( const char uplo, const char trans, const char diag,
+ const char normin, const integer_t n, const traits::complex_d* a,
+ const integer_t lda, traits::complex_d* x, double& scale,
+ double* cnorm, integer_t& info ) {
+ LAPACK_ZLATRS( &uplo, &trans, &diag, &normin, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(x), &scale, cnorm, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct latrs_impl{};
@@ -147,6 +150,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,30 +36,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void latrz( const integer_t m, const integer_t n,
- const integer_t l, float* a, const integer_t lda, float* tau,
- float* work ) {
- LAPACK_SLATRZ( &m, &n, &l, a, &lda, tau, work );
- }
- inline void latrz( const integer_t m, const integer_t n,
- const integer_t l, double* a, const integer_t lda, double* tau,
- double* work ) {
- LAPACK_DLATRZ( &m, &n, &l, a, &lda, tau, work );
- }
- inline void latrz( const integer_t m, const integer_t n,
- const integer_t l, traits::complex_f* a, const integer_t lda,
- traits::complex_f* tau, traits::complex_f* work ) {
- LAPACK_CLATRZ( &m, &n, &l, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work) );
- }
- inline void latrz( const integer_t m, const integer_t n,
- const integer_t l, traits::complex_d* a, const integer_t lda,
- traits::complex_d* tau, traits::complex_d* work ) {
- LAPACK_ZLATRZ( &m, &n, &l, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work) );
- }
+
+inline void latrz( const integer_t m, const integer_t n, const integer_t l,
+ float* a, const integer_t lda, float* tau, float* work ) {
+ LAPACK_SLATRZ( &m, &n, &l, a, &lda, tau, work );
 }
 
+inline void latrz( const integer_t m, const integer_t n, const integer_t l,
+ double* a, const integer_t lda, double* tau, double* work ) {
+ LAPACK_DLATRZ( &m, &n, &l, a, &lda, tau, work );
+}
+
+inline void latrz( const integer_t m, const integer_t n, const integer_t l,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* tau,
+ traits::complex_f* work ) {
+ LAPACK_CLATRZ( &m, &n, &l, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work) );
+}
+
+inline void latrz( const integer_t m, const integer_t n, const integer_t l,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* tau,
+ traits::complex_d* work ) {
+ LAPACK_ZLATRZ( &m, &n, &l, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work) );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct latrz_impl{};
@@ -179,6 +182,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,18 +33,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void opgtr( const char uplo, const integer_t n, const float* ap,
- const float* tau, float* q, const integer_t ldq, float* work,
- integer_t& info ) {
- LAPACK_SOPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info );
- }
- inline void opgtr( const char uplo, const integer_t n, const double* ap,
- const double* tau, double* q, const integer_t ldq, double* work,
- integer_t& info ) {
- LAPACK_DOPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info );
- }
+
+inline void opgtr( const char uplo, const integer_t n, const float* ap,
+ const float* tau, float* q, const integer_t ldq, float* work,
+ integer_t& info ) {
+ LAPACK_SOPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info );
 }
 
+inline void opgtr( const char uplo, const integer_t n, const double* ap,
+ const double* tau, double* q, const integer_t ldq, double* work,
+ integer_t& info ) {
+ LAPACK_DOPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct opgtr_impl {
@@ -127,6 +130,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,22 +33,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void opmtr( const char side, const char uplo, const char trans,
- const integer_t m, const integer_t n, const float* ap,
- const float* tau, float* c, const integer_t ldc, float* work,
- integer_t& info ) {
- LAPACK_SOPMTR( &side, &uplo, &trans, &m, &n, ap, tau, c, &ldc, work,
- &info );
- }
- inline void opmtr( const char side, const char uplo, const char trans,
- const integer_t m, const integer_t n, const double* ap,
- const double* tau, double* c, const integer_t ldc, double* work,
- integer_t& info ) {
- LAPACK_DOPMTR( &side, &uplo, &trans, &m, &n, ap, tau, c, &ldc, work,
- &info );
- }
+
+inline void opmtr( const char side, const char uplo, const char trans,
+ const integer_t m, const integer_t n, const float* ap,
+ const float* tau, float* c, const integer_t ldc, float* work,
+ integer_t& info ) {
+ LAPACK_SOPMTR( &side, &uplo, &trans, &m, &n, ap, tau, c, &ldc, work,
+ &info );
 }
 
+inline void opmtr( const char side, const char uplo, const char trans,
+ const integer_t m, const integer_t n, const double* ap,
+ const double* tau, double* c, const integer_t ldc, double* work,
+ integer_t& info ) {
+ LAPACK_DOPMTR( &side, &uplo, &trans, &m, &n, ap, tau, c, &ldc, work,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct opmtr_impl {
@@ -138,6 +141,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,20 +34,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void orgbr( const char vect, const integer_t m, const integer_t n,
- const integer_t k, float* a, const integer_t lda,
- const float* tau, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
- inline void orgbr( const char vect, const integer_t m, const integer_t n,
- const integer_t k, double* a, const integer_t lda,
- const double* tau, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
+
+inline void orgbr( const char vect, const integer_t m, const integer_t n,
+ const integer_t k, float* a, const integer_t lda, const float* tau,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SORGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void orgbr( const char vect, const integer_t m, const integer_t n,
+ const integer_t k, double* a, const integer_t lda, const double* tau,
+ double* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_DORGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct orgbr_impl {
@@ -127,6 +128,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,20 +34,22 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void orghr( const integer_t n, const integer_t ilo,
- const integer_t ihi, float* a, const integer_t lda,
- const float* tau, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info );
- }
- inline void orghr( const integer_t n, const integer_t ilo,
- const integer_t ihi, double* a, const integer_t lda,
- const double* tau, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info );
- }
+
+inline void orghr( const integer_t n, const integer_t ilo,
+ const integer_t ihi, float* a, const integer_t lda, const float* tau,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SORGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void orghr( const integer_t n, const integer_t ilo,
+ const integer_t ihi, double* a, const integer_t lda,
+ const double* tau, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct orghr_impl {
@@ -126,6 +128,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,20 +34,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void orglq( const integer_t m, const integer_t n,
- const integer_t k, float* a, const integer_t lda,
- const float* tau, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
- inline void orglq( const integer_t m, const integer_t n,
- const integer_t k, double* a, const integer_t lda,
- const double* tau, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
+
+inline void orglq( const integer_t m, const integer_t n, const integer_t k,
+ float* a, const integer_t lda, const float* tau, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SORGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void orglq( const integer_t m, const integer_t n, const integer_t k,
+ double* a, const integer_t lda, const double* tau, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DORGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct orglq_impl {
@@ -126,6 +127,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,20 +34,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void orgql( const integer_t m, const integer_t n,
- const integer_t k, float* a, const integer_t lda,
- const float* tau, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
- inline void orgql( const integer_t m, const integer_t n,
- const integer_t k, double* a, const integer_t lda,
- const double* tau, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
+
+inline void orgql( const integer_t m, const integer_t n, const integer_t k,
+ float* a, const integer_t lda, const float* tau, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SORGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void orgql( const integer_t m, const integer_t n, const integer_t k,
+ double* a, const integer_t lda, const double* tau, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DORGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct orgql_impl {
@@ -126,6 +127,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,20 +34,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void orgqr( const integer_t m, const integer_t n,
- const integer_t k, float* a, const integer_t lda,
- const float* tau, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
- inline void orgqr( const integer_t m, const integer_t n,
- const integer_t k, double* a, const integer_t lda,
- const double* tau, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
+
+inline void orgqr( const integer_t m, const integer_t n, const integer_t k,
+ float* a, const integer_t lda, const float* tau, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SORGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void orgqr( const integer_t m, const integer_t n, const integer_t k,
+ double* a, const integer_t lda, const double* tau, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DORGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct orgqr_impl {
@@ -126,6 +127,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,20 +34,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void orgrq( const integer_t m, const integer_t n,
- const integer_t k, float* a, const integer_t lda,
- const float* tau, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
- inline void orgrq( const integer_t m, const integer_t n,
- const integer_t k, double* a, const integer_t lda,
- const double* tau, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
- }
+
+inline void orgrq( const integer_t m, const integer_t n, const integer_t k,
+ float* a, const integer_t lda, const float* tau, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SORGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void orgrq( const integer_t m, const integer_t n, const integer_t k,
+ double* a, const integer_t lda, const double* tau, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DORGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct orgrq_impl {
@@ -126,6 +127,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,18 +34,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void orgtr( const char uplo, const integer_t n, float* a,
- const integer_t lda, const float* tau, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SORGTR( &uplo, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void orgtr( const char uplo, const integer_t n, double* a,
- const integer_t lda, const double* tau, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DORGTR( &uplo, &n, a, &lda, tau, work, &lwork, &info );
- }
+
+inline void orgtr( const char uplo, const integer_t n, float* a,
+ const integer_t lda, const float* tau, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SORGTR( &uplo, &n, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void orgtr( const char uplo, const integer_t n, double* a,
+ const integer_t lda, const double* tau, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DORGTR( &uplo, &n, a, &lda, tau, work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct orgtr_impl {
@@ -122,6 +125,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ormbr( const char vect, const char side, const char trans,
- const integer_t m, const integer_t n, const integer_t k,
- const float* a, const integer_t lda, const float* tau, float* c,
- const integer_t ldc, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORMBR( &vect, &side, &trans, &m, &n, &k, a, &lda, tau, c,
- &ldc, work, &lwork, &info );
- }
- inline void ormbr( const char vect, const char side, const char trans,
- const integer_t m, const integer_t n, const integer_t k,
- const double* a, const integer_t lda, const double* tau,
- double* c, const integer_t ldc, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DORMBR( &vect, &side, &trans, &m, &n, &k, a, &lda, tau, c,
- &ldc, work, &lwork, &info );
- }
+
+inline void ormbr( const char vect, const char side, const char trans,
+ const integer_t m, const integer_t n, const integer_t k,
+ const float* a, const integer_t lda, const float* tau, float* c,
+ const integer_t ldc, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SORMBR( &vect, &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc,
+ work, &lwork, &info );
 }
 
+inline void ormbr( const char vect, const char side, const char trans,
+ const integer_t m, const integer_t n, const integer_t k,
+ const double* a, const integer_t lda, const double* tau, double* c,
+ const integer_t ldc, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORMBR( &vect, &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc,
+ work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ormbr_impl {
@@ -152,6 +155,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ormhr( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t ilo, const integer_t ihi,
- const float* a, const integer_t lda, const float* tau, float* c,
- const integer_t ldc, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORMHR( &side, &trans, &m, &n, &ilo, &ihi, a, &lda, tau, c,
- &ldc, work, &lwork, &info );
- }
- inline void ormhr( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t ilo, const integer_t ihi,
- const double* a, const integer_t lda, const double* tau,
- double* c, const integer_t ldc, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DORMHR( &side, &trans, &m, &n, &ilo, &ihi, a, &lda, tau, c,
- &ldc, work, &lwork, &info );
- }
+
+inline void ormhr( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t ilo, const integer_t ihi,
+ const float* a, const integer_t lda, const float* tau, float* c,
+ const integer_t ldc, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SORMHR( &side, &trans, &m, &n, &ilo, &ihi, a, &lda, tau, c, &ldc,
+ work, &lwork, &info );
 }
 
+inline void ormhr( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t ilo, const integer_t ihi,
+ const double* a, const integer_t lda, const double* tau, double* c,
+ const integer_t ldc, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORMHR( &side, &trans, &m, &n, &ilo, &ihi, a, &lda, tau, c, &ldc,
+ work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ormhr_impl {
@@ -155,6 +158,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,26 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ormlq( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const float* a,
- const integer_t lda, const float* tau, float* c,
- const integer_t ldc, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORMLQ( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
- &lwork, &info );
- }
- inline void ormlq( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const double* a,
- const integer_t lda, const double* tau, double* c,
- const integer_t ldc, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORMLQ( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
- &lwork, &info );
- }
+
+inline void ormlq( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const float* a,
+ const integer_t lda, const float* tau, float* c, const integer_t ldc,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SORMLQ( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
 }
 
+inline void ormlq( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const double* a,
+ const integer_t lda, const double* tau, double* c,
+ const integer_t ldc, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORMLQ( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ormlq_impl {
@@ -151,6 +153,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,26 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ormql( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const float* a,
- const integer_t lda, const float* tau, float* c,
- const integer_t ldc, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORMQL( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
- &lwork, &info );
- }
- inline void ormql( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const double* a,
- const integer_t lda, const double* tau, double* c,
- const integer_t ldc, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORMQL( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
- &lwork, &info );
- }
+
+inline void ormql( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const float* a,
+ const integer_t lda, const float* tau, float* c, const integer_t ldc,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SORMQL( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
 }
 
+inline void ormql( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const double* a,
+ const integer_t lda, const double* tau, double* c,
+ const integer_t ldc, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORMQL( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ormql_impl {
@@ -150,6 +152,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,26 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ormqr( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const float* a,
- const integer_t lda, const float* tau, float* c,
- const integer_t ldc, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORMQR( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
- &lwork, &info );
- }
- inline void ormqr( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const double* a,
- const integer_t lda, const double* tau, double* c,
- const integer_t ldc, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORMQR( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
- &lwork, &info );
- }
+
+inline void ormqr( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const float* a,
+ const integer_t lda, const float* tau, float* c, const integer_t ldc,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SORMQR( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
 }
 
+inline void ormqr( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const double* a,
+ const integer_t lda, const double* tau, double* c,
+ const integer_t ldc, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORMQR( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ormqr_impl {
@@ -150,6 +152,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,26 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ormrq( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const float* a,
- const integer_t lda, const float* tau, float* c,
- const integer_t ldc, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORMRQ( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
- &lwork, &info );
- }
- inline void ormrq( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const double* a,
- const integer_t lda, const double* tau, double* c,
- const integer_t ldc, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORMRQ( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
- &lwork, &info );
- }
+
+inline void ormrq( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const float* a,
+ const integer_t lda, const float* tau, float* c, const integer_t ldc,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SORMRQ( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
 }
 
+inline void ormrq( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const double* a,
+ const integer_t lda, const double* tau, double* c,
+ const integer_t ldc, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORMRQ( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ormrq_impl {
@@ -151,6 +153,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ormrz( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const integer_t l,
- const float* a, const integer_t lda, const float* tau, float* c,
- const integer_t ldc, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORMRZ( &side, &trans, &m, &n, &k, &l, a, &lda, tau, c, &ldc,
- work, &lwork, &info );
- }
- inline void ormrz( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const integer_t l,
- const double* a, const integer_t lda, const double* tau,
- double* c, const integer_t ldc, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DORMRZ( &side, &trans, &m, &n, &k, &l, a, &lda, tau, c, &ldc,
- work, &lwork, &info );
- }
+
+inline void ormrz( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const integer_t l,
+ const float* a, const integer_t lda, const float* tau, float* c,
+ const integer_t ldc, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SORMRZ( &side, &trans, &m, &n, &k, &l, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
 }
 
+inline void ormrz( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const integer_t l,
+ const double* a, const integer_t lda, const double* tau, double* c,
+ const integer_t ldc, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORMRZ( &side, &trans, &m, &n, &k, &l, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ormrz_impl {
@@ -148,6 +151,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,26 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ormtr( const char side, const char uplo, const char trans,
- const integer_t m, const integer_t n, const float* a,
- const integer_t lda, const float* tau, float* c,
- const integer_t ldc, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SORMTR( &side, &uplo, &trans, &m, &n, a, &lda, tau, c, &ldc,
- work, &lwork, &info );
- }
- inline void ormtr( const char side, const char uplo, const char trans,
- const integer_t m, const integer_t n, const double* a,
- const integer_t lda, const double* tau, double* c,
- const integer_t ldc, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DORMTR( &side, &uplo, &trans, &m, &n, a, &lda, tau, c, &ldc,
- work, &lwork, &info );
- }
+
+inline void ormtr( const char side, const char uplo, const char trans,
+ const integer_t m, const integer_t n, const float* a,
+ const integer_t lda, const float* tau, float* c, const integer_t ldc,
+ float* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_SORMTR( &side, &uplo, &trans, &m, &n, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
 }
 
+inline void ormtr( const char side, const char uplo, const char trans,
+ const integer_t m, const integer_t n, const double* a,
+ const integer_t lda, const double* tau, double* c,
+ const integer_t ldc, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DORMTR( &side, &uplo, &trans, &m, &n, a, &lda, tau, c, &ldc, work,
+ &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ormtr_impl {
@@ -150,6 +152,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,34 +36,39 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pbcon( const char uplo, const integer_t n, const integer_t kd,
- const float* ab, const integer_t ldab, const float anorm,
- float& rcond, float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SPBCON( &uplo, &n, &kd, ab, &ldab, &anorm, &rcond, work, iwork,
- &info );
- }
- inline void pbcon( const char uplo, const integer_t n, const integer_t kd,
- const double* ab, const integer_t ldab, const double anorm,
- double& rcond, double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DPBCON( &uplo, &n, &kd, ab, &ldab, &anorm, &rcond, work, iwork,
- &info );
- }
- inline void pbcon( const char uplo, const integer_t n, const integer_t kd,
- const traits::complex_f* ab, const integer_t ldab,
- const float anorm, float& rcond, traits::complex_f* work,
- float* rwork, integer_t& info ) {
- LAPACK_CPBCON( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &anorm,
- &rcond, traits::complex_ptr(work), rwork, &info );
- }
- inline void pbcon( const char uplo, const integer_t n, const integer_t kd,
- const traits::complex_d* ab, const integer_t ldab,
- const double anorm, double& rcond, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZPBCON( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &anorm,
- &rcond, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void pbcon( const char uplo, const integer_t n, const integer_t kd,
+ const float* ab, const integer_t ldab, const float anorm,
+ float& rcond, float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SPBCON( &uplo, &n, &kd, ab, &ldab, &anorm, &rcond, work, iwork,
+ &info );
 }
 
+inline void pbcon( const char uplo, const integer_t n, const integer_t kd,
+ const double* ab, const integer_t ldab, const double anorm,
+ double& rcond, double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DPBCON( &uplo, &n, &kd, ab, &ldab, &anorm, &rcond, work, iwork,
+ &info );
+}
+
+inline void pbcon( const char uplo, const integer_t n, const integer_t kd,
+ const traits::complex_f* ab, const integer_t ldab, const float anorm,
+ float& rcond, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CPBCON( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &anorm,
+ &rcond, traits::complex_ptr(work), rwork, &info );
+}
+
+inline void pbcon( const char uplo, const integer_t n, const integer_t kd,
+ const traits::complex_d* ab, const integer_t ldab, const double anorm,
+ double& rcond, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZPBCON( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &anorm,
+ &rcond, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pbcon_impl{};
@@ -209,6 +214,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,30 +34,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pbequ( const char uplo, const integer_t n, const integer_t kd,
- const float* ab, const integer_t ldab, float* s, float& scond,
- float& amax, integer_t& info ) {
- LAPACK_SPBEQU( &uplo, &n, &kd, ab, &ldab, s, &scond, &amax, &info );
- }
- inline void pbequ( const char uplo, const integer_t n, const integer_t kd,
- const double* ab, const integer_t ldab, double* s, double& scond,
- double& amax, integer_t& info ) {
- LAPACK_DPBEQU( &uplo, &n, &kd, ab, &ldab, s, &scond, &amax, &info );
- }
- inline void pbequ( const char uplo, const integer_t n, const integer_t kd,
- const traits::complex_f* ab, const integer_t ldab, float* s,
- float& scond, float& amax, integer_t& info ) {
- LAPACK_CPBEQU( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, s,
- &scond, &amax, &info );
- }
- inline void pbequ( const char uplo, const integer_t n, const integer_t kd,
- const traits::complex_d* ab, const integer_t ldab, double* s,
- double& scond, double& amax, integer_t& info ) {
- LAPACK_ZPBEQU( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, s,
- &scond, &amax, &info );
- }
+
+inline void pbequ( const char uplo, const integer_t n, const integer_t kd,
+ const float* ab, const integer_t ldab, float* s, float& scond,
+ float& amax, integer_t& info ) {
+ LAPACK_SPBEQU( &uplo, &n, &kd, ab, &ldab, s, &scond, &amax, &info );
+}
+
+inline void pbequ( const char uplo, const integer_t n, const integer_t kd,
+ const double* ab, const integer_t ldab, double* s, double& scond,
+ double& amax, integer_t& info ) {
+ LAPACK_DPBEQU( &uplo, &n, &kd, ab, &ldab, s, &scond, &amax, &info );
+}
+
+inline void pbequ( const char uplo, const integer_t n, const integer_t kd,
+ const traits::complex_f* ab, const integer_t ldab, float* s,
+ float& scond, float& amax, integer_t& info ) {
+ LAPACK_CPBEQU( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, s, &scond,
+ &amax, &info );
 }
 
+inline void pbequ( const char uplo, const integer_t n, const integer_t kd,
+ const traits::complex_d* ab, const integer_t ldab, double* s,
+ double& scond, double& amax, integer_t& info ) {
+ LAPACK_ZPBEQU( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, s, &scond,
+ &amax, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pbequ_impl{};
@@ -126,6 +131,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,48 +36,53 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pbrfs( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, const float* ab, const integer_t ldab,
- const float* afb, const integer_t ldafb, const float* b,
- const integer_t ldb, float* x, const integer_t ldx, float* ferr,
- float* berr, float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SPBRFS( &uplo, &n, &kd, &nrhs, ab, &ldab, afb, &ldafb, b, &ldb,
- x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void pbrfs( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, const double* ab, const integer_t ldab,
- const double* afb, const integer_t ldafb, const double* b,
- const integer_t ldb, double* x, const integer_t ldx, double* ferr,
- double* berr, double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DPBRFS( &uplo, &n, &kd, &nrhs, ab, &ldab, afb, &ldafb, b, &ldb,
- x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void pbrfs( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, const traits::complex_f* ab,
- const integer_t ldab, const traits::complex_f* afb,
- const integer_t ldafb, const traits::complex_f* b,
- const integer_t ldb, traits::complex_f* x, const integer_t ldx,
- float* ferr, float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CPBRFS( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
- traits::complex_ptr(afb), &ldafb, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void pbrfs( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, const traits::complex_d* ab,
- const integer_t ldab, const traits::complex_d* afb,
- const integer_t ldafb, const traits::complex_d* b,
- const integer_t ldb, traits::complex_d* x, const integer_t ldx,
- double* ferr, double* berr, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZPBRFS( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
- traits::complex_ptr(afb), &ldafb, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void pbrfs( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, const float* ab, const integer_t ldab,
+ const float* afb, const integer_t ldafb, const float* b,
+ const integer_t ldb, float* x, const integer_t ldx, float* ferr,
+ float* berr, float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SPBRFS( &uplo, &n, &kd, &nrhs, ab, &ldab, afb, &ldafb, b, &ldb, x,
+ &ldx, ferr, berr, work, iwork, &info );
 }
 
+inline void pbrfs( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, const double* ab, const integer_t ldab,
+ const double* afb, const integer_t ldafb, const double* b,
+ const integer_t ldb, double* x, const integer_t ldx, double* ferr,
+ double* berr, double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DPBRFS( &uplo, &n, &kd, &nrhs, ab, &ldab, afb, &ldafb, b, &ldb, x,
+ &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void pbrfs( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, const traits::complex_f* ab,
+ const integer_t ldab, const traits::complex_f* afb,
+ const integer_t ldafb, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float* ferr, float* berr, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CPBRFS( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(afb), &ldafb, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+inline void pbrfs( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, const traits::complex_d* ab,
+ const integer_t ldab, const traits::complex_d* afb,
+ const integer_t ldafb, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZPBRFS( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(afb), &ldafb, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pbrfs_impl{};
@@ -283,6 +288,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,24 +31,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pbstf( const char uplo, const integer_t n, const integer_t kd,
- float* ab, const integer_t ldab, integer_t& info ) {
- LAPACK_SPBSTF( &uplo, &n, &kd, ab, &ldab, &info );
- }
- inline void pbstf( const char uplo, const integer_t n, const integer_t kd,
- double* ab, const integer_t ldab, integer_t& info ) {
- LAPACK_DPBSTF( &uplo, &n, &kd, ab, &ldab, &info );
- }
- inline void pbstf( const char uplo, const integer_t n, const integer_t kd,
- traits::complex_f* ab, const integer_t ldab, integer_t& info ) {
- LAPACK_CPBSTF( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &info );
- }
- inline void pbstf( const char uplo, const integer_t n, const integer_t kd,
- traits::complex_d* ab, const integer_t ldab, integer_t& info ) {
- LAPACK_ZPBSTF( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &info );
- }
+
+inline void pbstf( const char uplo, const integer_t n, const integer_t kd,
+ float* ab, const integer_t ldab, integer_t& info ) {
+ LAPACK_SPBSTF( &uplo, &n, &kd, ab, &ldab, &info );
+}
+
+inline void pbstf( const char uplo, const integer_t n, const integer_t kd,
+ double* ab, const integer_t ldab, integer_t& info ) {
+ LAPACK_DPBSTF( &uplo, &n, &kd, ab, &ldab, &info );
+}
+
+inline void pbstf( const char uplo, const integer_t n, const integer_t kd,
+ traits::complex_f* ab, const integer_t ldab, integer_t& info ) {
+ LAPACK_CPBSTF( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &info );
 }
 
+inline void pbstf( const char uplo, const integer_t n, const integer_t kd,
+ traits::complex_d* ab, const integer_t ldab, integer_t& info ) {
+ LAPACK_ZPBSTF( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct pbstf_impl {
@@ -82,6 +87,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,24 +31,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pbtrf( const char uplo, const integer_t n, const integer_t kd,
- float* ab, const integer_t ldab, integer_t& info ) {
- LAPACK_SPBTRF( &uplo, &n, &kd, ab, &ldab, &info );
- }
- inline void pbtrf( const char uplo, const integer_t n, const integer_t kd,
- double* ab, const integer_t ldab, integer_t& info ) {
- LAPACK_DPBTRF( &uplo, &n, &kd, ab, &ldab, &info );
- }
- inline void pbtrf( const char uplo, const integer_t n, const integer_t kd,
- traits::complex_f* ab, const integer_t ldab, integer_t& info ) {
- LAPACK_CPBTRF( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &info );
- }
- inline void pbtrf( const char uplo, const integer_t n, const integer_t kd,
- traits::complex_d* ab, const integer_t ldab, integer_t& info ) {
- LAPACK_ZPBTRF( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &info );
- }
+
+inline void pbtrf( const char uplo, const integer_t n, const integer_t kd,
+ float* ab, const integer_t ldab, integer_t& info ) {
+ LAPACK_SPBTRF( &uplo, &n, &kd, ab, &ldab, &info );
+}
+
+inline void pbtrf( const char uplo, const integer_t n, const integer_t kd,
+ double* ab, const integer_t ldab, integer_t& info ) {
+ LAPACK_DPBTRF( &uplo, &n, &kd, ab, &ldab, &info );
+}
+
+inline void pbtrf( const char uplo, const integer_t n, const integer_t kd,
+ traits::complex_f* ab, const integer_t ldab, integer_t& info ) {
+ LAPACK_CPBTRF( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &info );
 }
 
+inline void pbtrf( const char uplo, const integer_t n, const integer_t kd,
+ traits::complex_d* ab, const integer_t ldab, integer_t& info ) {
+ LAPACK_ZPBTRF( &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct pbtrf_impl {
@@ -82,6 +87,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,32 +31,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pbtrs( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, const float* ab, const integer_t ldab,
- float* b, const integer_t ldb, integer_t& info ) {
- LAPACK_SPBTRS( &uplo, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
- }
- inline void pbtrs( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, const double* ab, const integer_t ldab,
- double* b, const integer_t ldb, integer_t& info ) {
- LAPACK_DPBTRS( &uplo, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
- }
- inline void pbtrs( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, const traits::complex_f* ab,
- const integer_t ldab, traits::complex_f* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_CPBTRS( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void pbtrs( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, const traits::complex_d* ab,
- const integer_t ldab, traits::complex_d* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_ZPBTRS( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void pbtrs( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, const float* ab, const integer_t ldab, float* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_SPBTRS( &uplo, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
 }
 
+inline void pbtrs( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, const double* ab, const integer_t ldab,
+ double* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_DPBTRS( &uplo, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
+}
+
+inline void pbtrs( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, const traits::complex_f* ab,
+ const integer_t ldab, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CPBTRS( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+inline void pbtrs( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, const traits::complex_d* ab,
+ const integer_t ldab, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZPBTRS( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct pbtrs_impl {
@@ -96,6 +101,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,30 +34,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pftrs( const char transr, const char uplo, const integer_t n,
- const integer_t nrhs, const float* a, float* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_SPFTRS( &transr, &uplo, &n, &nrhs, a, b, &ldb, &info );
- }
- inline void pftrs( const char transr, const char uplo, const integer_t n,
- const integer_t nrhs, const double* a, double* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_DPFTRS( &transr, &uplo, &n, &nrhs, a, b, &ldb, &info );
- }
- inline void pftrs( const char transr, const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CPFTRS( &transr, &uplo, &n, &nrhs, traits::complex_ptr(a),
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void pftrs( const char transr, const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZPFTRS( &transr, &uplo, &n, &nrhs, traits::complex_ptr(a),
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void pftrs( const char transr, const char uplo, const integer_t n,
+ const integer_t nrhs, const float* a, float* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_SPFTRS( &transr, &uplo, &n, &nrhs, a, b, &ldb, &info );
+}
+
+inline void pftrs( const char transr, const char uplo, const integer_t n,
+ const integer_t nrhs, const double* a, double* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_DPFTRS( &transr, &uplo, &n, &nrhs, a, b, &ldb, &info );
+}
+
+inline void pftrs( const char transr, const char uplo, const integer_t n,
+ const integer_t nrhs, const traits::complex_f* a,
+ traits::complex_f* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_CPFTRS( &transr, &uplo, &n, &nrhs, traits::complex_ptr(a),
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void pftrs( const char transr, const char uplo, const integer_t n,
+ const integer_t nrhs, const traits::complex_d* a,
+ traits::complex_d* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_ZPFTRS( &transr, &uplo, &n, &nrhs, traits::complex_ptr(a),
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pftrs_impl{};
@@ -129,6 +134,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,34 +36,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pocon( const char uplo, const integer_t n, const float* a,
- const integer_t lda, const float anorm, float& rcond, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SPOCON( &uplo, &n, a, &lda, &anorm, &rcond, work, iwork,
- &info );
- }
- inline void pocon( const char uplo, const integer_t n, const double* a,
- const integer_t lda, const double anorm, double& rcond,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DPOCON( &uplo, &n, a, &lda, &anorm, &rcond, work, iwork,
- &info );
- }
- inline void pocon( const char uplo, const integer_t n,
- const traits::complex_f* a, const integer_t lda,
- const float anorm, float& rcond, traits::complex_f* work,
- float* rwork, integer_t& info ) {
- LAPACK_CPOCON( &uplo, &n, traits::complex_ptr(a), &lda, &anorm,
- &rcond, traits::complex_ptr(work), rwork, &info );
- }
- inline void pocon( const char uplo, const integer_t n,
- const traits::complex_d* a, const integer_t lda,
- const double anorm, double& rcond, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZPOCON( &uplo, &n, traits::complex_ptr(a), &lda, &anorm,
- &rcond, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void pocon( const char uplo, const integer_t n, const float* a,
+ const integer_t lda, const float anorm, float& rcond, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_SPOCON( &uplo, &n, a, &lda, &anorm, &rcond, work, iwork, &info );
 }
 
+inline void pocon( const char uplo, const integer_t n, const double* a,
+ const integer_t lda, const double anorm, double& rcond, double* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_DPOCON( &uplo, &n, a, &lda, &anorm, &rcond, work, iwork, &info );
+}
+
+inline void pocon( const char uplo, const integer_t n,
+ const traits::complex_f* a, const integer_t lda, const float anorm,
+ float& rcond, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CPOCON( &uplo, &n, traits::complex_ptr(a), &lda, &anorm, &rcond,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+inline void pocon( const char uplo, const integer_t n,
+ const traits::complex_d* a, const integer_t lda, const double anorm,
+ double& rcond, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZPOCON( &uplo, &n, traits::complex_ptr(a), &lda, &anorm, &rcond,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pocon_impl{};
@@ -206,6 +209,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,29 +34,31 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void poequ( const integer_t n, const float* a, const integer_t lda,
- float* s, float& scond, float& amax, integer_t& info ) {
- LAPACK_SPOEQU( &n, a, &lda, s, &scond, &amax, &info );
- }
- inline void poequ( const integer_t n, const double* a,
- const integer_t lda, double* s, double& scond, double& amax,
- integer_t& info ) {
- LAPACK_DPOEQU( &n, a, &lda, s, &scond, &amax, &info );
- }
- inline void poequ( const integer_t n, const traits::complex_f* a,
- const integer_t lda, float* s, float& scond, float& amax,
- integer_t& info ) {
- LAPACK_CPOEQU( &n, traits::complex_ptr(a), &lda, s, &scond, &amax,
- &info );
- }
- inline void poequ( const integer_t n, const traits::complex_d* a,
- const integer_t lda, double* s, double& scond, double& amax,
- integer_t& info ) {
- LAPACK_ZPOEQU( &n, traits::complex_ptr(a), &lda, s, &scond, &amax,
- &info );
- }
+
+inline void poequ( const integer_t n, const float* a, const integer_t lda,
+ float* s, float& scond, float& amax, integer_t& info ) {
+ LAPACK_SPOEQU( &n, a, &lda, s, &scond, &amax, &info );
+}
+
+inline void poequ( const integer_t n, const double* a, const integer_t lda,
+ double* s, double& scond, double& amax, integer_t& info ) {
+ LAPACK_DPOEQU( &n, a, &lda, s, &scond, &amax, &info );
+}
+
+inline void poequ( const integer_t n, const traits::complex_f* a,
+ const integer_t lda, float* s, float& scond, float& amax,
+ integer_t& info ) {
+ LAPACK_CPOEQU( &n, traits::complex_ptr(a), &lda, s, &scond, &amax, &info );
 }
 
+inline void poequ( const integer_t n, const traits::complex_d* a,
+ const integer_t lda, double* s, double& scond, double& amax,
+ integer_t& info ) {
+ LAPACK_ZPOEQU( &n, traits::complex_ptr(a), &lda, s, &scond, &amax, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct poequ_impl{};
@@ -118,6 +120,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,48 +36,51 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void porfs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* a, const integer_t lda,
- const float* af, const integer_t ldaf, const float* b,
- const integer_t ldb, float* x, const integer_t ldx, float* ferr,
- float* berr, float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SPORFS( &uplo, &n, &nrhs, a, &lda, af, &ldaf, b, &ldb, x, &ldx,
- ferr, berr, work, iwork, &info );
- }
- inline void porfs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* a, const integer_t lda,
- const double* af, const integer_t ldaf, const double* b,
- const integer_t ldb, double* x, const integer_t ldx, double* ferr,
- double* berr, double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DPORFS( &uplo, &n, &nrhs, a, &lda, af, &ldaf, b, &ldb, x, &ldx,
- ferr, berr, work, iwork, &info );
- }
- inline void porfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* af,
- const integer_t ldaf, const traits::complex_f* b,
- const integer_t ldb, traits::complex_f* x, const integer_t ldx,
- float* ferr, float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CPORFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void porfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* af,
- const integer_t ldaf, const traits::complex_d* b,
- const integer_t ldb, traits::complex_d* x, const integer_t ldx,
- double* ferr, double* berr, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZPORFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void porfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* a, const integer_t lda, const float* af,
+ const integer_t ldaf, const float* b, const integer_t ldb, float* x,
+ const integer_t ldx, float* ferr, float* berr, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_SPORFS( &uplo, &n, &nrhs, a, &lda, af, &ldaf, b, &ldb, x, &ldx,
+ ferr, berr, work, iwork, &info );
+}
+
+inline void porfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* a, const integer_t lda, const double* af,
+ const integer_t ldaf, const double* b, const integer_t ldb, double* x,
+ const integer_t ldx, double* ferr, double* berr, double* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_DPORFS( &uplo, &n, &nrhs, a, &lda, af, &ldaf, b, &ldb, x, &ldx,
+ ferr, berr, work, iwork, &info );
+}
+
+inline void porfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* af, const integer_t ldaf,
+ const traits::complex_f* b, const integer_t ldb, traits::complex_f* x,
+ const integer_t ldx, float* ferr, float* berr,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CPORFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void porfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* af, const integer_t ldaf,
+ const traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
+ const integer_t ldx, double* ferr, double* berr,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZPORFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct porfs_impl{};
@@ -286,6 +289,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,24 +31,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void potrf( const char uplo, const integer_t n, float* a,
- const integer_t lda, integer_t& info ) {
- LAPACK_SPOTRF( &uplo, &n, a, &lda, &info );
- }
- inline void potrf( const char uplo, const integer_t n, double* a,
- const integer_t lda, integer_t& info ) {
- LAPACK_DPOTRF( &uplo, &n, a, &lda, &info );
- }
- inline void potrf( const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, integer_t& info ) {
- LAPACK_CPOTRF( &uplo, &n, traits::complex_ptr(a), &lda, &info );
- }
- inline void potrf( const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, integer_t& info ) {
- LAPACK_ZPOTRF( &uplo, &n, traits::complex_ptr(a), &lda, &info );
- }
+
+inline void potrf( const char uplo, const integer_t n, float* a,
+ const integer_t lda, integer_t& info ) {
+ LAPACK_SPOTRF( &uplo, &n, a, &lda, &info );
+}
+
+inline void potrf( const char uplo, const integer_t n, double* a,
+ const integer_t lda, integer_t& info ) {
+ LAPACK_DPOTRF( &uplo, &n, a, &lda, &info );
+}
+
+inline void potrf( const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, integer_t& info ) {
+ LAPACK_CPOTRF( &uplo, &n, traits::complex_ptr(a), &lda, &info );
 }
 
+inline void potrf( const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, integer_t& info ) {
+ LAPACK_ZPOTRF( &uplo, &n, traits::complex_ptr(a), &lda, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct potrf_impl {
@@ -80,6 +85,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,24 +31,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void potri( const char uplo, const integer_t n, float* a,
- const integer_t lda, integer_t& info ) {
- LAPACK_SPOTRI( &uplo, &n, a, &lda, &info );
- }
- inline void potri( const char uplo, const integer_t n, double* a,
- const integer_t lda, integer_t& info ) {
- LAPACK_DPOTRI( &uplo, &n, a, &lda, &info );
- }
- inline void potri( const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, integer_t& info ) {
- LAPACK_CPOTRI( &uplo, &n, traits::complex_ptr(a), &lda, &info );
- }
- inline void potri( const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, integer_t& info ) {
- LAPACK_ZPOTRI( &uplo, &n, traits::complex_ptr(a), &lda, &info );
- }
+
+inline void potri( const char uplo, const integer_t n, float* a,
+ const integer_t lda, integer_t& info ) {
+ LAPACK_SPOTRI( &uplo, &n, a, &lda, &info );
+}
+
+inline void potri( const char uplo, const integer_t n, double* a,
+ const integer_t lda, integer_t& info ) {
+ LAPACK_DPOTRI( &uplo, &n, a, &lda, &info );
+}
+
+inline void potri( const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, integer_t& info ) {
+ LAPACK_CPOTRI( &uplo, &n, traits::complex_ptr(a), &lda, &info );
 }
 
+inline void potri( const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, integer_t& info ) {
+ LAPACK_ZPOTRI( &uplo, &n, traits::complex_ptr(a), &lda, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct potri_impl {
@@ -80,6 +85,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,32 +31,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void potrs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* a, const integer_t lda,
- float* b, const integer_t ldb, integer_t& info ) {
- LAPACK_SPOTRS( &uplo, &n, &nrhs, a, &lda, b, &ldb, &info );
- }
- inline void potrs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* a, const integer_t lda,
- double* b, const integer_t ldb, integer_t& info ) {
- LAPACK_DPOTRS( &uplo, &n, &nrhs, a, &lda, b, &ldb, &info );
- }
- inline void potrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, traits::complex_f* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_CPOTRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void potrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, traits::complex_d* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_ZPOTRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void potrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* a, const integer_t lda, float* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_SPOTRS( &uplo, &n, &nrhs, a, &lda, b, &ldb, &info );
+}
+
+inline void potrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* a, const integer_t lda, double* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_DPOTRS( &uplo, &n, &nrhs, a, &lda, b, &ldb, &info );
+}
+
+inline void potrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_CPOTRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void potrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_ZPOTRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct potrs_impl {
@@ -96,6 +99,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,46 +36,47 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* ap, const float* afp,
- const float* b, const integer_t ldb, float* x,
- const integer_t ldx, float* ferr, float* berr, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SPPRFS( &uplo, &n, &nrhs, ap, afp, b, &ldb, x, &ldx, ferr,
- berr, work, iwork, &info );
- }
- inline void pprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* ap, const double* afp,
- const double* b, const integer_t ldb, double* x,
- const integer_t ldx, double* ferr, double* berr, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DPPRFS( &uplo, &n, &nrhs, ap, afp, b, &ldb, x, &ldx, ferr,
- berr, work, iwork, &info );
- }
- inline void pprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* ap,
- const traits::complex_f* afp, const traits::complex_f* b,
- const integer_t ldb, traits::complex_f* x, const integer_t ldx,
- float* ferr, float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CPPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void pprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* ap,
- const traits::complex_d* afp, const traits::complex_d* b,
- const integer_t ldb, traits::complex_d* x, const integer_t ldx,
- double* ferr, double* berr, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZPPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void pprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* ap, const float* afp, const float* b,
+ const integer_t ldb, float* x, const integer_t ldx, float* ferr,
+ float* berr, float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SPPRFS( &uplo, &n, &nrhs, ap, afp, b, &ldb, x, &ldx, ferr, berr,
+ work, iwork, &info );
 }
 
+inline void pprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* ap, const double* afp, const double* b,
+ const integer_t ldb, double* x, const integer_t ldx, double* ferr,
+ double* berr, double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DPPRFS( &uplo, &n, &nrhs, ap, afp, b, &ldb, x, &ldx, ferr, berr,
+ work, iwork, &info );
+}
+
+inline void pprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* ap, const traits::complex_f* afp,
+ const traits::complex_f* b, const integer_t ldb, traits::complex_f* x,
+ const integer_t ldx, float* ferr, float* berr,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CPPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+inline void pprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* ap, const traits::complex_d* afp,
+ const traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
+ const integer_t ldx, double* ferr, double* berr,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZPPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pprfs_impl{};
@@ -275,6 +276,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,30 +31,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* ap, float* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_SPPTRS( &uplo, &n, &nrhs, ap, b, &ldb, &info );
- }
- inline void pptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* ap, double* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_DPPTRS( &uplo, &n, &nrhs, ap, b, &ldb, &info );
- }
- inline void pptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* ap,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CPPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void pptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* ap,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZPPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void pptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* ap, float* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_SPPTRS( &uplo, &n, &nrhs, ap, b, &ldb, &info );
+}
+
+inline void pptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* ap, double* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_DPPTRS( &uplo, &n, &nrhs, ap, b, &ldb, &info );
+}
+
+inline void pptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* ap, traits::complex_f* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_CPPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void pptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* ap, traits::complex_d* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_ZPPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct pptrs_impl {
@@ -92,6 +95,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,30 +36,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pteqr( const char compz, const integer_t n, float* d,
- float* e, float* z, const integer_t ldz, float* work,
- integer_t& info ) {
- LAPACK_SPTEQR( &compz, &n, d, e, z, &ldz, work, &info );
- }
- inline void pteqr( const char compz, const integer_t n, double* d,
- double* e, double* z, const integer_t ldz, double* work,
- integer_t& info ) {
- LAPACK_DPTEQR( &compz, &n, d, e, z, &ldz, work, &info );
- }
- inline void pteqr( const char compz, const integer_t n, float* d,
- float* e, traits::complex_f* z, const integer_t ldz, float* work,
- integer_t& info ) {
- LAPACK_CPTEQR( &compz, &n, d, e, traits::complex_ptr(z), &ldz, work,
- &info );
- }
- inline void pteqr( const char compz, const integer_t n, double* d,
- double* e, traits::complex_d* z, const integer_t ldz,
- double* work, integer_t& info ) {
- LAPACK_ZPTEQR( &compz, &n, d, e, traits::complex_ptr(z), &ldz, work,
- &info );
- }
+
+inline void pteqr( const char compz, const integer_t n, float* d, float* e,
+ float* z, const integer_t ldz, float* work, integer_t& info ) {
+ LAPACK_SPTEQR( &compz, &n, d, e, z, &ldz, work, &info );
 }
 
+inline void pteqr( const char compz, const integer_t n, double* d, double* e,
+ double* z, const integer_t ldz, double* work, integer_t& info ) {
+ LAPACK_DPTEQR( &compz, &n, d, e, z, &ldz, work, &info );
+}
+
+inline void pteqr( const char compz, const integer_t n, float* d, float* e,
+ traits::complex_f* z, const integer_t ldz, float* work,
+ integer_t& info ) {
+ LAPACK_CPTEQR( &compz, &n, d, e, traits::complex_ptr(z), &ldz, work,
+ &info );
+}
+
+inline void pteqr( const char compz, const integer_t n, double* d, double* e,
+ traits::complex_d* z, const integer_t ldz, double* work,
+ integer_t& info ) {
+ LAPACK_ZPTEQR( &compz, &n, d, e, traits::complex_ptr(z), &ldz, work,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pteqr_impl{};
@@ -186,6 +189,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,48 +36,49 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ptrfs( const integer_t n, const integer_t nrhs,
- const float* d, const float* e, const float* df, const float* ef,
- const float* b, const integer_t ldb, float* x,
- const integer_t ldx, float* ferr, float* berr, float* work,
- integer_t& info ) {
- LAPACK_SPTRFS( &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, ferr, berr,
- work, &info );
- }
- inline void ptrfs( const integer_t n, const integer_t nrhs,
- const double* d, const double* e, const double* df,
- const double* ef, const double* b, const integer_t ldb, double* x,
- const integer_t ldx, double* ferr, double* berr, double* work,
- integer_t& info ) {
- LAPACK_DPTRFS( &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, ferr, berr,
- work, &info );
- }
- inline void ptrfs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* d, const traits::complex_f* e,
- const float* df, const traits::complex_f* ef,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float* ferr,
- float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CPTRFS( &uplo, &n, &nrhs, d, traits::complex_ptr(e), df,
- traits::complex_ptr(ef), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void ptrfs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* d, const traits::complex_d* e,
- const double* df, const traits::complex_d* ef,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double* ferr,
- double* berr, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZPTRFS( &uplo, &n, &nrhs, d, traits::complex_ptr(e), df,
- traits::complex_ptr(ef), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void ptrfs( const integer_t n, const integer_t nrhs, const float* d,
+ const float* e, const float* df, const float* ef, const float* b,
+ const integer_t ldb, float* x, const integer_t ldx, float* ferr,
+ float* berr, float* work, integer_t& info ) {
+ LAPACK_SPTRFS( &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, ferr, berr,
+ work, &info );
+}
+
+inline void ptrfs( const integer_t n, const integer_t nrhs, const double* d,
+ const double* e, const double* df, const double* ef, const double* b,
+ const integer_t ldb, double* x, const integer_t ldx, double* ferr,
+ double* berr, double* work, integer_t& info ) {
+ LAPACK_DPTRFS( &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, ferr, berr,
+ work, &info );
+}
+
+inline void ptrfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* d, const traits::complex_f* e, const float* df,
+ const traits::complex_f* ef, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float* ferr, float* berr, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CPTRFS( &uplo, &n, &nrhs, d, traits::complex_ptr(e), df,
+ traits::complex_ptr(ef), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void ptrfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* d, const traits::complex_d* e, const double* df,
+ const traits::complex_d* ef, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZPTRFS( &uplo, &n, &nrhs, d, traits::complex_ptr(e), df,
+ traits::complex_ptr(ef), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ptrfs_impl{};
@@ -321,6 +322,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,30 +34,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pttrs( const integer_t n, const integer_t nrhs,
- const float* d, const float* e, float* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_SPTTRS( &n, &nrhs, d, e, b, &ldb, &info );
- }
- inline void pttrs( const integer_t n, const integer_t nrhs,
- const double* d, const double* e, double* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_DPTTRS( &n, &nrhs, d, e, b, &ldb, &info );
- }
- inline void pttrs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* d, const traits::complex_f* e,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CPTTRS( &uplo, &n, &nrhs, d, traits::complex_ptr(e),
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void pttrs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* d, const traits::complex_d* e,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZPTTRS( &uplo, &n, &nrhs, d, traits::complex_ptr(e),
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void pttrs( const integer_t n, const integer_t nrhs, const float* d,
+ const float* e, float* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_SPTTRS( &n, &nrhs, d, e, b, &ldb, &info );
+}
+
+inline void pttrs( const integer_t n, const integer_t nrhs, const double* d,
+ const double* e, double* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_DPTTRS( &n, &nrhs, d, e, b, &ldb, &info );
+}
+
+inline void pttrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* d, const traits::complex_f* e, traits::complex_f* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_CPTTRS( &uplo, &n, &nrhs, d, traits::complex_ptr(e),
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void pttrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* d, const traits::complex_d* e, traits::complex_d* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_ZPTTRS( &uplo, &n, &nrhs, d, traits::complex_ptr(e),
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pttrs_impl{};
@@ -137,6 +140,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,22 +33,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sbgst( const char vect, const char uplo, const integer_t n,
- const integer_t ka, const integer_t kb, float* ab,
- const integer_t ldab, const float* bb, const integer_t ldbb,
- float* x, const integer_t ldx, float* work, integer_t& info ) {
- LAPACK_SSBGST( &vect, &uplo, &n, &ka, &kb, ab, &ldab, bb, &ldbb, x,
- &ldx, work, &info );
- }
- inline void sbgst( const char vect, const char uplo, const integer_t n,
- const integer_t ka, const integer_t kb, double* ab,
- const integer_t ldab, const double* bb, const integer_t ldbb,
- double* x, const integer_t ldx, double* work, integer_t& info ) {
- LAPACK_DSBGST( &vect, &uplo, &n, &ka, &kb, ab, &ldab, bb, &ldbb, x,
- &ldx, work, &info );
- }
+
+inline void sbgst( const char vect, const char uplo, const integer_t n,
+ const integer_t ka, const integer_t kb, float* ab,
+ const integer_t ldab, const float* bb, const integer_t ldbb, float* x,
+ const integer_t ldx, float* work, integer_t& info ) {
+ LAPACK_SSBGST( &vect, &uplo, &n, &ka, &kb, ab, &ldab, bb, &ldbb, x, &ldx,
+ work, &info );
 }
 
+inline void sbgst( const char vect, const char uplo, const integer_t n,
+ const integer_t ka, const integer_t kb, double* ab,
+ const integer_t ldab, const double* bb, const integer_t ldbb,
+ double* x, const integer_t ldx, double* work, integer_t& info ) {
+ LAPACK_DSBGST( &vect, &uplo, &n, &ka, &kb, ab, &ldab, bb, &ldbb, x, &ldx,
+ work, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct sbgst_impl {
@@ -136,6 +139,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,22 +33,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sbtrd( const char vect, const char uplo, const integer_t n,
- const integer_t kd, float* ab, const integer_t ldab, float* d,
- float* e, float* q, const integer_t ldq, float* work,
- integer_t& info ) {
- LAPACK_SSBTRD( &vect, &uplo, &n, &kd, ab, &ldab, d, e, q, &ldq, work,
- &info );
- }
- inline void sbtrd( const char vect, const char uplo, const integer_t n,
- const integer_t kd, double* ab, const integer_t ldab, double* d,
- double* e, double* q, const integer_t ldq, double* work,
- integer_t& info ) {
- LAPACK_DSBTRD( &vect, &uplo, &n, &kd, ab, &ldab, d, e, q, &ldq, work,
- &info );
- }
+
+inline void sbtrd( const char vect, const char uplo, const integer_t n,
+ const integer_t kd, float* ab, const integer_t ldab, float* d,
+ float* e, float* q, const integer_t ldq, float* work,
+ integer_t& info ) {
+ LAPACK_SSBTRD( &vect, &uplo, &n, &kd, ab, &ldab, d, e, q, &ldq, work,
+ &info );
 }
 
+inline void sbtrd( const char vect, const char uplo, const integer_t n,
+ const integer_t kd, double* ab, const integer_t ldab, double* d,
+ double* e, double* q, const integer_t ldq, double* work,
+ integer_t& info ) {
+ LAPACK_DSBTRD( &vect, &uplo, &n, &kd, ab, &ldab, d, e, q, &ldq, work,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct sbtrd_impl {
@@ -138,6 +141,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,48 +36,51 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* ap, const float* afp,
- const integer_t* ipiv, const float* b, const integer_t ldb,
- float* x, const integer_t ldx, float* ferr, float* berr,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SSPRFS( &uplo, &n, &nrhs, ap, afp, ipiv, b, &ldb, x, &ldx,
- ferr, berr, work, iwork, &info );
- }
- inline void sprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* ap, const double* afp,
- const integer_t* ipiv, const double* b, const integer_t ldb,
- double* x, const integer_t ldx, double* ferr, double* berr,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DSPRFS( &uplo, &n, &nrhs, ap, afp, ipiv, b, &ldb, x, &ldx,
- ferr, berr, work, iwork, &info );
- }
- inline void sprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* ap,
- const traits::complex_f* afp, const integer_t* ipiv,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float* ferr,
- float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CSPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void sprfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* ap,
- const traits::complex_d* afp, const integer_t* ipiv,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double* ferr,
- double* berr, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZSPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void sprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* ap, const float* afp, const integer_t* ipiv,
+ const float* b, const integer_t ldb, float* x, const integer_t ldx,
+ float* ferr, float* berr, float* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_SSPRFS( &uplo, &n, &nrhs, ap, afp, ipiv, b, &ldb, x, &ldx, ferr,
+ berr, work, iwork, &info );
+}
+
+inline void sprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* ap, const double* afp, const integer_t* ipiv,
+ const double* b, const integer_t ldb, double* x, const integer_t ldx,
+ double* ferr, double* berr, double* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DSPRFS( &uplo, &n, &nrhs, ap, afp, ipiv, b, &ldb, x, &ldx, ferr,
+ berr, work, iwork, &info );
+}
+
+inline void sprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* ap, const traits::complex_f* afp,
+ const integer_t* ipiv, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float* ferr, float* berr, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CSPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void sprfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* ap, const traits::complex_d* afp,
+ const integer_t* ipiv, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZSPRFS( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct sprfs_impl{};
@@ -286,6 +289,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,32 +31,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* ap, const integer_t* ipiv,
- float* b, const integer_t ldb, integer_t& info ) {
- LAPACK_SSPTRS( &uplo, &n, &nrhs, ap, ipiv, b, &ldb, &info );
- }
- inline void sptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* ap, const integer_t* ipiv,
- double* b, const integer_t ldb, integer_t& info ) {
- LAPACK_DSPTRS( &uplo, &n, &nrhs, ap, ipiv, b, &ldb, &info );
- }
- inline void sptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* ap,
- const integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_CSPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void sptrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* ap,
- const integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_ZSPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void sptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* ap, const integer_t* ipiv, float* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_SSPTRS( &uplo, &n, &nrhs, ap, ipiv, b, &ldb, &info );
 }
 
+inline void sptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* ap, const integer_t* ipiv, double* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_DSPTRS( &uplo, &n, &nrhs, ap, ipiv, b, &ldb, &info );
+}
+
+inline void sptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* ap, const integer_t* ipiv,
+ traits::complex_f* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_CSPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+inline void sptrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* ap, const integer_t* ipiv,
+ traits::complex_d* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_ZSPTRS( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct sptrs_impl {
@@ -96,6 +99,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,26 +33,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void stebz( const char range, const char order, const integer_t n,
- const float vl, const float vu, const integer_t il,
- const integer_t iu, const float abstol, const float* d,
- const float* e, integer_t& m, integer_t& nsplit, float* w,
- integer_t* iblock, integer_t* isplit, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SSTEBZ( &range, &order, &n, &vl, &vu, &il, &iu, &abstol, d, e,
- &m, &nsplit, w, iblock, isplit, work, iwork, &info );
- }
- inline void stebz( const char range, const char order, const integer_t n,
- const double vl, const double vu, const integer_t il,
- const integer_t iu, const double abstol, const double* d,
- const double* e, integer_t& m, integer_t& nsplit, double* w,
- integer_t* iblock, integer_t* isplit, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DSTEBZ( &range, &order, &n, &vl, &vu, &il, &iu, &abstol, d, e,
- &m, &nsplit, w, iblock, isplit, work, iwork, &info );
- }
+
+inline void stebz( const char range, const char order, const integer_t n,
+ const float vl, const float vu, const integer_t il,
+ const integer_t iu, const float abstol, const float* d,
+ const float* e, integer_t& m, integer_t& nsplit, float* w,
+ integer_t* iblock, integer_t* isplit, float* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_SSTEBZ( &range, &order, &n, &vl, &vu, &il, &iu, &abstol, d, e, &m,
+ &nsplit, w, iblock, isplit, work, iwork, &info );
 }
 
+inline void stebz( const char range, const char order, const integer_t n,
+ const double vl, const double vu, const integer_t il,
+ const integer_t iu, const double abstol, const double* d,
+ const double* e, integer_t& m, integer_t& nsplit, double* w,
+ integer_t* iblock, integer_t* isplit, double* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DSTEBZ( &range, &order, &n, &vl, &vu, &il, &iu, &abstol, d, e, &m,
+ &nsplit, w, iblock, isplit, work, iwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct stebz_impl {
@@ -178,6 +181,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,40 +37,41 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void stedc( const char compz, const integer_t n, float* d,
- float* e, float* z, const integer_t ldz, float* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_SSTEDC( &compz, &n, d, e, z, &ldz, work, &lwork, iwork,
- &liwork, &info );
- }
- inline void stedc( const char compz, const integer_t n, double* d,
- double* e, double* z, const integer_t ldz, double* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_DSTEDC( &compz, &n, d, e, z, &ldz, work, &lwork, iwork,
- &liwork, &info );
- }
- inline void stedc( const char compz, const integer_t n, float* d,
- float* e, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_CSTEDC( &compz, &n, d, e, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork,
- &liwork, &info );
- }
- inline void stedc( const char compz, const integer_t n, double* d,
- double* e, traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_ZSTEDC( &compz, &n, d, e, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork,
- &liwork, &info );
- }
+
+inline void stedc( const char compz, const integer_t n, float* d, float* e,
+ float* z, const integer_t ldz, float* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_SSTEDC( &compz, &n, d, e, z, &ldz, work, &lwork, iwork, &liwork,
+ &info );
 }
 
+inline void stedc( const char compz, const integer_t n, double* d, double* e,
+ double* z, const integer_t ldz, double* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_DSTEDC( &compz, &n, d, e, z, &ldz, work, &lwork, iwork, &liwork,
+ &info );
+}
+
+inline void stedc( const char compz, const integer_t n, float* d, float* e,
+ traits::complex_f* z, const integer_t ldz, traits::complex_f* work,
+ const integer_t lwork, float* rwork, const integer_t lrwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_CSTEDC( &compz, &n, d, e, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork,
+ &info );
+}
+
+inline void stedc( const char compz, const integer_t n, double* d, double* e,
+ traits::complex_d* z, const integer_t ldz, traits::complex_d* work,
+ const integer_t lwork, double* rwork, const integer_t lrwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_ZSTEDC( &compz, &n, d, e, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct stedc_impl{};
@@ -252,6 +253,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,47 +37,51 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void stegr( const char jobz, const char range, const integer_t n,
- float* d, float* e, const float vl, const float vu,
- const integer_t il, const integer_t iu, const float abstol,
- integer_t& m, float* w, float* z, const integer_t ldz,
- integer_t* isuppz, float* work, const integer_t lwork,
- integer_t* iwork, const integer_t liwork, integer_t& info ) {
- LAPACK_SSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol,
- &m, w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info );
- }
- inline void stegr( const char jobz, const char range, const integer_t n,
- double* d, double* e, const double vl, const double vu,
- const integer_t il, const integer_t iu, const double abstol,
- integer_t& m, double* w, double* z, const integer_t ldz,
- integer_t* isuppz, double* work, const integer_t lwork,
- integer_t* iwork, const integer_t liwork, integer_t& info ) {
- LAPACK_DSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol,
- &m, w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info );
- }
- inline void stegr( const char jobz, const char range, const integer_t n,
- float* d, float* e, const float vl, const float vu,
- const integer_t il, const integer_t iu, const float abstol,
- integer_t& m, float* w, traits::complex_f* z, const integer_t ldz,
- integer_t* isuppz, float* work, const integer_t lwork,
- integer_t* iwork, const integer_t liwork, integer_t& info ) {
- LAPACK_CSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol,
- &m, w, traits::complex_ptr(z), &ldz, isuppz, work, &lwork,
- iwork, &liwork, &info );
- }
- inline void stegr( const char jobz, const char range, const integer_t n,
- double* d, double* e, const double vl, const double vu,
- const integer_t il, const integer_t iu, const double abstol,
- integer_t& m, double* w, traits::complex_d* z,
- const integer_t ldz, integer_t* isuppz, double* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_ZSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol,
- &m, w, traits::complex_ptr(z), &ldz, isuppz, work, &lwork,
- iwork, &liwork, &info );
- }
+
+inline void stegr( const char jobz, const char range, const integer_t n,
+ float* d, float* e, const float vl, const float vu,
+ const integer_t il, const integer_t iu, const float abstol,
+ integer_t& m, float* w, float* z, const integer_t ldz,
+ integer_t* isuppz, float* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_SSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m,
+ w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info );
+}
+
+inline void stegr( const char jobz, const char range, const integer_t n,
+ double* d, double* e, const double vl, const double vu,
+ const integer_t il, const integer_t iu, const double abstol,
+ integer_t& m, double* w, double* z, const integer_t ldz,
+ integer_t* isuppz, double* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_DSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m,
+ w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info );
+}
+
+inline void stegr( const char jobz, const char range, const integer_t n,
+ float* d, float* e, const float vl, const float vu,
+ const integer_t il, const integer_t iu, const float abstol,
+ integer_t& m, float* w, traits::complex_f* z, const integer_t ldz,
+ integer_t* isuppz, float* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_CSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m,
+ w, traits::complex_ptr(z), &ldz, isuppz, work, &lwork, iwork,
+ &liwork, &info );
 }
 
+inline void stegr( const char jobz, const char range, const integer_t n,
+ double* d, double* e, const double vl, const double vu,
+ const integer_t il, const integer_t iu, const double abstol,
+ integer_t& m, double* w, traits::complex_d* z, const integer_t ldz,
+ integer_t* isuppz, double* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_ZSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m,
+ w, traits::complex_ptr(z), &ldz, isuppz, work, &lwork, iwork,
+ &liwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct stegr_impl{};
@@ -320,6 +324,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,40 +36,41 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void stein( const integer_t n, const float* d, const float* e,
- const integer_t m, const float* w, const integer_t* iblock,
- const integer_t* isplit, float* z, const integer_t ldz,
- float* work, integer_t* iwork, integer_t* ifail,
- integer_t& info ) {
- LAPACK_SSTEIN( &n, d, e, &m, w, iblock, isplit, z, &ldz, work, iwork,
- ifail, &info );
- }
- inline void stein( const integer_t n, const double* d, const double* e,
- const integer_t m, const double* w, const integer_t* iblock,
- const integer_t* isplit, double* z, const integer_t ldz,
- double* work, integer_t* iwork, integer_t* ifail,
- integer_t& info ) {
- LAPACK_DSTEIN( &n, d, e, &m, w, iblock, isplit, z, &ldz, work, iwork,
- ifail, &info );
- }
- inline void stein( const integer_t n, const float* d, const float* e,
- const integer_t m, const float* w, const integer_t* iblock,
- const integer_t* isplit, traits::complex_f* z,
- const integer_t ldz, float* work, integer_t* iwork,
- integer_t* ifail, integer_t& info ) {
- LAPACK_CSTEIN( &n, d, e, &m, w, iblock, isplit,
- traits::complex_ptr(z), &ldz, work, iwork, ifail, &info );
- }
- inline void stein( const integer_t n, const double* d, const double* e,
- const integer_t m, const double* w, const integer_t* iblock,
- const integer_t* isplit, traits::complex_d* z,
- const integer_t ldz, double* work, integer_t* iwork,
- integer_t* ifail, integer_t& info ) {
- LAPACK_ZSTEIN( &n, d, e, &m, w, iblock, isplit,
- traits::complex_ptr(z), &ldz, work, iwork, ifail, &info );
- }
+
+inline void stein( const integer_t n, const float* d, const float* e,
+ const integer_t m, const float* w, const integer_t* iblock,
+ const integer_t* isplit, float* z, const integer_t ldz, float* work,
+ integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_SSTEIN( &n, d, e, &m, w, iblock, isplit, z, &ldz, work, iwork,
+ ifail, &info );
 }
 
+inline void stein( const integer_t n, const double* d, const double* e,
+ const integer_t m, const double* w, const integer_t* iblock,
+ const integer_t* isplit, double* z, const integer_t ldz, double* work,
+ integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_DSTEIN( &n, d, e, &m, w, iblock, isplit, z, &ldz, work, iwork,
+ ifail, &info );
+}
+
+inline void stein( const integer_t n, const float* d, const float* e,
+ const integer_t m, const float* w, const integer_t* iblock,
+ const integer_t* isplit, traits::complex_f* z, const integer_t ldz,
+ float* work, integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_CSTEIN( &n, d, e, &m, w, iblock, isplit, traits::complex_ptr(z),
+ &ldz, work, iwork, ifail, &info );
+}
+
+inline void stein( const integer_t n, const double* d, const double* e,
+ const integer_t m, const double* w, const integer_t* iblock,
+ const integer_t* isplit, traits::complex_d* z, const integer_t ldz,
+ double* work, integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_ZSTEIN( &n, d, e, &m, w, iblock, isplit, traits::complex_ptr(z),
+ &ldz, work, iwork, ifail, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct stein_impl{};
@@ -272,6 +273,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stemr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stemr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stemr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,52 +37,54 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void stemr( const char jobz, const char range, const integer_t n,
- float* d, float* e, const float vl, const float vu,
- const integer_t il, const integer_t iu, integer_t& m, float* w,
- float* z, const integer_t ldz, const integer_t nzc,
- integer_t* isuppz, logical_t& tryrac, float* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_SSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z,
- &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork,
- &info );
- }
- inline void stemr( const char jobz, const char range, const integer_t n,
- double* d, double* e, const double vl, const double vu,
- const integer_t il, const integer_t iu, integer_t& m, double* w,
- double* z, const integer_t ldz, const integer_t nzc,
- integer_t* isuppz, logical_t& tryrac, double* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_DSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z,
- &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork,
- &info );
- }
- inline void stemr( const char jobz, const char range, const integer_t n,
- float* d, float* e, const float vl, const float vu,
- const integer_t il, const integer_t iu, integer_t& m, float* w,
- traits::complex_f* z, const integer_t ldz, const integer_t nzc,
- integer_t* isuppz, logical_t& tryrac, float* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_CSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w,
- traits::complex_ptr(z), &ldz, &nzc, isuppz, &tryrac, work,
- &lwork, iwork, &liwork, &info );
- }
- inline void stemr( const char jobz, const char range, const integer_t n,
- double* d, double* e, const double vl, const double vu,
- const integer_t il, const integer_t iu, integer_t& m, double* w,
- traits::complex_d* z, const integer_t ldz, const integer_t nzc,
- integer_t* isuppz, logical_t& tryrac, double* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_ZSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w,
- traits::complex_ptr(z), &ldz, &nzc, isuppz, &tryrac, work,
- &lwork, iwork, &liwork, &info );
- }
+
+inline void stemr( const char jobz, const char range, const integer_t n,
+ float* d, float* e, const float vl, const float vu,
+ const integer_t il, const integer_t iu, integer_t& m, float* w,
+ float* z, const integer_t ldz, const integer_t nzc, integer_t* isuppz,
+ logical_t& tryrac, float* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_SSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z,
+ &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork, &info );
+}
+
+inline void stemr( const char jobz, const char range, const integer_t n,
+ double* d, double* e, const double vl, const double vu,
+ const integer_t il, const integer_t iu, integer_t& m, double* w,
+ double* z, const integer_t ldz, const integer_t nzc,
+ integer_t* isuppz, logical_t& tryrac, double* work,
+ const integer_t lwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_DSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z,
+ &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork, &info );
+}
+
+inline void stemr( const char jobz, const char range, const integer_t n,
+ float* d, float* e, const float vl, const float vu,
+ const integer_t il, const integer_t iu, integer_t& m, float* w,
+ traits::complex_f* z, const integer_t ldz, const integer_t nzc,
+ integer_t* isuppz, logical_t& tryrac, float* work,
+ const integer_t lwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_CSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w,
+ traits::complex_ptr(z), &ldz, &nzc, isuppz, &tryrac, work, &lwork,
+ iwork, &liwork, &info );
 }
 
+inline void stemr( const char jobz, const char range, const integer_t n,
+ double* d, double* e, const double vl, const double vu,
+ const integer_t il, const integer_t iu, integer_t& m, double* w,
+ traits::complex_d* z, const integer_t ldz, const integer_t nzc,
+ integer_t* isuppz, logical_t& tryrac, double* work,
+ const integer_t lwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_ZSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w,
+ traits::complex_ptr(z), &ldz, &nzc, isuppz, &tryrac, work, &lwork,
+ iwork, &liwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct stemr_impl{};
@@ -328,6 +330,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,30 +36,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void steqr( const char compz, const integer_t n, float* d,
- float* e, float* z, const integer_t ldz, float* work,
- integer_t& info ) {
- LAPACK_SSTEQR( &compz, &n, d, e, z, &ldz, work, &info );
- }
- inline void steqr( const char compz, const integer_t n, double* d,
- double* e, double* z, const integer_t ldz, double* work,
- integer_t& info ) {
- LAPACK_DSTEQR( &compz, &n, d, e, z, &ldz, work, &info );
- }
- inline void steqr( const char compz, const integer_t n, float* d,
- float* e, traits::complex_f* z, const integer_t ldz, float* work,
- integer_t& info ) {
- LAPACK_CSTEQR( &compz, &n, d, e, traits::complex_ptr(z), &ldz, work,
- &info );
- }
- inline void steqr( const char compz, const integer_t n, double* d,
- double* e, traits::complex_d* z, const integer_t ldz,
- double* work, integer_t& info ) {
- LAPACK_ZSTEQR( &compz, &n, d, e, traits::complex_ptr(z), &ldz, work,
- &info );
- }
+
+inline void steqr( const char compz, const integer_t n, float* d, float* e,
+ float* z, const integer_t ldz, float* work, integer_t& info ) {
+ LAPACK_SSTEQR( &compz, &n, d, e, z, &ldz, work, &info );
 }
 
+inline void steqr( const char compz, const integer_t n, double* d, double* e,
+ double* z, const integer_t ldz, double* work, integer_t& info ) {
+ LAPACK_DSTEQR( &compz, &n, d, e, z, &ldz, work, &info );
+}
+
+inline void steqr( const char compz, const integer_t n, float* d, float* e,
+ traits::complex_f* z, const integer_t ldz, float* work,
+ integer_t& info ) {
+ LAPACK_CSTEQR( &compz, &n, d, e, traits::complex_ptr(z), &ldz, work,
+ &info );
+}
+
+inline void steqr( const char compz, const integer_t n, double* d, double* e,
+ traits::complex_d* z, const integer_t ldz, double* work,
+ integer_t& info ) {
+ LAPACK_ZSTEQR( &compz, &n, d, e, traits::complex_ptr(z), &ldz, work,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct steqr_impl{};
@@ -186,6 +189,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,16 +31,17 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sterf( const integer_t n, float* d, float* e,
- integer_t& info ) {
- LAPACK_SSTERF( &n, d, e, &info );
- }
- inline void sterf( const integer_t n, double* d, double* e,
- integer_t& info ) {
- LAPACK_DSTERF( &n, d, e, &info );
- }
+
+inline void sterf( const integer_t n, float* d, float* e, integer_t& info ) {
+ LAPACK_SSTERF( &n, d, e, &info );
+}
+
+inline void sterf( const integer_t n, double* d, double* e, integer_t& info ) {
+ LAPACK_DSTERF( &n, d, e, &info );
 }
 
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct sterf_impl {
@@ -72,6 +73,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,34 +36,39 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sycon( const char uplo, const integer_t n, const float* a,
- const integer_t lda, const integer_t* ipiv, const float anorm,
- float& rcond, float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SSYCON( &uplo, &n, a, &lda, ipiv, &anorm, &rcond, work, iwork,
- &info );
- }
- inline void sycon( const char uplo, const integer_t n, const double* a,
- const integer_t lda, const integer_t* ipiv, const double anorm,
- double& rcond, double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DSYCON( &uplo, &n, a, &lda, ipiv, &anorm, &rcond, work, iwork,
- &info );
- }
- inline void sycon( const char uplo, const integer_t n,
- const traits::complex_f* a, const integer_t lda,
- const integer_t* ipiv, const float anorm, float& rcond,
- traits::complex_f* work, integer_t& info ) {
- LAPACK_CSYCON( &uplo, &n, traits::complex_ptr(a), &lda, ipiv, &anorm,
- &rcond, traits::complex_ptr(work), &info );
- }
- inline void sycon( const char uplo, const integer_t n,
- const traits::complex_d* a, const integer_t lda,
- const integer_t* ipiv, const double anorm, double& rcond,
- traits::complex_d* work, integer_t& info ) {
- LAPACK_ZSYCON( &uplo, &n, traits::complex_ptr(a), &lda, ipiv, &anorm,
- &rcond, traits::complex_ptr(work), &info );
- }
+
+inline void sycon( const char uplo, const integer_t n, const float* a,
+ const integer_t lda, const integer_t* ipiv, const float anorm,
+ float& rcond, float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SSYCON( &uplo, &n, a, &lda, ipiv, &anorm, &rcond, work, iwork,
+ &info );
 }
 
+inline void sycon( const char uplo, const integer_t n, const double* a,
+ const integer_t lda, const integer_t* ipiv, const double anorm,
+ double& rcond, double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DSYCON( &uplo, &n, a, &lda, ipiv, &anorm, &rcond, work, iwork,
+ &info );
+}
+
+inline void sycon( const char uplo, const integer_t n,
+ const traits::complex_f* a, const integer_t lda,
+ const integer_t* ipiv, const float anorm, float& rcond,
+ traits::complex_f* work, integer_t& info ) {
+ LAPACK_CSYCON( &uplo, &n, traits::complex_ptr(a), &lda, ipiv, &anorm,
+ &rcond, traits::complex_ptr(work), &info );
+}
+
+inline void sycon( const char uplo, const integer_t n,
+ const traits::complex_d* a, const integer_t lda,
+ const integer_t* ipiv, const double anorm, double& rcond,
+ traits::complex_d* work, integer_t& info ) {
+ LAPACK_ZSYCON( &uplo, &n, traits::complex_ptr(a), &lda, ipiv, &anorm,
+ &rcond, traits::complex_ptr(work), &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct sycon_impl{};
@@ -208,6 +213,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,18 +31,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sygst( const integer_t itype, const char uplo,
- const integer_t n, float* a, const integer_t lda, const float* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_SSYGST( &itype, &uplo, &n, a, &lda, b, &ldb, &info );
- }
- inline void sygst( const integer_t itype, const char uplo,
- const integer_t n, double* a, const integer_t lda,
- const double* b, const integer_t ldb, integer_t& info ) {
- LAPACK_DSYGST( &itype, &uplo, &n, a, &lda, b, &ldb, &info );
- }
+
+inline void sygst( const integer_t itype, const char uplo, const integer_t n,
+ float* a, const integer_t lda, const float* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_SSYGST( &itype, &uplo, &n, a, &lda, b, &ldb, &info );
 }
 
+inline void sygst( const integer_t itype, const char uplo, const integer_t n,
+ double* a, const integer_t lda, const double* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_DSYGST( &itype, &uplo, &n, a, &lda, b, &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct sygst_impl {
@@ -80,6 +83,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,52 +36,53 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void syrfs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* a, const integer_t lda,
- const float* af, const integer_t ldaf, const integer_t* ipiv,
- const float* b, const integer_t ldb, float* x,
- const integer_t ldx, float* ferr, float* berr, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SSYRFS( &uplo, &n, &nrhs, a, &lda, af, &ldaf, ipiv, b, &ldb, x,
- &ldx, ferr, berr, work, iwork, &info );
- }
- inline void syrfs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* a, const integer_t lda,
- const double* af, const integer_t ldaf, const integer_t* ipiv,
- const double* b, const integer_t ldb, double* x,
- const integer_t ldx, double* ferr, double* berr, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DSYRFS( &uplo, &n, &nrhs, a, &lda, af, &ldaf, ipiv, b, &ldb, x,
- &ldx, ferr, berr, work, iwork, &info );
- }
- inline void syrfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* af,
- const integer_t ldaf, const integer_t* ipiv,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float* ferr,
- float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CSYRFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void syrfs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* af,
- const integer_t ldaf, const integer_t* ipiv,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double* ferr,
- double* berr, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZSYRFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void syrfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* a, const integer_t lda, const float* af,
+ const integer_t ldaf, const integer_t* ipiv, const float* b,
+ const integer_t ldb, float* x, const integer_t ldx, float* ferr,
+ float* berr, float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SSYRFS( &uplo, &n, &nrhs, a, &lda, af, &ldaf, ipiv, b, &ldb, x,
+ &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void syrfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* a, const integer_t lda, const double* af,
+ const integer_t ldaf, const integer_t* ipiv, const double* b,
+ const integer_t ldb, double* x, const integer_t ldx, double* ferr,
+ double* berr, double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DSYRFS( &uplo, &n, &nrhs, a, &lda, af, &ldaf, ipiv, b, &ldb, x,
+ &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void syrfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* af, const integer_t ldaf,
+ const integer_t* ipiv, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float* ferr, float* berr, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CSYRFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void syrfs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* af, const integer_t ldaf,
+ const integer_t* ipiv, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZSYRFS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct syrfs_impl{};
@@ -308,6 +309,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,18 +34,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sytrd( const char uplo, const integer_t n, float* a,
- const integer_t lda, float* d, float* e, float* tau, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SSYTRD( &uplo, &n, a, &lda, d, e, tau, work, &lwork, &info );
- }
- inline void sytrd( const char uplo, const integer_t n, double* a,
- const integer_t lda, double* d, double* e, double* tau,
- double* work, const integer_t lwork, integer_t& info ) {
- LAPACK_DSYTRD( &uplo, &n, a, &lda, d, e, tau, work, &lwork, &info );
- }
+
+inline void sytrd( const char uplo, const integer_t n, float* a,
+ const integer_t lda, float* d, float* e, float* tau, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SSYTRD( &uplo, &n, a, &lda, d, e, tau, work, &lwork, &info );
 }
 
+inline void sytrd( const char uplo, const integer_t n, double* a,
+ const integer_t lda, double* d, double* e, double* tau, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DSYTRD( &uplo, &n, a, &lda, d, e, tau, work, &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct sytrd_impl {
@@ -141,6 +144,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,30 +37,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sytrf( const char uplo, const integer_t n, float* a,
- const integer_t lda, integer_t* ipiv, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SSYTRF( &uplo, &n, a, &lda, ipiv, work, &lwork, &info );
- }
- inline void sytrf( const char uplo, const integer_t n, double* a,
- const integer_t lda, integer_t* ipiv, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DSYTRF( &uplo, &n, a, &lda, ipiv, work, &lwork, &info );
- }
- inline void sytrf( const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, integer_t* ipiv,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CSYTRF( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void sytrf( const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, integer_t* ipiv,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZSYTRF( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void sytrf( const char uplo, const integer_t n, float* a,
+ const integer_t lda, integer_t* ipiv, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SSYTRF( &uplo, &n, a, &lda, ipiv, work, &lwork, &info );
 }
 
+inline void sytrf( const char uplo, const integer_t n, double* a,
+ const integer_t lda, integer_t* ipiv, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DSYTRF( &uplo, &n, a, &lda, ipiv, work, &lwork, &info );
+}
+
+inline void sytrf( const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, integer_t* ipiv, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CSYTRF( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+inline void sytrf( const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, integer_t* ipiv, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZSYTRF( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct sytrf_impl{};
@@ -191,6 +196,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,30 +36,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sytri( const char uplo, const integer_t n, float* a,
- const integer_t lda, const integer_t* ipiv, float* work,
- integer_t& info ) {
- LAPACK_SSYTRI( &uplo, &n, a, &lda, ipiv, work, &info );
- }
- inline void sytri( const char uplo, const integer_t n, double* a,
- const integer_t lda, const integer_t* ipiv, double* work,
- integer_t& info ) {
- LAPACK_DSYTRI( &uplo, &n, a, &lda, ipiv, work, &info );
- }
- inline void sytri( const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, const integer_t* ipiv,
- traits::complex_f* work, integer_t& info ) {
- LAPACK_CSYTRI( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &info );
- }
- inline void sytri( const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, const integer_t* ipiv,
- traits::complex_d* work, integer_t& info ) {
- LAPACK_ZSYTRI( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(work), &info );
- }
+
+inline void sytri( const char uplo, const integer_t n, float* a,
+ const integer_t lda, const integer_t* ipiv, float* work,
+ integer_t& info ) {
+ LAPACK_SSYTRI( &uplo, &n, a, &lda, ipiv, work, &info );
 }
 
+inline void sytri( const char uplo, const integer_t n, double* a,
+ const integer_t lda, const integer_t* ipiv, double* work,
+ integer_t& info ) {
+ LAPACK_DSYTRI( &uplo, &n, a, &lda, ipiv, work, &info );
+}
+
+inline void sytri( const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, const integer_t* ipiv, traits::complex_f* work,
+ integer_t& info ) {
+ LAPACK_CSYTRI( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &info );
+}
+
+inline void sytri( const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, const integer_t* ipiv, traits::complex_d* work,
+ integer_t& info ) {
+ LAPACK_ZSYTRI( &uplo, &n, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(work), &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct sytri_impl{};
@@ -178,6 +183,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,34 +31,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sytrs( const char uplo, const integer_t n,
- const integer_t nrhs, const float* a, const integer_t lda,
- const integer_t* ipiv, float* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_SSYTRS( &uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
- }
- inline void sytrs( const char uplo, const integer_t n,
- const integer_t nrhs, const double* a, const integer_t lda,
- const integer_t* ipiv, double* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_DSYTRS( &uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
- }
- inline void sytrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, const integer_t* ipiv, traits::complex_f* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_CSYTRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void sytrs( const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, const integer_t* ipiv, traits::complex_d* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_ZSYTRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void sytrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const float* a, const integer_t lda, const integer_t* ipiv, float* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_SSYTRS( &uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
+}
+
+inline void sytrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const double* a, const integer_t lda, const integer_t* ipiv,
+ double* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_DSYTRS( &uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
+}
+
+inline void sytrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_f* a, const integer_t lda,
+ const integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CSYTRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void sytrs( const char uplo, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda,
+ const integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZSYTRS( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct sytrs_impl {
@@ -101,6 +104,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,36 +36,41 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tbcon( const char norm, const char uplo, const char diag,
- const integer_t n, const integer_t kd, const float* ab,
- const integer_t ldab, float& rcond, float* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_STBCON( &norm, &uplo, &diag, &n, &kd, ab, &ldab, &rcond, work,
- iwork, &info );
- }
- inline void tbcon( const char norm, const char uplo, const char diag,
- const integer_t n, const integer_t kd, const double* ab,
- const integer_t ldab, double& rcond, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DTBCON( &norm, &uplo, &diag, &n, &kd, ab, &ldab, &rcond, work,
- iwork, &info );
- }
- inline void tbcon( const char norm, const char uplo, const char diag,
- const integer_t n, const integer_t kd,
- const traits::complex_f* ab, const integer_t ldab, float& rcond,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CTBCON( &norm, &uplo, &diag, &n, &kd, traits::complex_ptr(ab),
- &ldab, &rcond, traits::complex_ptr(work), rwork, &info );
- }
- inline void tbcon( const char norm, const char uplo, const char diag,
- const integer_t n, const integer_t kd,
- const traits::complex_d* ab, const integer_t ldab, double& rcond,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZTBCON( &norm, &uplo, &diag, &n, &kd, traits::complex_ptr(ab),
- &ldab, &rcond, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void tbcon( const char norm, const char uplo, const char diag,
+ const integer_t n, const integer_t kd, const float* ab,
+ const integer_t ldab, float& rcond, float* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_STBCON( &norm, &uplo, &diag, &n, &kd, ab, &ldab, &rcond, work,
+ iwork, &info );
 }
 
+inline void tbcon( const char norm, const char uplo, const char diag,
+ const integer_t n, const integer_t kd, const double* ab,
+ const integer_t ldab, double& rcond, double* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DTBCON( &norm, &uplo, &diag, &n, &kd, ab, &ldab, &rcond, work,
+ iwork, &info );
+}
+
+inline void tbcon( const char norm, const char uplo, const char diag,
+ const integer_t n, const integer_t kd, const traits::complex_f* ab,
+ const integer_t ldab, float& rcond, traits::complex_f* work,
+ float* rwork, integer_t& info ) {
+ LAPACK_CTBCON( &norm, &uplo, &diag, &n, &kd, traits::complex_ptr(ab),
+ &ldab, &rcond, traits::complex_ptr(work), rwork, &info );
+}
+
+inline void tbcon( const char norm, const char uplo, const char diag,
+ const integer_t n, const integer_t kd, const traits::complex_d* ab,
+ const integer_t ldab, double& rcond, traits::complex_d* work,
+ double* rwork, integer_t& info ) {
+ LAPACK_ZTBCON( &norm, &uplo, &diag, &n, &kd, traits::complex_ptr(ab),
+ &ldab, &rcond, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tbcon_impl{};
@@ -215,6 +220,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,50 +36,53 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tbrfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t kd, const integer_t nrhs,
- const float* ab, const integer_t ldab, const float* b,
- const integer_t ldb, const float* x, const integer_t ldx,
- float* ferr, float* berr, float* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_STBRFS( &uplo, &trans, &diag, &n, &kd, &nrhs, ab, &ldab, b,
- &ldb, x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void tbrfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t kd, const integer_t nrhs,
- const double* ab, const integer_t ldab, const double* b,
- const integer_t ldb, const double* x, const integer_t ldx,
- double* ferr, double* berr, double* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_DTBRFS( &uplo, &trans, &diag, &n, &kd, &nrhs, ab, &ldab, b,
- &ldb, x, &ldx, ferr, berr, work, iwork, &info );
- }
- inline void tbrfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t kd, const integer_t nrhs,
- const traits::complex_f* ab, const integer_t ldab,
- const traits::complex_f* b, const integer_t ldb,
- const traits::complex_f* x, const integer_t ldx, float* ferr,
- float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CTBRFS( &uplo, &trans, &diag, &n, &kd, &nrhs,
- traits::complex_ptr(ab), &ldab, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void tbrfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t kd, const integer_t nrhs,
- const traits::complex_d* ab, const integer_t ldab,
- const traits::complex_d* b, const integer_t ldb,
- const traits::complex_d* x, const integer_t ldx, double* ferr,
- double* berr, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZTBRFS( &uplo, &trans, &diag, &n, &kd, &nrhs,
- traits::complex_ptr(ab), &ldab, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void tbrfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t kd, const integer_t nrhs,
+ const float* ab, const integer_t ldab, const float* b,
+ const integer_t ldb, const float* x, const integer_t ldx, float* ferr,
+ float* berr, float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_STBRFS( &uplo, &trans, &diag, &n, &kd, &nrhs, ab, &ldab, b, &ldb,
+ x, &ldx, ferr, berr, work, iwork, &info );
 }
 
+inline void tbrfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t kd, const integer_t nrhs,
+ const double* ab, const integer_t ldab, const double* b,
+ const integer_t ldb, const double* x, const integer_t ldx,
+ double* ferr, double* berr, double* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DTBRFS( &uplo, &trans, &diag, &n, &kd, &nrhs, ab, &ldab, b, &ldb,
+ x, &ldx, ferr, berr, work, iwork, &info );
+}
+
+inline void tbrfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t kd, const integer_t nrhs,
+ const traits::complex_f* ab, const integer_t ldab,
+ const traits::complex_f* b, const integer_t ldb,
+ const traits::complex_f* x, const integer_t ldx, float* ferr,
+ float* berr, traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CTBRFS( &uplo, &trans, &diag, &n, &kd, &nrhs,
+ traits::complex_ptr(ab), &ldab, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+inline void tbrfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t kd, const integer_t nrhs,
+ const traits::complex_d* ab, const integer_t ldab,
+ const traits::complex_d* b, const integer_t ldb,
+ const traits::complex_d* x, const integer_t ldx, double* ferr,
+ double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZTBRFS( &uplo, &trans, &diag, &n, &kd, &nrhs,
+ traits::complex_ptr(ab), &ldab, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tbrfs_impl{};
@@ -282,6 +285,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,38 +31,43 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tbtrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t kd, const integer_t nrhs,
- const float* ab, const integer_t ldab, float* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_STBTRS( &uplo, &trans, &diag, &n, &kd, &nrhs, ab, &ldab, b,
- &ldb, &info );
- }
- inline void tbtrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t kd, const integer_t nrhs,
- const double* ab, const integer_t ldab, double* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_DTBTRS( &uplo, &trans, &diag, &n, &kd, &nrhs, ab, &ldab, b,
- &ldb, &info );
- }
- inline void tbtrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t kd, const integer_t nrhs,
- const traits::complex_f* ab, const integer_t ldab,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CTBTRS( &uplo, &trans, &diag, &n, &kd, &nrhs,
- traits::complex_ptr(ab), &ldab, traits::complex_ptr(b), &ldb,
- &info );
- }
- inline void tbtrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t kd, const integer_t nrhs,
- const traits::complex_d* ab, const integer_t ldab,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZTBTRS( &uplo, &trans, &diag, &n, &kd, &nrhs,
- traits::complex_ptr(ab), &ldab, traits::complex_ptr(b), &ldb,
- &info );
- }
+
+inline void tbtrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t kd, const integer_t nrhs,
+ const float* ab, const integer_t ldab, float* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_STBTRS( &uplo, &trans, &diag, &n, &kd, &nrhs, ab, &ldab, b, &ldb,
+ &info );
+}
+
+inline void tbtrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t kd, const integer_t nrhs,
+ const double* ab, const integer_t ldab, double* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_DTBTRS( &uplo, &trans, &diag, &n, &kd, &nrhs, ab, &ldab, b, &ldb,
+ &info );
+}
+
+inline void tbtrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t kd, const integer_t nrhs,
+ const traits::complex_f* ab, const integer_t ldab,
+ traits::complex_f* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_CTBTRS( &uplo, &trans, &diag, &n, &kd, &nrhs,
+ traits::complex_ptr(ab), &ldab, traits::complex_ptr(b), &ldb,
+ &info );
 }
 
+inline void tbtrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t kd, const integer_t nrhs,
+ const traits::complex_d* ab, const integer_t ldab,
+ traits::complex_d* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_ZTBTRS( &uplo, &trans, &diag, &n, &kd, &nrhs,
+ traits::complex_ptr(ab), &ldab, traits::complex_ptr(b), &ldb,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct tbtrs_impl {
@@ -106,6 +111,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,51 +36,53 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tgevc( const char side, const char howmny,
- const logical_t* select, const integer_t n, const float* s,
- const integer_t lds, const float* p, const integer_t ldp,
- float* vl, const integer_t ldvl, float* vr, const integer_t ldvr,
- const integer_t mm, integer_t& m, float* work, integer_t& info ) {
- LAPACK_STGEVC( &side, &howmny, select, &n, s, &lds, p, &ldp, vl,
- &ldvl, vr, &ldvr, &mm, &m, work, &info );
- }
- inline void tgevc( const char side, const char howmny,
- const logical_t* select, const integer_t n, const double* s,
- const integer_t lds, const double* p, const integer_t ldp,
- double* vl, const integer_t ldvl, double* vr,
- const integer_t ldvr, const integer_t mm, integer_t& m,
- double* work, integer_t& info ) {
- LAPACK_DTGEVC( &side, &howmny, select, &n, s, &lds, p, &ldp, vl,
- &ldvl, vr, &ldvr, &mm, &m, work, &info );
- }
- inline void tgevc( const char side, const char howmny,
- const logical_t* select, const integer_t n,
- const traits::complex_f* s, const integer_t lds,
- const traits::complex_f* p, const integer_t ldp,
- traits::complex_f* vl, const integer_t ldvl,
- traits::complex_f* vr, const integer_t ldvr, const integer_t mm,
- integer_t& m, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CTGEVC( &side, &howmny, select, &n, traits::complex_ptr(s),
- &lds, traits::complex_ptr(p), &ldp, traits::complex_ptr(vl),
- &ldvl, traits::complex_ptr(vr), &ldvr, &mm, &m,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void tgevc( const char side, const char howmny,
- const logical_t* select, const integer_t n,
- const traits::complex_d* s, const integer_t lds,
- const traits::complex_d* p, const integer_t ldp,
- traits::complex_d* vl, const integer_t ldvl,
- traits::complex_d* vr, const integer_t ldvr, const integer_t mm,
- integer_t& m, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZTGEVC( &side, &howmny, select, &n, traits::complex_ptr(s),
- &lds, traits::complex_ptr(p), &ldp, traits::complex_ptr(vl),
- &ldvl, traits::complex_ptr(vr), &ldvr, &mm, &m,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void tgevc( const char side, const char howmny,
+ const logical_t* select, const integer_t n, const float* s,
+ const integer_t lds, const float* p, const integer_t ldp, float* vl,
+ const integer_t ldvl, float* vr, const integer_t ldvr,
+ const integer_t mm, integer_t& m, float* work, integer_t& info ) {
+ LAPACK_STGEVC( &side, &howmny, select, &n, s, &lds, p, &ldp, vl, &ldvl,
+ vr, &ldvr, &mm, &m, work, &info );
 }
 
+inline void tgevc( const char side, const char howmny,
+ const logical_t* select, const integer_t n, const double* s,
+ const integer_t lds, const double* p, const integer_t ldp, double* vl,
+ const integer_t ldvl, double* vr, const integer_t ldvr,
+ const integer_t mm, integer_t& m, double* work, integer_t& info ) {
+ LAPACK_DTGEVC( &side, &howmny, select, &n, s, &lds, p, &ldp, vl, &ldvl,
+ vr, &ldvr, &mm, &m, work, &info );
+}
+
+inline void tgevc( const char side, const char howmny,
+ const logical_t* select, const integer_t n,
+ const traits::complex_f* s, const integer_t lds,
+ const traits::complex_f* p, const integer_t ldp,
+ traits::complex_f* vl, const integer_t ldvl, traits::complex_f* vr,
+ const integer_t ldvr, const integer_t mm, integer_t& m,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CTGEVC( &side, &howmny, select, &n, traits::complex_ptr(s), &lds,
+ traits::complex_ptr(p), &ldp, traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, &mm, &m,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+inline void tgevc( const char side, const char howmny,
+ const logical_t* select, const integer_t n,
+ const traits::complex_d* s, const integer_t lds,
+ const traits::complex_d* p, const integer_t ldp,
+ traits::complex_d* vl, const integer_t ldvl, traits::complex_d* vr,
+ const integer_t ldvr, const integer_t mm, integer_t& m,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZTGEVC( &side, &howmny, select, &n, traits::complex_ptr(s), &lds,
+ traits::complex_ptr(p), &ldp, traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, &mm, &m,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tgevc_impl{};
@@ -258,6 +260,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,42 +37,47 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tgexc( const logical_t wantq, const logical_t wantz,
- const integer_t n, float* a, const integer_t lda, float* b,
- const integer_t ldb, float* q, const integer_t ldq, float* z,
- const integer_t ldz, integer_t& ifst, integer_t& ilst,
- float* work, const integer_t lwork, integer_t& info ) {
- LAPACK_STGEXC( &wantq, &wantz, &n, a, &lda, b, &ldb, q, &ldq, z, &ldz,
- &ifst, &ilst, work, &lwork, &info );
- }
- inline void tgexc( const logical_t wantq, const logical_t wantz,
- const integer_t n, double* a, const integer_t lda, double* b,
- const integer_t ldb, double* q, const integer_t ldq, double* z,
- const integer_t ldz, integer_t& ifst, integer_t& ilst,
- double* work, const integer_t lwork, integer_t& info ) {
- LAPACK_DTGEXC( &wantq, &wantz, &n, a, &lda, b, &ldb, q, &ldq, z, &ldz,
- &ifst, &ilst, work, &lwork, &info );
- }
- inline void tgexc( const logical_t wantq, const logical_t wantz,
- const integer_t n, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, traits::complex_f* q,
- const integer_t ldq, traits::complex_f* z, const integer_t ldz,
- const integer_t ifst, integer_t& ilst, integer_t& info ) {
- LAPACK_CTGEXC( &wantq, &wantz, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(q), &ldq,
- traits::complex_ptr(z), &ldz, &ifst, &ilst, &info );
- }
- inline void tgexc( const logical_t wantq, const logical_t wantz,
- const integer_t n, traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb, traits::complex_d* q,
- const integer_t ldq, traits::complex_d* z, const integer_t ldz,
- const integer_t ifst, integer_t& ilst, integer_t& info ) {
- LAPACK_ZTGEXC( &wantq, &wantz, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(q), &ldq,
- traits::complex_ptr(z), &ldz, &ifst, &ilst, &info );
- }
+
+inline void tgexc( const logical_t wantq, const logical_t wantz,
+ const integer_t n, float* a, const integer_t lda, float* b,
+ const integer_t ldb, float* q, const integer_t ldq, float* z,
+ const integer_t ldz, integer_t& ifst, integer_t& ilst, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_STGEXC( &wantq, &wantz, &n, a, &lda, b, &ldb, q, &ldq, z, &ldz,
+ &ifst, &ilst, work, &lwork, &info );
+}
+
+inline void tgexc( const logical_t wantq, const logical_t wantz,
+ const integer_t n, double* a, const integer_t lda, double* b,
+ const integer_t ldb, double* q, const integer_t ldq, double* z,
+ const integer_t ldz, integer_t& ifst, integer_t& ilst, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DTGEXC( &wantq, &wantz, &n, a, &lda, b, &ldb, q, &ldq, z, &ldz,
+ &ifst, &ilst, work, &lwork, &info );
+}
+
+inline void tgexc( const logical_t wantq, const logical_t wantz,
+ const integer_t n, traits::complex_f* a, const integer_t lda,
+ traits::complex_f* b, const integer_t ldb, traits::complex_f* q,
+ const integer_t ldq, traits::complex_f* z, const integer_t ldz,
+ const integer_t ifst, integer_t& ilst, integer_t& info ) {
+ LAPACK_CTGEXC( &wantq, &wantz, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(z), &ldz, &ifst, &ilst, &info );
 }
 
+inline void tgexc( const logical_t wantq, const logical_t wantz,
+ const integer_t n, traits::complex_d* a, const integer_t lda,
+ traits::complex_d* b, const integer_t ldb, traits::complex_d* q,
+ const integer_t ldq, traits::complex_d* z, const integer_t ldz,
+ const integer_t ifst, integer_t& ilst, integer_t& info ) {
+ LAPACK_ZTGEXC( &wantq, &wantz, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(z), &ldz, &ifst, &ilst, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tgexc_impl{};
@@ -211,6 +216,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,64 +37,65 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tgsen( const integer_t ijob, const logical_t wantq,
- const logical_t wantz, const logical_t* select, const integer_t n,
- float* a, const integer_t lda, float* b, const integer_t ldb,
- float* alphar, float* alphai, float* beta, float* q,
- const integer_t ldq, float* z, const integer_t ldz, integer_t& m,
- float& pl, float& pr, float* dif, float* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_STGSEN( &ijob, &wantq, &wantz, select, &n, a, &lda, b, &ldb,
- alphar, alphai, beta, q, &ldq, z, &ldz, &m, &pl, &pr, dif,
- work, &lwork, iwork, &liwork, &info );
- }
- inline void tgsen( const integer_t ijob, const logical_t wantq,
- const logical_t wantz, const logical_t* select, const integer_t n,
- double* a, const integer_t lda, double* b, const integer_t ldb,
- double* alphar, double* alphai, double* beta, double* q,
- const integer_t ldq, double* z, const integer_t ldz, integer_t& m,
- double& pl, double& pr, double* dif, double* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_DTGSEN( &ijob, &wantq, &wantz, select, &n, a, &lda, b, &ldb,
- alphar, alphai, beta, q, &ldq, z, &ldz, &m, &pl, &pr, dif,
- work, &lwork, iwork, &liwork, &info );
- }
- inline void tgsen( const integer_t ijob, const logical_t wantq,
- const logical_t wantz, const logical_t* select, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* b,
- const integer_t ldb, traits::complex_f* alpha,
- traits::complex_f* beta, traits::complex_f* q,
- const integer_t ldq, traits::complex_f* z, const integer_t ldz,
- integer_t& m, float& pl, float& pr, float* dif,
- traits::complex_f* work, const integer_t lwork, integer_t* iwork,
- const integer_t liwork, integer_t& info ) {
- LAPACK_CTGSEN( &ijob, &wantq, &wantz, select, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(q), &ldq, traits::complex_ptr(z), &ldz,
- &m, &pl, &pr, dif, traits::complex_ptr(work), &lwork, iwork,
- &liwork, &info );
- }
- inline void tgsen( const integer_t ijob, const logical_t wantq,
- const logical_t wantz, const logical_t* select, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* b,
- const integer_t ldb, traits::complex_d* alpha,
- traits::complex_d* beta, traits::complex_d* q,
- const integer_t ldq, traits::complex_d* z, const integer_t ldz,
- integer_t& m, double& pl, double& pr, double* dif,
- traits::complex_d* work, const integer_t lwork, integer_t* iwork,
- const integer_t liwork, integer_t& info ) {
- LAPACK_ZTGSEN( &ijob, &wantq, &wantz, select, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(q), &ldq, traits::complex_ptr(z), &ldz,
- &m, &pl, &pr, dif, traits::complex_ptr(work), &lwork, iwork,
- &liwork, &info );
- }
+
+inline void tgsen( const integer_t ijob, const logical_t wantq,
+ const logical_t wantz, const logical_t* select, const integer_t n,
+ float* a, const integer_t lda, float* b, const integer_t ldb,
+ float* alphar, float* alphai, float* beta, float* q,
+ const integer_t ldq, float* z, const integer_t ldz, integer_t& m,
+ float& pl, float& pr, float* dif, float* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_STGSEN( &ijob, &wantq, &wantz, select, &n, a, &lda, b, &ldb,
+ alphar, alphai, beta, q, &ldq, z, &ldz, &m, &pl, &pr, dif, work,
+ &lwork, iwork, &liwork, &info );
+}
+
+inline void tgsen( const integer_t ijob, const logical_t wantq,
+ const logical_t wantz, const logical_t* select, const integer_t n,
+ double* a, const integer_t lda, double* b, const integer_t ldb,
+ double* alphar, double* alphai, double* beta, double* q,
+ const integer_t ldq, double* z, const integer_t ldz, integer_t& m,
+ double& pl, double& pr, double* dif, double* work,
+ const integer_t lwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_DTGSEN( &ijob, &wantq, &wantz, select, &n, a, &lda, b, &ldb,
+ alphar, alphai, beta, q, &ldq, z, &ldz, &m, &pl, &pr, dif, work,
+ &lwork, iwork, &liwork, &info );
+}
+
+inline void tgsen( const integer_t ijob, const logical_t wantq,
+ const logical_t wantz, const logical_t* select, const integer_t n,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* alpha,
+ traits::complex_f* beta, traits::complex_f* q, const integer_t ldq,
+ traits::complex_f* z, const integer_t ldz, integer_t& m, float& pl,
+ float& pr, float* dif, traits::complex_f* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, integer_t& info ) {
+ LAPACK_CTGSEN( &ijob, &wantq, &wantz, select, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
+ traits::complex_ptr(beta), traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(z), &ldz, &m, &pl, &pr, dif,
+ traits::complex_ptr(work), &lwork, iwork, &liwork, &info );
 }
 
+inline void tgsen( const integer_t ijob, const logical_t wantq,
+ const logical_t wantz, const logical_t* select, const integer_t n,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* alpha,
+ traits::complex_d* beta, traits::complex_d* q, const integer_t ldq,
+ traits::complex_d* z, const integer_t ldz, integer_t& m, double& pl,
+ double& pr, double* dif, traits::complex_d* work,
+ const integer_t lwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_ZTGSEN( &ijob, &wantq, &wantz, select, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
+ traits::complex_ptr(beta), traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(z), &ldz, &m, &pl, &pr, dif,
+ traits::complex_ptr(work), &lwork, iwork, &liwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tgsen_impl{};
@@ -407,6 +408,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,60 +36,63 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tgsja( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t p, const integer_t n,
- const integer_t k, const integer_t l, float* a,
- const integer_t lda, float* b, const integer_t ldb,
- const float tola, const float tolb, float* alpha, float* beta,
- float* u, const integer_t ldu, float* v, const integer_t ldv,
- float* q, const integer_t ldq, float* work, integer_t& ncycle,
- integer_t& info ) {
- LAPACK_STGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l, a, &lda, b,
- &ldb, &tola, &tolb, alpha, beta, u, &ldu, v, &ldv, q, &ldq,
- work, &ncycle, &info );
- }
- inline void tgsja( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t p, const integer_t n,
- const integer_t k, const integer_t l, double* a,
- const integer_t lda, double* b, const integer_t ldb,
- const double tola, const double tolb, double* alpha, double* beta,
- double* u, const integer_t ldu, double* v, const integer_t ldv,
- double* q, const integer_t ldq, double* work, integer_t& ncycle,
- integer_t& info ) {
- LAPACK_DTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l, a, &lda, b,
- &ldb, &tola, &tolb, alpha, beta, u, &ldu, v, &ldv, q, &ldq,
- work, &ncycle, &info );
- }
- inline void tgsja( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t p, const integer_t n,
- const integer_t k, const integer_t l, traits::complex_f* a,
- const integer_t lda, traits::complex_f* b, const integer_t ldb,
- const float tola, const float tolb, float* alpha, float* beta,
- traits::complex_f* u, const integer_t ldu, traits::complex_f* v,
- const integer_t ldv, traits::complex_f* q, const integer_t ldq,
- traits::complex_f* work, integer_t& ncycle, integer_t& info ) {
- LAPACK_CTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &tola, &tolb, alpha, beta, traits::complex_ptr(u), &ldu,
- traits::complex_ptr(v), &ldv, traits::complex_ptr(q), &ldq,
- traits::complex_ptr(work), &ncycle, &info );
- }
- inline void tgsja( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t p, const integer_t n,
- const integer_t k, const integer_t l, traits::complex_d* a,
- const integer_t lda, traits::complex_d* b, const integer_t ldb,
- const double tola, const double tolb, double* alpha, double* beta,
- traits::complex_d* u, const integer_t ldu, traits::complex_d* v,
- const integer_t ldv, traits::complex_d* q, const integer_t ldq,
- traits::complex_d* work, integer_t& ncycle, integer_t& info ) {
- LAPACK_ZTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &tola, &tolb, alpha, beta, traits::complex_ptr(u), &ldu,
- traits::complex_ptr(v), &ldv, traits::complex_ptr(q), &ldq,
- traits::complex_ptr(work), &ncycle, &info );
- }
+
+inline void tgsja( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t p, const integer_t n,
+ const integer_t k, const integer_t l, float* a, const integer_t lda,
+ float* b, const integer_t ldb, const float tola, const float tolb,
+ float* alpha, float* beta, float* u, const integer_t ldu, float* v,
+ const integer_t ldv, float* q, const integer_t ldq, float* work,
+ integer_t& ncycle, integer_t& info ) {
+ LAPACK_STGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l, a, &lda, b, &ldb,
+ &tola, &tolb, alpha, beta, u, &ldu, v, &ldv, q, &ldq, work,
+ &ncycle, &info );
+}
+
+inline void tgsja( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t p, const integer_t n,
+ const integer_t k, const integer_t l, double* a, const integer_t lda,
+ double* b, const integer_t ldb, const double tola, const double tolb,
+ double* alpha, double* beta, double* u, const integer_t ldu,
+ double* v, const integer_t ldv, double* q, const integer_t ldq,
+ double* work, integer_t& ncycle, integer_t& info ) {
+ LAPACK_DTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l, a, &lda, b, &ldb,
+ &tola, &tolb, alpha, beta, u, &ldu, v, &ldv, q, &ldq, work,
+ &ncycle, &info );
+}
+
+inline void tgsja( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t p, const integer_t n,
+ const integer_t k, const integer_t l, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* b, const integer_t ldb,
+ const float tola, const float tolb, float* alpha, float* beta,
+ traits::complex_f* u, const integer_t ldu, traits::complex_f* v,
+ const integer_t ldv, traits::complex_f* q, const integer_t ldq,
+ traits::complex_f* work, integer_t& ncycle, integer_t& info ) {
+ LAPACK_CTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, &tola,
+ &tolb, alpha, beta, traits::complex_ptr(u), &ldu,
+ traits::complex_ptr(v), &ldv, traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(work), &ncycle, &info );
 }
 
+inline void tgsja( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t p, const integer_t n,
+ const integer_t k, const integer_t l, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* b, const integer_t ldb,
+ const double tola, const double tolb, double* alpha, double* beta,
+ traits::complex_d* u, const integer_t ldu, traits::complex_d* v,
+ const integer_t ldv, traits::complex_d* q, const integer_t ldq,
+ traits::complex_d* work, integer_t& ncycle, integer_t& info ) {
+ LAPACK_ZTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, &tola,
+ &tolb, alpha, beta, traits::complex_ptr(u), &ldu,
+ traits::complex_ptr(v), &ldv, traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(work), &ncycle, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tgsja_impl{};
@@ -322,6 +325,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,56 +37,57 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tgsna( const char job, const char howmny,
- const logical_t* select, const integer_t n, const float* a,
- const integer_t lda, const float* b, const integer_t ldb,
- const float* vl, const integer_t ldvl, const float* vr,
- const integer_t ldvr, float* s, float* dif, const integer_t mm,
- integer_t& m, float* work, const integer_t lwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_STGSNA( &job, &howmny, select, &n, a, &lda, b, &ldb, vl, &ldvl,
- vr, &ldvr, s, dif, &mm, &m, work, &lwork, iwork, &info );
- }
- inline void tgsna( const char job, const char howmny,
- const logical_t* select, const integer_t n, const double* a,
- const integer_t lda, const double* b, const integer_t ldb,
- const double* vl, const integer_t ldvl, const double* vr,
- const integer_t ldvr, double* s, double* dif, const integer_t mm,
- integer_t& m, double* work, const integer_t lwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DTGSNA( &job, &howmny, select, &n, a, &lda, b, &ldb, vl, &ldvl,
- vr, &ldvr, s, dif, &mm, &m, work, &lwork, iwork, &info );
- }
- inline void tgsna( const char job, const char howmny,
- const logical_t* select, const integer_t n,
- const traits::complex_f* a, const integer_t lda,
- const traits::complex_f* b, const integer_t ldb,
- const traits::complex_f* vl, const integer_t ldvl,
- const traits::complex_f* vr, const integer_t ldvr, float* s,
- float* dif, const integer_t mm, integer_t& m,
- traits::complex_f* work, const integer_t lwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_CTGSNA( &job, &howmny, select, &n, traits::complex_ptr(a),
- &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(vl),
- &ldvl, traits::complex_ptr(vr), &ldvr, s, dif, &mm, &m,
- traits::complex_ptr(work), &lwork, iwork, &info );
- }
- inline void tgsna( const char job, const char howmny,
- const logical_t* select, const integer_t n,
- const traits::complex_d* a, const integer_t lda,
- const traits::complex_d* b, const integer_t ldb,
- const traits::complex_d* vl, const integer_t ldvl,
- const traits::complex_d* vr, const integer_t ldvr, double* s,
- double* dif, const integer_t mm, integer_t& m,
- traits::complex_d* work, const integer_t lwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_ZTGSNA( &job, &howmny, select, &n, traits::complex_ptr(a),
- &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(vl),
- &ldvl, traits::complex_ptr(vr), &ldvr, s, dif, &mm, &m,
- traits::complex_ptr(work), &lwork, iwork, &info );
- }
+
+inline void tgsna( const char job, const char howmny, const logical_t* select,
+ const integer_t n, const float* a, const integer_t lda,
+ const float* b, const integer_t ldb, const float* vl,
+ const integer_t ldvl, const float* vr, const integer_t ldvr, float* s,
+ float* dif, const integer_t mm, integer_t& m, float* work,
+ const integer_t lwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_STGSNA( &job, &howmny, select, &n, a, &lda, b, &ldb, vl, &ldvl, vr,
+ &ldvr, s, dif, &mm, &m, work, &lwork, iwork, &info );
+}
+
+inline void tgsna( const char job, const char howmny, const logical_t* select,
+ const integer_t n, const double* a, const integer_t lda,
+ const double* b, const integer_t ldb, const double* vl,
+ const integer_t ldvl, const double* vr, const integer_t ldvr,
+ double* s, double* dif, const integer_t mm, integer_t& m,
+ double* work, const integer_t lwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DTGSNA( &job, &howmny, select, &n, a, &lda, b, &ldb, vl, &ldvl, vr,
+ &ldvr, s, dif, &mm, &m, work, &lwork, iwork, &info );
+}
+
+inline void tgsna( const char job, const char howmny, const logical_t* select,
+ const integer_t n, const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* b, const integer_t ldb,
+ const traits::complex_f* vl, const integer_t ldvl,
+ const traits::complex_f* vr, const integer_t ldvr, float* s,
+ float* dif, const integer_t mm, integer_t& m, traits::complex_f* work,
+ const integer_t lwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_CTGSNA( &job, &howmny, select, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, s, dif, &mm, &m,
+ traits::complex_ptr(work), &lwork, iwork, &info );
 }
 
+inline void tgsna( const char job, const char howmny, const logical_t* select,
+ const integer_t n, const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* b, const integer_t ldb,
+ const traits::complex_d* vl, const integer_t ldvl,
+ const traits::complex_d* vr, const integer_t ldvr, double* s,
+ double* dif, const integer_t mm, integer_t& m,
+ traits::complex_d* work, const integer_t lwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_ZTGSNA( &job, &howmny, select, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, s, dif, &mm, &m,
+ traits::complex_ptr(work), &lwork, iwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tgsna_impl{};
@@ -313,6 +314,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,62 +37,61 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tgsyl( const char trans, const integer_t ijob,
- const integer_t m, const integer_t n, const float* a,
- const integer_t lda, const float* b, const integer_t ldb,
- float* c, const integer_t ldc, const float* d,
- const integer_t ldd, const float* e, const integer_t lde,
- float* f, const integer_t ldf, float& scale, float& dif,
- float* work, const integer_t lwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_STGSYL( &trans, &ijob, &m, &n, a, &lda, b, &ldb, c, &ldc, d,
- &ldd, e, &lde, f, &ldf, &scale, &dif, work, &lwork, iwork,
- &info );
- }
- inline void tgsyl( const char trans, const integer_t ijob,
- const integer_t m, const integer_t n, const double* a,
- const integer_t lda, const double* b, const integer_t ldb,
- double* c, const integer_t ldc, const double* d,
- const integer_t ldd, const double* e, const integer_t lde,
- double* f, const integer_t ldf, double& scale, double& dif,
- double* work, const integer_t lwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_DTGSYL( &trans, &ijob, &m, &n, a, &lda, b, &ldb, c, &ldc, d,
- &ldd, e, &lde, f, &ldf, &scale, &dif, work, &lwork, iwork,
- &info );
- }
- inline void tgsyl( const char trans, const integer_t ijob,
- const integer_t m, const integer_t n, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* b,
- const integer_t ldb, traits::complex_f* c, const integer_t ldc,
- const traits::complex_f* d, const integer_t ldd,
- const traits::complex_f* e, const integer_t lde,
- traits::complex_f* f, const integer_t ldf, float& scale,
- float& dif, traits::complex_f* work, const integer_t lwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_CTGSYL( &trans, &ijob, &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(c), &ldc,
- traits::complex_ptr(d), &ldd, traits::complex_ptr(e), &lde,
- traits::complex_ptr(f), &ldf, &scale, &dif,
- traits::complex_ptr(work), &lwork, iwork, &info );
- }
- inline void tgsyl( const char trans, const integer_t ijob,
- const integer_t m, const integer_t n, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* b,
- const integer_t ldb, traits::complex_d* c, const integer_t ldc,
- const traits::complex_d* d, const integer_t ldd,
- const traits::complex_d* e, const integer_t lde,
- traits::complex_d* f, const integer_t ldf, double& scale,
- double& dif, traits::complex_d* work, const integer_t lwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_ZTGSYL( &trans, &ijob, &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(c), &ldc,
- traits::complex_ptr(d), &ldd, traits::complex_ptr(e), &lde,
- traits::complex_ptr(f), &ldf, &scale, &dif,
- traits::complex_ptr(work), &lwork, iwork, &info );
- }
+
+inline void tgsyl( const char trans, const integer_t ijob, const integer_t m,
+ const integer_t n, const float* a, const integer_t lda,
+ const float* b, const integer_t ldb, float* c, const integer_t ldc,
+ const float* d, const integer_t ldd, const float* e,
+ const integer_t lde, float* f, const integer_t ldf, float& scale,
+ float& dif, float* work, const integer_t lwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_STGSYL( &trans, &ijob, &m, &n, a, &lda, b, &ldb, c, &ldc, d, &ldd,
+ e, &lde, f, &ldf, &scale, &dif, work, &lwork, iwork, &info );
+}
+
+inline void tgsyl( const char trans, const integer_t ijob, const integer_t m,
+ const integer_t n, const double* a, const integer_t lda,
+ const double* b, const integer_t ldb, double* c, const integer_t ldc,
+ const double* d, const integer_t ldd, const double* e,
+ const integer_t lde, double* f, const integer_t ldf, double& scale,
+ double& dif, double* work, const integer_t lwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DTGSYL( &trans, &ijob, &m, &n, a, &lda, b, &ldb, c, &ldc, d, &ldd,
+ e, &lde, f, &ldf, &scale, &dif, work, &lwork, iwork, &info );
+}
+
+inline void tgsyl( const char trans, const integer_t ijob, const integer_t m,
+ const integer_t n, const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* b, const integer_t ldb, traits::complex_f* c,
+ const integer_t ldc, const traits::complex_f* d, const integer_t ldd,
+ const traits::complex_f* e, const integer_t lde, traits::complex_f* f,
+ const integer_t ldf, float& scale, float& dif,
+ traits::complex_f* work, const integer_t lwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_CTGSYL( &trans, &ijob, &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(d), &ldd, traits::complex_ptr(e), &lde,
+ traits::complex_ptr(f), &ldf, &scale, &dif,
+ traits::complex_ptr(work), &lwork, iwork, &info );
 }
 
+inline void tgsyl( const char trans, const integer_t ijob, const integer_t m,
+ const integer_t n, const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* b, const integer_t ldb, traits::complex_d* c,
+ const integer_t ldc, const traits::complex_d* d, const integer_t ldd,
+ const traits::complex_d* e, const integer_t lde, traits::complex_d* f,
+ const integer_t ldf, double& scale, double& dif,
+ traits::complex_d* work, const integer_t lwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_ZTGSYL( &trans, &ijob, &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(d), &ldd, traits::complex_ptr(e), &lde,
+ traits::complex_ptr(f), &ldf, &scale, &dif,
+ traits::complex_ptr(work), &lwork, iwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tgsyl_impl{};
@@ -327,6 +326,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,46 +36,48 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tprfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs, const float* ap,
- const float* b, const integer_t ldb, const float* x,
- const integer_t ldx, float* ferr, float* berr, float* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_STPRFS( &uplo, &trans, &diag, &n, &nrhs, ap, b, &ldb, x, &ldx,
- ferr, berr, work, iwork, &info );
- }
- inline void tprfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs, const double* ap,
- const double* b, const integer_t ldb, const double* x,
- const integer_t ldx, double* ferr, double* berr, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DTPRFS( &uplo, &trans, &diag, &n, &nrhs, ap, b, &ldb, x, &ldx,
- ferr, berr, work, iwork, &info );
- }
- inline void tprfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs,
- const traits::complex_f* ap, const traits::complex_f* b,
- const integer_t ldb, const traits::complex_f* x,
- const integer_t ldx, float* ferr, float* berr,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CTPRFS( &uplo, &trans, &diag, &n, &nrhs,
- traits::complex_ptr(ap), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void tprfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs,
- const traits::complex_d* ap, const traits::complex_d* b,
- const integer_t ldb, const traits::complex_d* x,
- const integer_t ldx, double* ferr, double* berr,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZTPRFS( &uplo, &trans, &diag, &n, &nrhs,
- traits::complex_ptr(ap), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void tprfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const float* ap,
+ const float* b, const integer_t ldb, const float* x,
+ const integer_t ldx, float* ferr, float* berr, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_STPRFS( &uplo, &trans, &diag, &n, &nrhs, ap, b, &ldb, x, &ldx,
+ ferr, berr, work, iwork, &info );
 }
 
+inline void tprfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const double* ap,
+ const double* b, const integer_t ldb, const double* x,
+ const integer_t ldx, double* ferr, double* berr, double* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_DTPRFS( &uplo, &trans, &diag, &n, &nrhs, ap, b, &ldb, x, &ldx,
+ ferr, berr, work, iwork, &info );
+}
+
+inline void tprfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const traits::complex_f* ap,
+ const traits::complex_f* b, const integer_t ldb,
+ const traits::complex_f* x, const integer_t ldx, float* ferr,
+ float* berr, traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CTPRFS( &uplo, &trans, &diag, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx, ferr,
+ berr, traits::complex_ptr(work), rwork, &info );
+}
+
+inline void tprfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const traits::complex_d* ap,
+ const traits::complex_d* b, const integer_t ldb,
+ const traits::complex_d* x, const integer_t ldx, double* ferr,
+ double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZTPRFS( &uplo, &trans, &diag, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx, ferr,
+ berr, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tprfs_impl{};
@@ -270,6 +272,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,24 +31,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tptri( const char uplo, const char diag, const integer_t n,
- float* ap, integer_t& info ) {
- LAPACK_STPTRI( &uplo, &diag, &n, ap, &info );
- }
- inline void tptri( const char uplo, const char diag, const integer_t n,
- double* ap, integer_t& info ) {
- LAPACK_DTPTRI( &uplo, &diag, &n, ap, &info );
- }
- inline void tptri( const char uplo, const char diag, const integer_t n,
- traits::complex_f* ap, integer_t& info ) {
- LAPACK_CTPTRI( &uplo, &diag, &n, traits::complex_ptr(ap), &info );
- }
- inline void tptri( const char uplo, const char diag, const integer_t n,
- traits::complex_d* ap, integer_t& info ) {
- LAPACK_ZTPTRI( &uplo, &diag, &n, traits::complex_ptr(ap), &info );
- }
+
+inline void tptri( const char uplo, const char diag, const integer_t n,
+ float* ap, integer_t& info ) {
+ LAPACK_STPTRI( &uplo, &diag, &n, ap, &info );
+}
+
+inline void tptri( const char uplo, const char diag, const integer_t n,
+ double* ap, integer_t& info ) {
+ LAPACK_DTPTRI( &uplo, &diag, &n, ap, &info );
+}
+
+inline void tptri( const char uplo, const char diag, const integer_t n,
+ traits::complex_f* ap, integer_t& info ) {
+ LAPACK_CTPTRI( &uplo, &diag, &n, traits::complex_ptr(ap), &info );
 }
 
+inline void tptri( const char uplo, const char diag, const integer_t n,
+ traits::complex_d* ap, integer_t& info ) {
+ LAPACK_ZTPTRI( &uplo, &diag, &n, traits::complex_ptr(ap), &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct tptri_impl {
@@ -79,6 +84,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,32 +31,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tptrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs, const float* ap,
- float* b, const integer_t ldb, integer_t& info ) {
- LAPACK_STPTRS( &uplo, &trans, &diag, &n, &nrhs, ap, b, &ldb, &info );
- }
- inline void tptrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs, const double* ap,
- double* b, const integer_t ldb, integer_t& info ) {
- LAPACK_DTPTRS( &uplo, &trans, &diag, &n, &nrhs, ap, b, &ldb, &info );
- }
- inline void tptrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs,
- const traits::complex_f* ap, traits::complex_f* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_CTPTRS( &uplo, &trans, &diag, &n, &nrhs,
- traits::complex_ptr(ap), traits::complex_ptr(b), &ldb, &info );
- }
- inline void tptrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs,
- const traits::complex_d* ap, traits::complex_d* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_ZTPTRS( &uplo, &trans, &diag, &n, &nrhs,
- traits::complex_ptr(ap), traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void tptrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const float* ap, float* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_STPTRS( &uplo, &trans, &diag, &n, &nrhs, ap, b, &ldb, &info );
+}
+
+inline void tptrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const double* ap, double* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_DTPTRS( &uplo, &trans, &diag, &n, &nrhs, ap, b, &ldb, &info );
+}
+
+inline void tptrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const traits::complex_f* ap,
+ traits::complex_f* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_CTPTRS( &uplo, &trans, &diag, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void tptrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const traits::complex_d* ap,
+ traits::complex_d* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_ZTPTRS( &uplo, &trans, &diag, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct tptrs_impl {
@@ -95,6 +98,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,34 +36,39 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trcon( const char norm, const char uplo, const char diag,
- const integer_t n, const float* a, const integer_t lda,
- float& rcond, float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_STRCON( &norm, &uplo, &diag, &n, a, &lda, &rcond, work, iwork,
- &info );
- }
- inline void trcon( const char norm, const char uplo, const char diag,
- const integer_t n, const double* a, const integer_t lda,
- double& rcond, double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DTRCON( &norm, &uplo, &diag, &n, a, &lda, &rcond, work, iwork,
- &info );
- }
- inline void trcon( const char norm, const char uplo, const char diag,
- const integer_t n, const traits::complex_f* a,
- const integer_t lda, float& rcond, traits::complex_f* work,
- float* rwork, integer_t& info ) {
- LAPACK_CTRCON( &norm, &uplo, &diag, &n, traits::complex_ptr(a), &lda,
- &rcond, traits::complex_ptr(work), rwork, &info );
- }
- inline void trcon( const char norm, const char uplo, const char diag,
- const integer_t n, const traits::complex_d* a,
- const integer_t lda, double& rcond, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZTRCON( &norm, &uplo, &diag, &n, traits::complex_ptr(a), &lda,
- &rcond, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void trcon( const char norm, const char uplo, const char diag,
+ const integer_t n, const float* a, const integer_t lda, float& rcond,
+ float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_STRCON( &norm, &uplo, &diag, &n, a, &lda, &rcond, work, iwork,
+ &info );
 }
 
+inline void trcon( const char norm, const char uplo, const char diag,
+ const integer_t n, const double* a, const integer_t lda,
+ double& rcond, double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DTRCON( &norm, &uplo, &diag, &n, a, &lda, &rcond, work, iwork,
+ &info );
+}
+
+inline void trcon( const char norm, const char uplo, const char diag,
+ const integer_t n, const traits::complex_f* a, const integer_t lda,
+ float& rcond, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CTRCON( &norm, &uplo, &diag, &n, traits::complex_ptr(a), &lda,
+ &rcond, traits::complex_ptr(work), rwork, &info );
+}
+
+inline void trcon( const char norm, const char uplo, const char diag,
+ const integer_t n, const traits::complex_d* a, const integer_t lda,
+ double& rcond, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZTRCON( &norm, &uplo, &diag, &n, traits::complex_ptr(a), &lda,
+ &rcond, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct trcon_impl{};
@@ -211,6 +216,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,43 +36,47 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trevc( const char side, const char howmny, logical_t* select,
- const integer_t n, const float* t, const integer_t ldt, float* vl,
- const integer_t ldvl, float* vr, const integer_t ldvr,
- const integer_t mm, integer_t& m, float* work, integer_t& info ) {
- LAPACK_STREVC( &side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr,
- &ldvr, &mm, &m, work, &info );
- }
- inline void trevc( const char side, const char howmny, logical_t* select,
- const integer_t n, const double* t, const integer_t ldt,
- double* vl, const integer_t ldvl, double* vr,
- const integer_t ldvr, const integer_t mm, integer_t& m,
- double* work, integer_t& info ) {
- LAPACK_DTREVC( &side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr,
- &ldvr, &mm, &m, work, &info );
- }
- inline void trevc( const char side, const char howmny,
- const logical_t* select, const integer_t n, traits::complex_f* t,
- const integer_t ldt, traits::complex_f* vl, const integer_t ldvl,
- traits::complex_f* vr, const integer_t ldvr, const integer_t mm,
- integer_t& m, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CTREVC( &side, &howmny, select, &n, traits::complex_ptr(t),
- &ldt, traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, &mm, &m, traits::complex_ptr(work), rwork, &info );
- }
- inline void trevc( const char side, const char howmny,
- const logical_t* select, const integer_t n, traits::complex_d* t,
- const integer_t ldt, traits::complex_d* vl, const integer_t ldvl,
- traits::complex_d* vr, const integer_t ldvr, const integer_t mm,
- integer_t& m, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZTREVC( &side, &howmny, select, &n, traits::complex_ptr(t),
- &ldt, traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, &mm, &m, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void trevc( const char side, const char howmny, logical_t* select,
+ const integer_t n, const float* t, const integer_t ldt, float* vl,
+ const integer_t ldvl, float* vr, const integer_t ldvr,
+ const integer_t mm, integer_t& m, float* work, integer_t& info ) {
+ LAPACK_STREVC( &side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr,
+ &mm, &m, work, &info );
 }
 
+inline void trevc( const char side, const char howmny, logical_t* select,
+ const integer_t n, const double* t, const integer_t ldt, double* vl,
+ const integer_t ldvl, double* vr, const integer_t ldvr,
+ const integer_t mm, integer_t& m, double* work, integer_t& info ) {
+ LAPACK_DTREVC( &side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr,
+ &mm, &m, work, &info );
+}
+
+inline void trevc( const char side, const char howmny,
+ const logical_t* select, const integer_t n, traits::complex_f* t,
+ const integer_t ldt, traits::complex_f* vl, const integer_t ldvl,
+ traits::complex_f* vr, const integer_t ldvr, const integer_t mm,
+ integer_t& m, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CTREVC( &side, &howmny, select, &n, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr,
+ &mm, &m, traits::complex_ptr(work), rwork, &info );
+}
+
+inline void trevc( const char side, const char howmny,
+ const logical_t* select, const integer_t n, traits::complex_d* t,
+ const integer_t ldt, traits::complex_d* vl, const integer_t ldvl,
+ traits::complex_d* vr, const integer_t ldvr, const integer_t mm,
+ integer_t& m, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZTREVC( &side, &howmny, select, &n, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr,
+ &mm, &m, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct trevc_impl{};
@@ -268,6 +272,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,34 +36,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trexc( const char compq, const integer_t n, float* t,
- const integer_t ldt, float* q, const integer_t ldq,
- integer_t& ifst, integer_t& ilst, float* work, integer_t& info ) {
- LAPACK_STREXC( &compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work,
- &info );
- }
- inline void trexc( const char compq, const integer_t n, double* t,
- const integer_t ldt, double* q, const integer_t ldq,
- integer_t& ifst, integer_t& ilst, double* work, integer_t& info ) {
- LAPACK_DTREXC( &compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work,
- &info );
- }
- inline void trexc( const char compq, const integer_t n,
- traits::complex_f* t, const integer_t ldt, traits::complex_f* q,
- const integer_t ldq, const integer_t ifst, const integer_t ilst,
- integer_t& info ) {
- LAPACK_CTREXC( &compq, &n, traits::complex_ptr(t), &ldt,
- traits::complex_ptr(q), &ldq, &ifst, &ilst, &info );
- }
- inline void trexc( const char compq, const integer_t n,
- traits::complex_d* t, const integer_t ldt, traits::complex_d* q,
- const integer_t ldq, const integer_t ifst, const integer_t ilst,
- integer_t& info ) {
- LAPACK_ZTREXC( &compq, &n, traits::complex_ptr(t), &ldt,
- traits::complex_ptr(q), &ldq, &ifst, &ilst, &info );
- }
+
+inline void trexc( const char compq, const integer_t n, float* t,
+ const integer_t ldt, float* q, const integer_t ldq, integer_t& ifst,
+ integer_t& ilst, float* work, integer_t& info ) {
+ LAPACK_STREXC( &compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info );
+}
+
+inline void trexc( const char compq, const integer_t n, double* t,
+ const integer_t ldt, double* q, const integer_t ldq, integer_t& ifst,
+ integer_t& ilst, double* work, integer_t& info ) {
+ LAPACK_DTREXC( &compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info );
+}
+
+inline void trexc( const char compq, const integer_t n, traits::complex_f* t,
+ const integer_t ldt, traits::complex_f* q, const integer_t ldq,
+ const integer_t ifst, const integer_t ilst, integer_t& info ) {
+ LAPACK_CTREXC( &compq, &n, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(q), &ldq, &ifst, &ilst, &info );
 }
 
+inline void trexc( const char compq, const integer_t n, traits::complex_d* t,
+ const integer_t ldt, traits::complex_d* q, const integer_t ldq,
+ const integer_t ifst, const integer_t ilst, integer_t& info ) {
+ LAPACK_ZTREXC( &compq, &n, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(q), &ldq, &ifst, &ilst, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct trexc_impl{};
@@ -176,6 +177,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,48 +36,48 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trrfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs, const float* a,
- const integer_t lda, const float* b, const integer_t ldb,
- const float* x, const integer_t ldx, float* ferr, float* berr,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_STRRFS( &uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb, x,
- &ldx, ferr, berr, work, iwork, &info );
- }
- inline void trrfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs, const double* a,
- const integer_t lda, const double* b, const integer_t ldb,
- const double* x, const integer_t ldx, double* ferr, double* berr,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DTRRFS( &uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb, x,
- &ldx, ferr, berr, work, iwork, &info );
- }
- inline void trrfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs,
- const traits::complex_f* a, const integer_t lda,
- const traits::complex_f* b, const integer_t ldb,
- const traits::complex_f* x, const integer_t ldx, float* ferr,
- float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CTRRFS( &uplo, &trans, &diag, &n, &nrhs,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void trrfs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs,
- const traits::complex_d* a, const integer_t lda,
- const traits::complex_d* b, const integer_t ldb,
- const traits::complex_d* x, const integer_t ldx, double* ferr,
- double* berr, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZTRRFS( &uplo, &trans, &diag, &n, &nrhs,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void trrfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const float* a,
+ const integer_t lda, const float* b, const integer_t ldb,
+ const float* x, const integer_t ldx, float* ferr, float* berr,
+ float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_STRRFS( &uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb, x, &ldx,
+ ferr, berr, work, iwork, &info );
 }
 
+inline void trrfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const double* a,
+ const integer_t lda, const double* b, const integer_t ldb,
+ const double* x, const integer_t ldx, double* ferr, double* berr,
+ double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DTRRFS( &uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb, x, &ldx,
+ ferr, berr, work, iwork, &info );
+}
+
+inline void trrfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const traits::complex_f* a,
+ const integer_t lda, const traits::complex_f* b, const integer_t ldb,
+ const traits::complex_f* x, const integer_t ldx, float* ferr,
+ float* berr, traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CTRRFS( &uplo, &trans, &diag, &n, &nrhs, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ ferr, berr, traits::complex_ptr(work), rwork, &info );
+}
+
+inline void trrfs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const traits::complex_d* a,
+ const integer_t lda, const traits::complex_d* b, const integer_t ldb,
+ const traits::complex_d* x, const integer_t ldx, double* ferr,
+ double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZTRRFS( &uplo, &trans, &diag, &n, &nrhs, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ ferr, berr, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct trrfs_impl{};
@@ -284,6 +284,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trsen( const char job, const char compq,
- const logical_t* select, const integer_t n, traits::complex_f* t,
- const integer_t ldt, traits::complex_f* q, const integer_t ldq,
- traits::complex_f* w, integer_t& m, float& s, float& sep,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CTRSEN( &job, &compq, select, &n, traits::complex_ptr(t), &ldt,
- traits::complex_ptr(q), &ldq, traits::complex_ptr(w), &m, &s,
- &sep, traits::complex_ptr(work), &lwork, &info );
- }
- inline void trsen( const char job, const char compq,
- const logical_t* select, const integer_t n, traits::complex_d* t,
- const integer_t ldt, traits::complex_d* q, const integer_t ldq,
- traits::complex_d* w, integer_t& m, double& s, double& sep,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZTRSEN( &job, &compq, select, &n, traits::complex_ptr(t), &ldt,
- traits::complex_ptr(q), &ldq, traits::complex_ptr(w), &m, &s,
- &sep, traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void trsen( const char job, const char compq, const logical_t* select,
+ const integer_t n, traits::complex_f* t, const integer_t ldt,
+ traits::complex_f* q, const integer_t ldq, traits::complex_f* w,
+ integer_t& m, float& s, float& sep, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CTRSEN( &job, &compq, select, &n, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(q), &ldq, traits::complex_ptr(w), &m, &s,
+ &sep, traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void trsen( const char job, const char compq, const logical_t* select,
+ const integer_t n, traits::complex_d* t, const integer_t ldt,
+ traits::complex_d* q, const integer_t ldq, traits::complex_d* w,
+ integer_t& m, double& s, double& sep, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZTRSEN( &job, &compq, select, &n, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(q), &ldq, traits::complex_ptr(w), &m, &s,
+ &sep, traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct trsen_impl {
@@ -167,6 +170,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,52 +36,52 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trsna( const char job, const char howmny,
- const logical_t* select, const integer_t n, const float* t,
- const integer_t ldt, const float* vl, const integer_t ldvl,
- const float* vr, const integer_t ldvr, float* s, float* sep,
- const integer_t mm, integer_t& m, float* work,
- const integer_t ldwork, integer_t* iwork, integer_t& info ) {
- LAPACK_STRSNA( &job, &howmny, select, &n, t, &ldt, vl, &ldvl, vr,
- &ldvr, s, sep, &mm, &m, work, &ldwork, iwork, &info );
- }
- inline void trsna( const char job, const char howmny,
- const logical_t* select, const integer_t n, const double* t,
- const integer_t ldt, const double* vl, const integer_t ldvl,
- const double* vr, const integer_t ldvr, double* s, double* sep,
- const integer_t mm, integer_t& m, double* work,
- const integer_t ldwork, integer_t* iwork, integer_t& info ) {
- LAPACK_DTRSNA( &job, &howmny, select, &n, t, &ldt, vl, &ldvl, vr,
- &ldvr, s, sep, &mm, &m, work, &ldwork, iwork, &info );
- }
- inline void trsna( const char job, const char howmny,
- const logical_t* select, const integer_t n,
- const traits::complex_f* t, const integer_t ldt,
- const traits::complex_f* vl, const integer_t ldvl,
- const traits::complex_f* vr, const integer_t ldvr, float* s,
- float* sep, const integer_t mm, integer_t& m,
- traits::complex_f* work, const integer_t ldwork, float* rwork,
- integer_t& info ) {
- LAPACK_CTRSNA( &job, &howmny, select, &n, traits::complex_ptr(t),
- &ldt, traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, s, sep, &mm, &m, traits::complex_ptr(work), &ldwork,
- rwork, &info );
- }
- inline void trsna( const char job, const char howmny,
- const logical_t* select, const integer_t n,
- const traits::complex_d* t, const integer_t ldt,
- const traits::complex_d* vl, const integer_t ldvl,
- const traits::complex_d* vr, const integer_t ldvr, double* s,
- double* sep, const integer_t mm, integer_t& m,
- traits::complex_d* work, const integer_t ldwork, double* rwork,
- integer_t& info ) {
- LAPACK_ZTRSNA( &job, &howmny, select, &n, traits::complex_ptr(t),
- &ldt, traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, s, sep, &mm, &m, traits::complex_ptr(work), &ldwork,
- rwork, &info );
- }
+
+inline void trsna( const char job, const char howmny, const logical_t* select,
+ const integer_t n, const float* t, const integer_t ldt,
+ const float* vl, const integer_t ldvl, const float* vr,
+ const integer_t ldvr, float* s, float* sep, const integer_t mm,
+ integer_t& m, float* work, const integer_t ldwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_STRSNA( &job, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr,
+ s, sep, &mm, &m, work, &ldwork, iwork, &info );
 }
 
+inline void trsna( const char job, const char howmny, const logical_t* select,
+ const integer_t n, const double* t, const integer_t ldt,
+ const double* vl, const integer_t ldvl, const double* vr,
+ const integer_t ldvr, double* s, double* sep, const integer_t mm,
+ integer_t& m, double* work, const integer_t ldwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DTRSNA( &job, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr,
+ s, sep, &mm, &m, work, &ldwork, iwork, &info );
+}
+
+inline void trsna( const char job, const char howmny, const logical_t* select,
+ const integer_t n, const traits::complex_f* t, const integer_t ldt,
+ const traits::complex_f* vl, const integer_t ldvl,
+ const traits::complex_f* vr, const integer_t ldvr, float* s,
+ float* sep, const integer_t mm, integer_t& m, traits::complex_f* work,
+ const integer_t ldwork, float* rwork, integer_t& info ) {
+ LAPACK_CTRSNA( &job, &howmny, select, &n, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr, s,
+ sep, &mm, &m, traits::complex_ptr(work), &ldwork, rwork, &info );
+}
+
+inline void trsna( const char job, const char howmny, const logical_t* select,
+ const integer_t n, const traits::complex_d* t, const integer_t ldt,
+ const traits::complex_d* vl, const integer_t ldvl,
+ const traits::complex_d* vr, const integer_t ldvr, double* s,
+ double* sep, const integer_t mm, integer_t& m,
+ traits::complex_d* work, const integer_t ldwork, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZTRSNA( &job, &howmny, select, &n, traits::complex_ptr(t), &ldt,
+ traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr, s,
+ sep, &mm, &m, traits::complex_ptr(work), &ldwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct trsna_impl{};
@@ -283,6 +283,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,44 +34,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trsyl( const char trana, const char tranb,
- const integer_t isgn, const integer_t m, const integer_t n,
- const float* a, const integer_t lda, const float* b,
- const integer_t ldb, float* c, const integer_t ldc, float& scale,
- integer_t& info ) {
- LAPACK_STRSYL( &trana, &tranb, &isgn, &m, &n, a, &lda, b, &ldb, c,
- &ldc, &scale, &info );
- }
- inline void trsyl( const char trana, const char tranb,
- const integer_t isgn, const integer_t m, const integer_t n,
- const double* a, const integer_t lda, const double* b,
- const integer_t ldb, double* c, const integer_t ldc,
- double& scale, integer_t& info ) {
- LAPACK_DTRSYL( &trana, &tranb, &isgn, &m, &n, a, &lda, b, &ldb, c,
- &ldc, &scale, &info );
- }
- inline void trsyl( const char trana, const char tranb,
- const integer_t isgn, const integer_t m, const integer_t n,
- const traits::complex_f* a, const integer_t lda,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* c, const integer_t ldc, float& scale,
- integer_t& info ) {
- LAPACK_CTRSYL( &trana, &tranb, &isgn, &m, &n, traits::complex_ptr(a),
- &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(c),
- &ldc, &scale, &info );
- }
- inline void trsyl( const char trana, const char tranb,
- const integer_t isgn, const integer_t m, const integer_t n,
- const traits::complex_d* a, const integer_t lda,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* c, const integer_t ldc, double& scale,
- integer_t& info ) {
- LAPACK_ZTRSYL( &trana, &tranb, &isgn, &m, &n, traits::complex_ptr(a),
- &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(c),
- &ldc, &scale, &info );
- }
+
+inline void trsyl( const char trana, const char tranb, const integer_t isgn,
+ const integer_t m, const integer_t n, const float* a,
+ const integer_t lda, const float* b, const integer_t ldb, float* c,
+ const integer_t ldc, float& scale, integer_t& info ) {
+ LAPACK_STRSYL( &trana, &tranb, &isgn, &m, &n, a, &lda, b, &ldb, c, &ldc,
+ &scale, &info );
 }
 
+inline void trsyl( const char trana, const char tranb, const integer_t isgn,
+ const integer_t m, const integer_t n, const double* a,
+ const integer_t lda, const double* b, const integer_t ldb, double* c,
+ const integer_t ldc, double& scale, integer_t& info ) {
+ LAPACK_DTRSYL( &trana, &tranb, &isgn, &m, &n, a, &lda, b, &ldb, c, &ldc,
+ &scale, &info );
+}
+
+inline void trsyl( const char trana, const char tranb, const integer_t isgn,
+ const integer_t m, const integer_t n, const traits::complex_f* a,
+ const integer_t lda, const traits::complex_f* b, const integer_t ldb,
+ traits::complex_f* c, const integer_t ldc, float& scale,
+ integer_t& info ) {
+ LAPACK_CTRSYL( &trana, &tranb, &isgn, &m, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(c), &ldc,
+ &scale, &info );
+}
+
+inline void trsyl( const char trana, const char tranb, const integer_t isgn,
+ const integer_t m, const integer_t n, const traits::complex_d* a,
+ const integer_t lda, const traits::complex_d* b, const integer_t ldb,
+ traits::complex_d* c, const integer_t ldc, double& scale,
+ integer_t& info ) {
+ LAPACK_ZTRSYL( &trana, &tranb, &isgn, &m, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, traits::complex_ptr(c), &ldc,
+ &scale, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct trsyl_impl{};
@@ -157,6 +158,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,24 +31,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trtri( const char uplo, const char diag, const integer_t n,
- float* a, const integer_t lda, integer_t& info ) {
- LAPACK_STRTRI( &uplo, &diag, &n, a, &lda, &info );
- }
- inline void trtri( const char uplo, const char diag, const integer_t n,
- double* a, const integer_t lda, integer_t& info ) {
- LAPACK_DTRTRI( &uplo, &diag, &n, a, &lda, &info );
- }
- inline void trtri( const char uplo, const char diag, const integer_t n,
- traits::complex_f* a, const integer_t lda, integer_t& info ) {
- LAPACK_CTRTRI( &uplo, &diag, &n, traits::complex_ptr(a), &lda, &info );
- }
- inline void trtri( const char uplo, const char diag, const integer_t n,
- traits::complex_d* a, const integer_t lda, integer_t& info ) {
- LAPACK_ZTRTRI( &uplo, &diag, &n, traits::complex_ptr(a), &lda, &info );
- }
+
+inline void trtri( const char uplo, const char diag, const integer_t n,
+ float* a, const integer_t lda, integer_t& info ) {
+ LAPACK_STRTRI( &uplo, &diag, &n, a, &lda, &info );
+}
+
+inline void trtri( const char uplo, const char diag, const integer_t n,
+ double* a, const integer_t lda, integer_t& info ) {
+ LAPACK_DTRTRI( &uplo, &diag, &n, a, &lda, &info );
+}
+
+inline void trtri( const char uplo, const char diag, const integer_t n,
+ traits::complex_f* a, const integer_t lda, integer_t& info ) {
+ LAPACK_CTRTRI( &uplo, &diag, &n, traits::complex_ptr(a), &lda, &info );
 }
 
+inline void trtri( const char uplo, const char diag, const integer_t n,
+ traits::complex_d* a, const integer_t lda, integer_t& info ) {
+ LAPACK_ZTRTRI( &uplo, &diag, &n, traits::complex_ptr(a), &lda, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct trtri_impl {
@@ -81,6 +86,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,38 +31,38 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void trtrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs, const float* a,
- const integer_t lda, float* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_STRTRS( &uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb,
- &info );
- }
- inline void trtrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs, const double* a,
- const integer_t lda, double* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_DTRTRS( &uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb,
- &info );
- }
- inline void trtrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs,
- const traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CTRTRS( &uplo, &trans, &diag, &n, &nrhs,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &info );
- }
- inline void trtrs( const char uplo, const char trans, const char diag,
- const integer_t n, const integer_t nrhs,
- const traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZTRTRS( &uplo, &trans, &diag, &n, &nrhs,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &info );
- }
+
+inline void trtrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const float* a,
+ const integer_t lda, float* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_STRTRS( &uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb, &info );
+}
+
+inline void trtrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const double* a,
+ const integer_t lda, double* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_DTRTRS( &uplo, &trans, &diag, &n, &nrhs, a, &lda, b, &ldb, &info );
+}
+
+inline void trtrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const traits::complex_f* a,
+ const integer_t lda, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CTRTRS( &uplo, &trans, &diag, &n, &nrhs, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void trtrs( const char uplo, const char trans, const char diag,
+ const integer_t n, const integer_t nrhs, const traits::complex_d* a,
+ const integer_t lda, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZTRTRS( &uplo, &trans, &diag, &n, &nrhs, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct trtrs_impl {
@@ -104,6 +104,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,32 +37,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void tzrzf( const integer_t m, const integer_t n, float* a,
- const integer_t lda, float* tau, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_STZRZF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void tzrzf( const integer_t m, const integer_t n, double* a,
- const integer_t lda, double* tau, double* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_DTZRZF( &m, &n, a, &lda, tau, work, &lwork, &info );
- }
- inline void tzrzf( const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* tau,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CTZRZF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void tzrzf( const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* tau,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZTZRZF( &m, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void tzrzf( const integer_t m, const integer_t n, float* a,
+ const integer_t lda, float* tau, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_STZRZF( &m, &n, a, &lda, tau, work, &lwork, &info );
 }
 
+inline void tzrzf( const integer_t m, const integer_t n, double* a,
+ const integer_t lda, double* tau, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DTZRZF( &m, &n, a, &lda, tau, work, &lwork, &info );
+}
+
+inline void tzrzf( const integer_t m, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CTZRZF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void tzrzf( const integer_t m, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZTZRZF( &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct tzrzf_impl{};
@@ -200,6 +205,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ungbr( const char vect, const integer_t m, const integer_t n,
- const integer_t k, traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNGBR( &vect, &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void ungbr( const char vect, const integer_t m, const integer_t n,
- const integer_t k, traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNGBR( &vect, &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void ungbr( const char vect, const integer_t m, const integer_t n,
+ const integer_t k, traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNGBR( &vect, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void ungbr( const char vect, const integer_t m, const integer_t n,
+ const integer_t k, traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNGBR( &vect, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ungbr_impl {
@@ -131,6 +134,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unghr( const integer_t n, const integer_t ilo,
- const integer_t ihi, traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNGHR( &n, &ilo, &ihi, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void unghr( const integer_t n, const integer_t ilo,
- const integer_t ihi, traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNGHR( &n, &ilo, &ihi, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void unghr( const integer_t n, const integer_t ilo,
+ const integer_t ihi, traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNGHR( &n, &ilo, &ihi, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void unghr( const integer_t n, const integer_t ilo,
+ const integer_t ihi, traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNGHR( &n, &ilo, &ihi, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unghr_impl {
@@ -130,6 +133,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unglq( const integer_t m, const integer_t n,
- const integer_t k, traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNGLQ( &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void unglq( const integer_t m, const integer_t n,
- const integer_t k, traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNGLQ( &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void unglq( const integer_t m, const integer_t n, const integer_t k,
+ traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNGLQ( &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void unglq( const integer_t m, const integer_t n, const integer_t k,
+ traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNGLQ( &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unglq_impl {
@@ -130,6 +133,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ungql( const integer_t m, const integer_t n,
- const integer_t k, traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNGQL( &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void ungql( const integer_t m, const integer_t n,
- const integer_t k, traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNGQL( &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void ungql( const integer_t m, const integer_t n, const integer_t k,
+ traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNGQL( &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void ungql( const integer_t m, const integer_t n, const integer_t k,
+ traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNGQL( &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ungql_impl {
@@ -130,6 +133,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ungqr( const integer_t m, const integer_t n,
- const integer_t k, traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNGQR( &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void ungqr( const integer_t m, const integer_t n,
- const integer_t k, traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNGQR( &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void ungqr( const integer_t m, const integer_t n, const integer_t k,
+ traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNGQR( &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void ungqr( const integer_t m, const integer_t n, const integer_t k,
+ traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNGQR( &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ungqr_impl {
@@ -130,6 +133,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ungrq( const integer_t m, const integer_t n,
- const integer_t k, traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNGRQ( &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void ungrq( const integer_t m, const integer_t n,
- const integer_t k, traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNGRQ( &m, &n, &k, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void ungrq( const integer_t m, const integer_t n, const integer_t k,
+ traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNGRQ( &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void ungrq( const integer_t m, const integer_t n, const integer_t k,
+ traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNGRQ( &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ungrq_impl {
@@ -130,6 +133,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ungtr( const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNGTR( &uplo, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
- inline void ungtr( const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNGTR( &uplo, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
- &info );
- }
+
+inline void ungtr( const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, const traits::complex_f* tau,
+ traits::complex_f* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNGTR( &uplo, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void ungtr( const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, const traits::complex_d* tau,
+ traits::complex_d* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNGTR( &uplo, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ungtr_impl {
@@ -133,6 +134,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,30 +34,31 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unmbr( const char vect, const char side, const char trans,
- const integer_t m, const integer_t n, const integer_t k,
- const traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* c,
- const integer_t ldc, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNMBR( &vect, &side, &trans, &m, &n, &k,
- traits::complex_ptr(a), &lda, traits::complex_ptr(tau),
- traits::complex_ptr(c), &ldc, traits::complex_ptr(work),
- &lwork, &info );
- }
- inline void unmbr( const char vect, const char side, const char trans,
- const integer_t m, const integer_t n, const integer_t k,
- const traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* c,
- const integer_t ldc, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNMBR( &vect, &side, &trans, &m, &n, &k,
- traits::complex_ptr(a), &lda, traits::complex_ptr(tau),
- traits::complex_ptr(c), &ldc, traits::complex_ptr(work),
- &lwork, &info );
- }
+
+inline void unmbr( const char vect, const char side, const char trans,
+ const integer_t m, const integer_t n, const integer_t k,
+ const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* c,
+ const integer_t ldc, traits::complex_f* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_CUNMBR( &vect, &side, &trans, &m, &n, &k, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void unmbr( const char vect, const char side, const char trans,
+ const integer_t m, const integer_t n, const integer_t k,
+ const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* c,
+ const integer_t ldc, traits::complex_d* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_ZUNMBR( &vect, &side, &trans, &m, &n, &k, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unmbr_impl {
@@ -158,6 +159,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,30 +34,31 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unmhr( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t ilo, const integer_t ihi,
- const traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* c,
- const integer_t ldc, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNMHR( &side, &trans, &m, &n, &ilo, &ihi,
- traits::complex_ptr(a), &lda, traits::complex_ptr(tau),
- traits::complex_ptr(c), &ldc, traits::complex_ptr(work),
- &lwork, &info );
- }
- inline void unmhr( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t ilo, const integer_t ihi,
- const traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* c,
- const integer_t ldc, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNMHR( &side, &trans, &m, &n, &ilo, &ihi,
- traits::complex_ptr(a), &lda, traits::complex_ptr(tau),
- traits::complex_ptr(c), &ldc, traits::complex_ptr(work),
- &lwork, &info );
- }
+
+inline void unmhr( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t ilo, const integer_t ihi,
+ const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* c,
+ const integer_t ldc, traits::complex_f* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_CUNMHR( &side, &trans, &m, &n, &ilo, &ihi, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void unmhr( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t ilo, const integer_t ihi,
+ const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* c,
+ const integer_t ldc, traits::complex_d* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_ZUNMHR( &side, &trans, &m, &n, &ilo, &ihi, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unmhr_impl {
@@ -161,6 +162,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unmlq( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* tau,
- traits::complex_f* c, const integer_t ldc,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CUNMLQ( &side, &trans, &m, &n, &k, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void unmlq( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* tau,
- traits::complex_d* c, const integer_t ldc,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNMLQ( &side, &trans, &m, &n, &k, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void unmlq( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const traits::complex_f* a,
+ const integer_t lda, const traits::complex_f* tau,
+ traits::complex_f* c, const integer_t ldc, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNMLQ( &side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void unmlq( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const traits::complex_d* a,
+ const integer_t lda, const traits::complex_d* tau,
+ traits::complex_d* c, const integer_t ldc, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNMLQ( &side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unmlq_impl {
@@ -153,6 +156,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unmql( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* tau,
- traits::complex_f* c, const integer_t ldc,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CUNMQL( &side, &trans, &m, &n, &k, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void unmql( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* tau,
- traits::complex_d* c, const integer_t ldc,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNMQL( &side, &trans, &m, &n, &k, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void unmql( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const traits::complex_f* a,
+ const integer_t lda, const traits::complex_f* tau,
+ traits::complex_f* c, const integer_t ldc, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNMQL( &side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void unmql( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const traits::complex_d* a,
+ const integer_t lda, const traits::complex_d* tau,
+ traits::complex_d* c, const integer_t ldc, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNMQL( &side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unmql_impl {
@@ -152,6 +155,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unmqr( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* tau,
- traits::complex_f* c, const integer_t ldc,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CUNMQR( &side, &trans, &m, &n, &k, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void unmqr( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* tau,
- traits::complex_d* c, const integer_t ldc,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNMQR( &side, &trans, &m, &n, &k, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void unmqr( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const traits::complex_f* a,
+ const integer_t lda, const traits::complex_f* tau,
+ traits::complex_f* c, const integer_t ldc, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNMQR( &side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void unmqr( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const traits::complex_d* a,
+ const integer_t lda, const traits::complex_d* tau,
+ traits::complex_d* c, const integer_t ldc, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNMQR( &side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unmqr_impl {
@@ -152,6 +155,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unmrq( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* tau,
- traits::complex_f* c, const integer_t ldc,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CUNMRQ( &side, &trans, &m, &n, &k, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void unmrq( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* tau,
- traits::complex_d* c, const integer_t ldc,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNMRQ( &side, &trans, &m, &n, &k, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void unmrq( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const traits::complex_f* a,
+ const integer_t lda, const traits::complex_f* tau,
+ traits::complex_f* c, const integer_t ldc, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNMRQ( &side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void unmrq( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const traits::complex_d* a,
+ const integer_t lda, const traits::complex_d* tau,
+ traits::complex_d* c, const integer_t ldc, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNMRQ( &side, &trans, &m, &n, &k, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unmrq_impl {
@@ -153,6 +156,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,28 +34,31 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unmrz( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const integer_t l,
- const traits::complex_f* a, const integer_t lda,
- const traits::complex_f* tau, traits::complex_f* c,
- const integer_t ldc, traits::complex_f* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_CUNMRZ( &side, &trans, &m, &n, &k, &l, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void unmrz( const char side, const char trans, const integer_t m,
- const integer_t n, const integer_t k, const integer_t l,
- const traits::complex_d* a, const integer_t lda,
- const traits::complex_d* tau, traits::complex_d* c,
- const integer_t ldc, traits::complex_d* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNMRZ( &side, &trans, &m, &n, &k, &l, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void unmrz( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const integer_t l,
+ const traits::complex_f* a, const integer_t lda,
+ const traits::complex_f* tau, traits::complex_f* c,
+ const integer_t ldc, traits::complex_f* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_CUNMRZ( &side, &trans, &m, &n, &k, &l, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void unmrz( const char side, const char trans, const integer_t m,
+ const integer_t n, const integer_t k, const integer_t l,
+ const traits::complex_d* a, const integer_t lda,
+ const traits::complex_d* tau, traits::complex_d* c,
+ const integer_t ldc, traits::complex_d* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_ZUNMRZ( &side, &trans, &m, &n, &k, &l, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unmrz_impl {
@@ -152,6 +155,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void unmtr( const char side, const char uplo, const char trans,
- const integer_t m, const integer_t n, const traits::complex_f* a,
- const integer_t lda, const traits::complex_f* tau,
- traits::complex_f* c, const integer_t ldc,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CUNMTR( &side, &uplo, &trans, &m, &n, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void unmtr( const char side, const char uplo, const char trans,
- const integer_t m, const integer_t n, const traits::complex_d* a,
- const integer_t lda, const traits::complex_d* tau,
- traits::complex_d* c, const integer_t ldc,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZUNMTR( &side, &uplo, &trans, &m, &n, traits::complex_ptr(a),
- &lda, traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void unmtr( const char side, const char uplo, const char trans,
+ const integer_t m, const integer_t n, const traits::complex_f* a,
+ const integer_t lda, const traits::complex_f* tau,
+ traits::complex_f* c, const integer_t ldc, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CUNMTR( &side, &uplo, &trans, &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
 }
 
+inline void unmtr( const char side, const char uplo, const char trans,
+ const integer_t m, const integer_t n, const traits::complex_d* a,
+ const integer_t lda, const traits::complex_d* tau,
+ traits::complex_d* c, const integer_t ldc, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZUNMTR( &side, &uplo, &trans, &m, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct unmtr_impl {
@@ -152,6 +155,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,24 +33,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void upgtr( const char uplo, const integer_t n,
- const traits::complex_f* ap, const traits::complex_f* tau,
- traits::complex_f* q, const integer_t ldq,
- traits::complex_f* work, integer_t& info ) {
- LAPACK_CUPGTR( &uplo, &n, traits::complex_ptr(ap),
- traits::complex_ptr(tau), traits::complex_ptr(q), &ldq,
- traits::complex_ptr(work), &info );
- }
- inline void upgtr( const char uplo, const integer_t n,
- const traits::complex_d* ap, const traits::complex_d* tau,
- traits::complex_d* q, const integer_t ldq,
- traits::complex_d* work, integer_t& info ) {
- LAPACK_ZUPGTR( &uplo, &n, traits::complex_ptr(ap),
- traits::complex_ptr(tau), traits::complex_ptr(q), &ldq,
- traits::complex_ptr(work), &info );
- }
+
+inline void upgtr( const char uplo, const integer_t n,
+ const traits::complex_f* ap, const traits::complex_f* tau,
+ traits::complex_f* q, const integer_t ldq, traits::complex_f* work,
+ integer_t& info ) {
+ LAPACK_CUPGTR( &uplo, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(tau), traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(work), &info );
 }
 
+inline void upgtr( const char uplo, const integer_t n,
+ const traits::complex_d* ap, const traits::complex_d* tau,
+ traits::complex_d* q, const integer_t ldq, traits::complex_d* work,
+ integer_t& info ) {
+ LAPACK_ZUPGTR( &uplo, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(tau), traits::complex_ptr(q), &ldq,
+ traits::complex_ptr(work), &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct upgtr_impl {
@@ -133,6 +136,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,24 +33,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void upmtr( const char side, const char uplo, const char trans,
- const integer_t m, const integer_t n, const traits::complex_f* ap,
- const traits::complex_f* tau, traits::complex_f* c,
- const integer_t ldc, traits::complex_f* work, integer_t& info ) {
- LAPACK_CUPMTR( &side, &uplo, &trans, &m, &n, traits::complex_ptr(ap),
- traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &info );
- }
- inline void upmtr( const char side, const char uplo, const char trans,
- const integer_t m, const integer_t n, const traits::complex_d* ap,
- const traits::complex_d* tau, traits::complex_d* c,
- const integer_t ldc, traits::complex_d* work, integer_t& info ) {
- LAPACK_ZUPMTR( &side, &uplo, &trans, &m, &n, traits::complex_ptr(ap),
- traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
- traits::complex_ptr(work), &info );
- }
+
+inline void upmtr( const char side, const char uplo, const char trans,
+ const integer_t m, const integer_t n, const traits::complex_f* ap,
+ const traits::complex_f* tau, traits::complex_f* c,
+ const integer_t ldc, traits::complex_f* work, integer_t& info ) {
+ LAPACK_CUPMTR( &side, &uplo, &trans, &m, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &info );
 }
 
+inline void upmtr( const char side, const char uplo, const char trans,
+ const integer_t m, const integer_t n, const traits::complex_d* ap,
+ const traits::complex_d* tau, traits::complex_d* c,
+ const integer_t ldc, traits::complex_d* work, integer_t& info ) {
+ LAPACK_ZUPMTR( &side, &uplo, &trans, &m, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(tau), traits::complex_ptr(c), &ldc,
+ traits::complex_ptr(work), &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct upmtr_impl {
@@ -135,6 +138,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,19 +33,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void cgesv( const integer_t n, const integer_t nrhs,
- traits::complex_d* a, const integer_t lda, integer_t* ipiv,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx,
- traits::complex_d* work, traits::complex_f* swork, double* rwork,
- integer_t& iter, integer_t& info ) {
- LAPACK_ZCGESV( &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- traits::complex_ptr(work), traits::complex_ptr(swork), rwork,
- &iter, &info );
- }
+
+inline void cgesv( const integer_t n, const integer_t nrhs,
+ traits::complex_d* a, const integer_t lda, integer_t* ipiv,
+ const traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
+ const integer_t ldx, traits::complex_d* work,
+ traits::complex_f* swork, double* rwork, integer_t& iter,
+ integer_t& info ) {
+ LAPACK_ZCGESV( &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ traits::complex_ptr(work), traits::complex_ptr(swork), rwork,
+ &iter, &info );
 }
 
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct cgesv_impl {
@@ -156,6 +158,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,19 +33,20 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void cposv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_d* a, const integer_t lda,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx,
- traits::complex_d* work, traits::complex_f* swork, double* rwork,
- integer_t& iter, integer_t& info ) {
- LAPACK_ZCPOSV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- traits::complex_ptr(work), traits::complex_ptr(swork), rwork,
- &iter, &info );
- }
+
+inline void cposv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_d* a, const integer_t lda, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ traits::complex_d* work, traits::complex_f* swork, double* rwork,
+ integer_t& iter, integer_t& info ) {
+ LAPACK_ZCPOSV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ traits::complex_ptr(work), traits::complex_ptr(swork), rwork,
+ &iter, &info );
 }
 
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct cposv_impl {
@@ -151,6 +152,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -32,34 +32,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gbsv( const integer_t n, const integer_t kl,
- const integer_t ku, const integer_t nrhs, float* ab,
- const integer_t ldab, integer_t* ipiv, float* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_SGBSV( &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb, &info );
- }
- inline void gbsv( const integer_t n, const integer_t kl,
- const integer_t ku, const integer_t nrhs, double* ab,
- const integer_t ldab, integer_t* ipiv, double* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_DGBSV( &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb, &info );
- }
- inline void gbsv( const integer_t n, const integer_t kl,
- const integer_t ku, const integer_t nrhs, traits::complex_f* ab,
- const integer_t ldab, integer_t* ipiv, traits::complex_f* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_CGBSV( &n, &kl, &ku, &nrhs, traits::complex_ptr(ab), &ldab,
- ipiv, traits::complex_ptr(b), &ldb, &info );
- }
- inline void gbsv( const integer_t n, const integer_t kl,
- const integer_t ku, const integer_t nrhs, traits::complex_d* ab,
- const integer_t ldab, integer_t* ipiv, traits::complex_d* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_ZGBSV( &n, &kl, &ku, &nrhs, traits::complex_ptr(ab), &ldab,
- ipiv, traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void gbsv( const integer_t n, const integer_t kl, const integer_t ku,
+ const integer_t nrhs, float* ab, const integer_t ldab,
+ integer_t* ipiv, float* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_SGBSV( &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb, &info );
+}
+
+inline void gbsv( const integer_t n, const integer_t kl, const integer_t ku,
+ const integer_t nrhs, double* ab, const integer_t ldab,
+ integer_t* ipiv, double* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_DGBSV( &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb, &info );
+}
+
+inline void gbsv( const integer_t n, const integer_t kl, const integer_t ku,
+ const integer_t nrhs, traits::complex_f* ab, const integer_t ldab,
+ integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CGBSV( &n, &kl, &ku, &nrhs, traits::complex_ptr(ab), &ldab, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void gbsv( const integer_t n, const integer_t kl, const integer_t ku,
+ const integer_t nrhs, traits::complex_d* ab, const integer_t ldab,
+ integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZGBSV( &n, &kl, &ku, &nrhs, traits::complex_ptr(ab), &ldab, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct gbsv_impl {
@@ -119,6 +122,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,58 +36,62 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gbsvx( const char fact, const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- float* ab, const integer_t ldab, float* afb,
- const integer_t ldafb, integer_t* ipiv, char& equed, float* r,
- float* c, float* b, const integer_t ldb, float* x,
- const integer_t ldx, float& rcond, float* ferr, float* berr,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SGBSVX( &fact, &trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb,
- &ldafb, ipiv, &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr,
- berr, work, iwork, &info );
- }
- inline void gbsvx( const char fact, const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- double* ab, const integer_t ldab, double* afb,
- const integer_t ldafb, integer_t* ipiv, char& equed, double* r,
- double* c, double* b, const integer_t ldb, double* x,
- const integer_t ldx, double& rcond, double* ferr, double* berr,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DGBSVX( &fact, &trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb,
- &ldafb, ipiv, &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr,
- berr, work, iwork, &info );
- }
- inline void gbsvx( const char fact, const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- traits::complex_f* ab, const integer_t ldab,
- traits::complex_f* afb, const integer_t ldafb, integer_t* ipiv,
- char& equed, float* r, float* c, traits::complex_f* b,
- const integer_t ldb, traits::complex_f* x, const integer_t ldx,
- float& rcond, float* ferr, float* berr, traits::complex_f* work,
- float* rwork, integer_t& info ) {
- LAPACK_CGBSVX( &fact, &trans, &n, &kl, &ku, &nrhs,
- traits::complex_ptr(ab), &ldab, traits::complex_ptr(afb),
- &ldafb, ipiv, &equed, r, c, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void gbsvx( const char fact, const char trans, const integer_t n,
- const integer_t kl, const integer_t ku, const integer_t nrhs,
- traits::complex_d* ab, const integer_t ldab,
- traits::complex_d* afb, const integer_t ldafb, integer_t* ipiv,
- char& equed, double* r, double* c, traits::complex_d* b,
- const integer_t ldb, traits::complex_d* x, const integer_t ldx,
- double& rcond, double* ferr, double* berr,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZGBSVX( &fact, &trans, &n, &kl, &ku, &nrhs,
- traits::complex_ptr(ab), &ldab, traits::complex_ptr(afb),
- &ldafb, ipiv, &equed, r, c, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void gbsvx( const char fact, const char trans, const integer_t n,
+ const integer_t kl, const integer_t ku, const integer_t nrhs,
+ float* ab, const integer_t ldab, float* afb, const integer_t ldafb,
+ integer_t* ipiv, char& equed, float* r, float* c, float* b,
+ const integer_t ldb, float* x, const integer_t ldx, float& rcond,
+ float* ferr, float* berr, float* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_SGBSVX( &fact, &trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb, &ldafb,
+ ipiv, &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr, berr, work,
+ iwork, &info );
+}
+
+inline void gbsvx( const char fact, const char trans, const integer_t n,
+ const integer_t kl, const integer_t ku, const integer_t nrhs,
+ double* ab, const integer_t ldab, double* afb, const integer_t ldafb,
+ integer_t* ipiv, char& equed, double* r, double* c, double* b,
+ const integer_t ldb, double* x, const integer_t ldx, double& rcond,
+ double* ferr, double* berr, double* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DGBSVX( &fact, &trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb, &ldafb,
+ ipiv, &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr, berr, work,
+ iwork, &info );
+}
+
+inline void gbsvx( const char fact, const char trans, const integer_t n,
+ const integer_t kl, const integer_t ku, const integer_t nrhs,
+ traits::complex_f* ab, const integer_t ldab, traits::complex_f* afb,
+ const integer_t ldafb, integer_t* ipiv, char& equed, float* r,
+ float* c, traits::complex_f* b, const integer_t ldb,
+ traits::complex_f* x, const integer_t ldx, float& rcond, float* ferr,
+ float* berr, traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CGBSVX( &fact, &trans, &n, &kl, &ku, &nrhs,
+ traits::complex_ptr(ab), &ldab, traits::complex_ptr(afb), &ldafb,
+ ipiv, &equed, r, c, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void gbsvx( const char fact, const char trans, const integer_t n,
+ const integer_t kl, const integer_t ku, const integer_t nrhs,
+ traits::complex_d* ab, const integer_t ldab, traits::complex_d* afb,
+ const integer_t ldafb, integer_t* ipiv, char& equed, double* r,
+ double* c, traits::complex_d* b, const integer_t ldb,
+ traits::complex_d* x, const integer_t ldx, double& rcond,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZGBSVX( &fact, &trans, &n, &kl, &ku, &nrhs,
+ traits::complex_ptr(ab), &ldab, traits::complex_ptr(afb), &ldafb,
+ ipiv, &equed, r, c, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gbsvx_impl{};
@@ -346,6 +350,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,46 +37,46 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gees( const char jobvs, const char sort, logical_t* select,
- const integer_t n, float* a, const integer_t lda, integer_t& sdim,
- float* wr, float* wi, float* vs, const integer_t ldvs,
- float* work, const integer_t lwork, logical_t* bwork,
- integer_t& info ) {
- LAPACK_SGEES( &jobvs, &sort, &select, &n, a, &lda, &sdim, wr, wi, vs,
- &ldvs, work, &lwork, bwork, &info );
- }
- inline void gees( const char jobvs, const char sort, logical_t* select,
- const integer_t n, double* a, const integer_t lda,
- integer_t& sdim, double* wr, double* wi, double* vs,
- const integer_t ldvs, double* work, const integer_t lwork,
- logical_t* bwork, integer_t& info ) {
- LAPACK_DGEES( &jobvs, &sort, &select, &n, a, &lda, &sdim, wr, wi, vs,
- &ldvs, work, &lwork, bwork, &info );
- }
- inline void gees( const char jobvs, const char sort, logical_t* select,
- const integer_t n, traits::complex_f* a, const integer_t lda,
- integer_t& sdim, traits::complex_f* w, traits::complex_f* vs,
- const integer_t ldvs, traits::complex_f* work,
- const integer_t lwork, float* rwork, logical_t* bwork,
- integer_t& info ) {
- LAPACK_CGEES( &jobvs, &sort, &select, &n, traits::complex_ptr(a),
- &lda, &sdim, traits::complex_ptr(w), traits::complex_ptr(vs),
- &ldvs, traits::complex_ptr(work), &lwork, rwork, bwork,
- &info );
- }
- inline void gees( const char jobvs, const char sort, logical_t* select,
- const integer_t n, traits::complex_d* a, const integer_t lda,
- integer_t& sdim, traits::complex_d* w, traits::complex_d* vs,
- const integer_t ldvs, traits::complex_d* work,
- const integer_t lwork, double* rwork, logical_t* bwork,
- integer_t& info ) {
- LAPACK_ZGEES( &jobvs, &sort, &select, &n, traits::complex_ptr(a),
- &lda, &sdim, traits::complex_ptr(w), traits::complex_ptr(vs),
- &ldvs, traits::complex_ptr(work), &lwork, rwork, bwork,
- &info );
- }
+
+inline void gees( const char jobvs, const char sort, logical_t* select,
+ const integer_t n, float* a, const integer_t lda, integer_t& sdim,
+ float* wr, float* wi, float* vs, const integer_t ldvs, float* work,
+ const integer_t lwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_SGEES( &jobvs, &sort, &select, &n, a, &lda, &sdim, wr, wi, vs,
+ &ldvs, work, &lwork, bwork, &info );
 }
 
+inline void gees( const char jobvs, const char sort, logical_t* select,
+ const integer_t n, double* a, const integer_t lda, integer_t& sdim,
+ double* wr, double* wi, double* vs, const integer_t ldvs,
+ double* work, const integer_t lwork, logical_t* bwork,
+ integer_t& info ) {
+ LAPACK_DGEES( &jobvs, &sort, &select, &n, a, &lda, &sdim, wr, wi, vs,
+ &ldvs, work, &lwork, bwork, &info );
+}
+
+inline void gees( const char jobvs, const char sort, logical_t* select,
+ const integer_t n, traits::complex_f* a, const integer_t lda,
+ integer_t& sdim, traits::complex_f* w, traits::complex_f* vs,
+ const integer_t ldvs, traits::complex_f* work, const integer_t lwork,
+ float* rwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_CGEES( &jobvs, &sort, &select, &n, traits::complex_ptr(a), &lda,
+ &sdim, traits::complex_ptr(w), traits::complex_ptr(vs), &ldvs,
+ traits::complex_ptr(work), &lwork, rwork, bwork, &info );
+}
+
+inline void gees( const char jobvs, const char sort, logical_t* select,
+ const integer_t n, traits::complex_d* a, const integer_t lda,
+ integer_t& sdim, traits::complex_d* w, traits::complex_d* vs,
+ const integer_t ldvs, traits::complex_d* work, const integer_t lwork,
+ double* rwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_ZGEES( &jobvs, &sort, &select, &n, traits::complex_ptr(a), &lda,
+ &sdim, traits::complex_ptr(w), traits::complex_ptr(vs), &ldvs,
+ traits::complex_ptr(work), &lwork, rwork, bwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gees_impl{};
@@ -319,6 +319,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,50 +37,55 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void geesx( const char jobvs, const char sort, logical_t* select,
- const char sense, const integer_t n, float* a,
- const integer_t lda, integer_t& sdim, float* wr, float* wi,
- float* vs, const integer_t ldvs, float& rconde, float& rcondv,
- float* work, const integer_t lwork, integer_t* iwork,
- const integer_t liwork, logical_t* bwork, integer_t& info ) {
- LAPACK_SGEESX( &jobvs, &sort, &select, &sense, &n, a, &lda, &sdim, wr,
- wi, vs, &ldvs, &rconde, &rcondv, work, &lwork, iwork, &liwork,
- bwork, &info );
- }
- inline void geesx( const char jobvs, const char sort, logical_t* select,
- const char sense, const integer_t n, double* a,
- const integer_t lda, integer_t& sdim, double* wr, double* wi,
- double* vs, const integer_t ldvs, double& rconde, double& rcondv,
- double* work, const integer_t lwork, integer_t* iwork,
- const integer_t liwork, logical_t* bwork, integer_t& info ) {
- LAPACK_DGEESX( &jobvs, &sort, &select, &sense, &n, a, &lda, &sdim, wr,
- wi, vs, &ldvs, &rconde, &rcondv, work, &lwork, iwork, &liwork,
- bwork, &info );
- }
- inline void geesx( const char jobvs, const char sort, logical_t* select,
- const char sense, const integer_t n, traits::complex_f* a,
- const integer_t lda, integer_t& sdim, traits::complex_f* w,
- traits::complex_f* vs, const integer_t ldvs, float& rconde,
- float& rcondv, traits::complex_f* work, const integer_t lwork,
- float* rwork, logical_t* bwork, integer_t& info ) {
- LAPACK_CGEESX( &jobvs, &sort, &select, &sense, &n,
- traits::complex_ptr(a), &lda, &sdim, traits::complex_ptr(w),
- traits::complex_ptr(vs), &ldvs, &rconde, &rcondv,
- traits::complex_ptr(work), &lwork, rwork, bwork, &info );
- }
- inline void geesx( const char jobvs, const char sort, logical_t* select,
- const char sense, const integer_t n, traits::complex_d* a,
- const integer_t lda, integer_t& sdim, traits::complex_d* w,
- traits::complex_d* vs, const integer_t ldvs, double& rconde,
- double& rcondv, traits::complex_d* work, const integer_t lwork,
- double* rwork, logical_t* bwork, integer_t& info ) {
- LAPACK_ZGEESX( &jobvs, &sort, &select, &sense, &n,
- traits::complex_ptr(a), &lda, &sdim, traits::complex_ptr(w),
- traits::complex_ptr(vs), &ldvs, &rconde, &rcondv,
- traits::complex_ptr(work), &lwork, rwork, bwork, &info );
- }
+
+inline void geesx( const char jobvs, const char sort, logical_t* select,
+ const char sense, const integer_t n, float* a, const integer_t lda,
+ integer_t& sdim, float* wr, float* wi, float* vs,
+ const integer_t ldvs, float& rconde, float& rcondv, float* work,
+ const integer_t lwork, integer_t* iwork, const integer_t liwork,
+ logical_t* bwork, integer_t& info ) {
+ LAPACK_SGEESX( &jobvs, &sort, &select, &sense, &n, a, &lda, &sdim, wr, wi,
+ vs, &ldvs, &rconde, &rcondv, work, &lwork, iwork, &liwork, bwork,
+ &info );
 }
 
+inline void geesx( const char jobvs, const char sort, logical_t* select,
+ const char sense, const integer_t n, double* a, const integer_t lda,
+ integer_t& sdim, double* wr, double* wi, double* vs,
+ const integer_t ldvs, double& rconde, double& rcondv, double* work,
+ const integer_t lwork, integer_t* iwork, const integer_t liwork,
+ logical_t* bwork, integer_t& info ) {
+ LAPACK_DGEESX( &jobvs, &sort, &select, &sense, &n, a, &lda, &sdim, wr, wi,
+ vs, &ldvs, &rconde, &rcondv, work, &lwork, iwork, &liwork, bwork,
+ &info );
+}
+
+inline void geesx( const char jobvs, const char sort, logical_t* select,
+ const char sense, const integer_t n, traits::complex_f* a,
+ const integer_t lda, integer_t& sdim, traits::complex_f* w,
+ traits::complex_f* vs, const integer_t ldvs, float& rconde,
+ float& rcondv, traits::complex_f* work, const integer_t lwork,
+ float* rwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_CGEESX( &jobvs, &sort, &select, &sense, &n, traits::complex_ptr(a),
+ &lda, &sdim, traits::complex_ptr(w), traits::complex_ptr(vs),
+ &ldvs, &rconde, &rcondv, traits::complex_ptr(work), &lwork, rwork,
+ bwork, &info );
+}
+
+inline void geesx( const char jobvs, const char sort, logical_t* select,
+ const char sense, const integer_t n, traits::complex_d* a,
+ const integer_t lda, integer_t& sdim, traits::complex_d* w,
+ traits::complex_d* vs, const integer_t ldvs, double& rconde,
+ double& rcondv, traits::complex_d* work, const integer_t lwork,
+ double* rwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_ZGEESX( &jobvs, &sort, &select, &sense, &n, traits::complex_ptr(a),
+ &lda, &sdim, traits::complex_ptr(w), traits::complex_ptr(vs),
+ &ldvs, &rconde, &rcondv, traits::complex_ptr(work), &lwork, rwork,
+ bwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct geesx_impl{};
@@ -374,6 +379,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,45 +37,47 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void geev( const char jobvl, const char jobvr, const integer_t n,
- float* a, const integer_t lda, float* wr, float* wi, float* vl,
- const integer_t ldvl, float* vr, const integer_t ldvr,
- float* work, const integer_t lwork, integer_t& info ) {
- LAPACK_SGEEV( &jobvl, &jobvr, &n, a, &lda, wr, wi, vl, &ldvl, vr,
- &ldvr, work, &lwork, &info );
- }
- inline void geev( const char jobvl, const char jobvr, const integer_t n,
- double* a, const integer_t lda, double* wr, double* wi,
- double* vl, const integer_t ldvl, double* vr,
- const integer_t ldvr, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DGEEV( &jobvl, &jobvr, &n, a, &lda, wr, wi, vl, &ldvl, vr,
- &ldvr, work, &lwork, &info );
- }
- inline void geev( const char jobvl, const char jobvr, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* w,
- traits::complex_f* vl, const integer_t ldvl,
- traits::complex_f* vr, const integer_t ldvr,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t& info ) {
- LAPACK_CGEEV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(w), traits::complex_ptr(vl), &ldvl,
- traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work),
- &lwork, rwork, &info );
- }
- inline void geev( const char jobvl, const char jobvr, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* w,
- traits::complex_d* vl, const integer_t ldvl,
- traits::complex_d* vr, const integer_t ldvr,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t& info ) {
- LAPACK_ZGEEV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(w), traits::complex_ptr(vl), &ldvl,
- traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work),
- &lwork, rwork, &info );
- }
+
+inline void geev( const char jobvl, const char jobvr, const integer_t n,
+ float* a, const integer_t lda, float* wr, float* wi, float* vl,
+ const integer_t ldvl, float* vr, const integer_t ldvr, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SGEEV( &jobvl, &jobvr, &n, a, &lda, wr, wi, vl, &ldvl, vr, &ldvr,
+ work, &lwork, &info );
+}
+
+inline void geev( const char jobvl, const char jobvr, const integer_t n,
+ double* a, const integer_t lda, double* wr, double* wi, double* vl,
+ const integer_t ldvl, double* vr, const integer_t ldvr, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DGEEV( &jobvl, &jobvr, &n, a, &lda, wr, wi, vl, &ldvl, vr, &ldvr,
+ work, &lwork, &info );
+}
+
+inline void geev( const char jobvl, const char jobvr, const integer_t n,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* w,
+ traits::complex_f* vl, const integer_t ldvl, traits::complex_f* vr,
+ const integer_t ldvr, traits::complex_f* work, const integer_t lwork,
+ float* rwork, integer_t& info ) {
+ LAPACK_CGEEV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(w), traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work), &lwork,
+ rwork, &info );
 }
 
+inline void geev( const char jobvl, const char jobvr, const integer_t n,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* w,
+ traits::complex_d* vl, const integer_t ldvl, traits::complex_d* vr,
+ const integer_t ldvr, traits::complex_d* work, const integer_t lwork,
+ double* rwork, integer_t& info ) {
+ LAPACK_ZGEEV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(w), traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work), &lwork,
+ rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct geev_impl{};
@@ -299,6 +301,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,56 +37,59 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void geevx( const char balanc, const char jobvl, const char jobvr,
- const char sense, const integer_t n, float* a,
- const integer_t lda, float* wr, float* wi, float* vl,
- const integer_t ldvl, float* vr, const integer_t ldvr,
- integer_t& ilo, integer_t& ihi, float* scale, float& abnrm,
- float* rconde, float* rcondv, float* work, const integer_t lwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SGEEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, wr, wi,
- vl, &ldvl, vr, &ldvr, &ilo, &ihi, scale, &abnrm, rconde,
- rcondv, work, &lwork, iwork, &info );
- }
- inline void geevx( const char balanc, const char jobvl, const char jobvr,
- const char sense, const integer_t n, double* a,
- const integer_t lda, double* wr, double* wi, double* vl,
- const integer_t ldvl, double* vr, const integer_t ldvr,
- integer_t& ilo, integer_t& ihi, double* scale, double& abnrm,
- double* rconde, double* rcondv, double* work,
- const integer_t lwork, integer_t* iwork, integer_t& info ) {
- LAPACK_DGEEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, wr, wi,
- vl, &ldvl, vr, &ldvr, &ilo, &ihi, scale, &abnrm, rconde,
- rcondv, work, &lwork, iwork, &info );
- }
- inline void geevx( const char balanc, const char jobvl, const char jobvr,
- const char sense, const integer_t n, traits::complex_f* a,
- const integer_t lda, traits::complex_f* w, traits::complex_f* vl,
- const integer_t ldvl, traits::complex_f* vr, const integer_t ldvr,
- integer_t& ilo, integer_t& ihi, float* scale, float& abnrm,
- float* rconde, float* rcondv, traits::complex_f* work,
- const integer_t lwork, float* rwork, integer_t& info ) {
- LAPACK_CGEEVX( &balanc, &jobvl, &jobvr, &sense, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(w),
- traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, &ilo, &ihi, scale, &abnrm, rconde, rcondv,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
- inline void geevx( const char balanc, const char jobvl, const char jobvr,
- const char sense, const integer_t n, traits::complex_d* a,
- const integer_t lda, traits::complex_d* w, traits::complex_d* vl,
- const integer_t ldvl, traits::complex_d* vr, const integer_t ldvr,
- integer_t& ilo, integer_t& ihi, double* scale, double& abnrm,
- double* rconde, double* rcondv, traits::complex_d* work,
- const integer_t lwork, double* rwork, integer_t& info ) {
- LAPACK_ZGEEVX( &balanc, &jobvl, &jobvr, &sense, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(w),
- traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, &ilo, &ihi, scale, &abnrm, rconde, rcondv,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
+
+inline void geevx( const char balanc, const char jobvl, const char jobvr,
+ const char sense, const integer_t n, float* a, const integer_t lda,
+ float* wr, float* wi, float* vl, const integer_t ldvl, float* vr,
+ const integer_t ldvr, integer_t& ilo, integer_t& ihi, float* scale,
+ float& abnrm, float* rconde, float* rcondv, float* work,
+ const integer_t lwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_SGEEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, wr, wi, vl,
+ &ldvl, vr, &ldvr, &ilo, &ihi, scale, &abnrm, rconde, rcondv, work,
+ &lwork, iwork, &info );
+}
+
+inline void geevx( const char balanc, const char jobvl, const char jobvr,
+ const char sense, const integer_t n, double* a, const integer_t lda,
+ double* wr, double* wi, double* vl, const integer_t ldvl, double* vr,
+ const integer_t ldvr, integer_t& ilo, integer_t& ihi, double* scale,
+ double& abnrm, double* rconde, double* rcondv, double* work,
+ const integer_t lwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGEEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, wr, wi, vl,
+ &ldvl, vr, &ldvr, &ilo, &ihi, scale, &abnrm, rconde, rcondv, work,
+ &lwork, iwork, &info );
+}
+
+inline void geevx( const char balanc, const char jobvl, const char jobvr,
+ const char sense, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* w, traits::complex_f* vl,
+ const integer_t ldvl, traits::complex_f* vr, const integer_t ldvr,
+ integer_t& ilo, integer_t& ihi, float* scale, float& abnrm,
+ float* rconde, float* rcondv, traits::complex_f* work,
+ const integer_t lwork, float* rwork, integer_t& info ) {
+ LAPACK_CGEEVX( &balanc, &jobvl, &jobvr, &sense, &n,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(w),
+ traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr,
+ &ilo, &ihi, scale, &abnrm, rconde, rcondv,
+ traits::complex_ptr(work), &lwork, rwork, &info );
 }
 
+inline void geevx( const char balanc, const char jobvl, const char jobvr,
+ const char sense, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* w, traits::complex_d* vl,
+ const integer_t ldvl, traits::complex_d* vr, const integer_t ldvr,
+ integer_t& ilo, integer_t& ihi, double* scale, double& abnrm,
+ double* rconde, double* rcondv, traits::complex_d* work,
+ const integer_t lwork, double* rwork, integer_t& info ) {
+ LAPACK_ZGEEVX( &balanc, &jobvl, &jobvr, &sense, &n,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(w),
+ traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr,
+ &ilo, &ihi, scale, &abnrm, rconde, rcondv,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct geevx_impl{};
@@ -431,6 +434,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,50 +37,53 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gegv( const char jobvl, const char jobvr, const integer_t n,
- float* a, const integer_t lda, float* b, const integer_t ldb,
- float* alphar, float* alphai, float* beta, float* vl,
- const integer_t ldvl, float* vr, const integer_t ldvr,
- float* work, const integer_t lwork, integer_t& info ) {
- LAPACK_SGEGV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai,
- beta, vl, &ldvl, vr, &ldvr, work, &lwork, &info );
- }
- inline void gegv( const char jobvl, const char jobvr, const integer_t n,
- double* a, const integer_t lda, double* b, const integer_t ldb,
- double* alphar, double* alphai, double* beta, double* vl,
- const integer_t ldvl, double* vr, const integer_t ldvr,
- double* work, const integer_t lwork, integer_t& info ) {
- LAPACK_DGEGV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai,
- beta, vl, &ldvl, vr, &ldvr, work, &lwork, &info );
- }
- inline void gegv( const char jobvl, const char jobvr, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* b,
- const integer_t ldb, traits::complex_f* alpha,
- traits::complex_f* beta, traits::complex_f* vl,
- const integer_t ldvl, traits::complex_f* vr, const integer_t ldvr,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t& info ) {
- LAPACK_CGEGV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
- traits::complex_ptr(beta), traits::complex_ptr(vl), &ldvl,
- traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work),
- &lwork, rwork, &info );
- }
- inline void gegv( const char jobvl, const char jobvr, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* b,
- const integer_t ldb, traits::complex_d* alpha,
- traits::complex_d* beta, traits::complex_d* vl,
- const integer_t ldvl, traits::complex_d* vr, const integer_t ldvr,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t& info ) {
- LAPACK_ZGEGV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
- traits::complex_ptr(beta), traits::complex_ptr(vl), &ldvl,
- traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work),
- &lwork, rwork, &info );
- }
+
+inline void gegv( const char jobvl, const char jobvr, const integer_t n,
+ float* a, const integer_t lda, float* b, const integer_t ldb,
+ float* alphar, float* alphai, float* beta, float* vl,
+ const integer_t ldvl, float* vr, const integer_t ldvr, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SGEGV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai, beta,
+ vl, &ldvl, vr, &ldvr, work, &lwork, &info );
+}
+
+inline void gegv( const char jobvl, const char jobvr, const integer_t n,
+ double* a, const integer_t lda, double* b, const integer_t ldb,
+ double* alphar, double* alphai, double* beta, double* vl,
+ const integer_t ldvl, double* vr, const integer_t ldvr, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DGEGV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai, beta,
+ vl, &ldvl, vr, &ldvr, work, &lwork, &info );
+}
+
+inline void gegv( const char jobvl, const char jobvr, const integer_t n,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* alpha,
+ traits::complex_f* beta, traits::complex_f* vl, const integer_t ldvl,
+ traits::complex_f* vr, const integer_t ldvr, traits::complex_f* work,
+ const integer_t lwork, float* rwork, integer_t& info ) {
+ LAPACK_CGEGV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
+ traits::complex_ptr(beta), traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work), &lwork,
+ rwork, &info );
 }
 
+inline void gegv( const char jobvl, const char jobvr, const integer_t n,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* alpha,
+ traits::complex_d* beta, traits::complex_d* vl, const integer_t ldvl,
+ traits::complex_d* vr, const integer_t ldvr, traits::complex_d* work,
+ const integer_t lwork, double* rwork, integer_t& info ) {
+ LAPACK_ZGEGV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
+ traits::complex_ptr(beta), traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work), &lwork,
+ rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gegv_impl{};
@@ -340,6 +343,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,38 +37,43 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gels( const char trans, const integer_t m, const integer_t n,
- const integer_t nrhs, float* a, const integer_t lda, float* b,
- const integer_t ldb, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SGELS( &trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork,
- &info );
- }
- inline void gels( const char trans, const integer_t m, const integer_t n,
- const integer_t nrhs, double* a, const integer_t lda, double* b,
- const integer_t ldb, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DGELS( &trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork,
- &info );
- }
- inline void gels( const char trans, const integer_t m, const integer_t n,
- const integer_t nrhs, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGELS( &trans, &m, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(work),
- &lwork, &info );
- }
- inline void gels( const char trans, const integer_t m, const integer_t n,
- const integer_t nrhs, traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGELS( &trans, &m, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(work),
- &lwork, &info );
- }
+
+inline void gels( const char trans, const integer_t m, const integer_t n,
+ const integer_t nrhs, float* a, const integer_t lda, float* b,
+ const integer_t ldb, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGELS( &trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork,
+ &info );
 }
 
+inline void gels( const char trans, const integer_t m, const integer_t n,
+ const integer_t nrhs, double* a, const integer_t lda, double* b,
+ const integer_t ldb, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DGELS( &trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork,
+ &info );
+}
+
+inline void gels( const char trans, const integer_t m, const integer_t n,
+ const integer_t nrhs, traits::complex_f* a, const integer_t lda,
+ traits::complex_f* b, const integer_t ldb, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CGELS( &trans, &m, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+inline void gels( const char trans, const integer_t m, const integer_t n,
+ const integer_t nrhs, traits::complex_d* a, const integer_t lda,
+ traits::complex_d* b, const integer_t ldb, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZGELS( &trans, &m, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gels_impl{};
@@ -228,6 +233,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -38,44 +38,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gelsd( const integer_t m, const integer_t n,
- const integer_t nrhs, const float* a, const integer_t lda,
- float* b, const integer_t ldb, float* s, const float rcond,
- integer_t& rank, float* work, const integer_t lwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_SGELSD( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank,
- work, &lwork, iwork, &info );
- }
- inline void gelsd( const integer_t m, const integer_t n,
- const integer_t nrhs, const double* a, const integer_t lda,
- double* b, const integer_t ldb, double* s, const double rcond,
- integer_t& rank, double* work, const integer_t lwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DGELSD( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank,
- work, &lwork, iwork, &info );
- }
- inline void gelsd( const integer_t m, const integer_t n,
- const integer_t nrhs, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, float* s,
- const float rcond, integer_t& rank, traits::complex_f* work,
- const integer_t lwork, float* rwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_CGELSD( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, s, &rcond, &rank,
- traits::complex_ptr(work), &lwork, rwork, iwork, &info );
- }
- inline void gelsd( const integer_t m, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, traits::complex_d* b, const integer_t ldb,
- double* s, const double rcond, integer_t& rank,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_ZGELSD( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, s, &rcond, &rank,
- traits::complex_ptr(work), &lwork, rwork, iwork, &info );
- }
+
+inline void gelsd( const integer_t m, const integer_t n, const integer_t nrhs,
+ const float* a, const integer_t lda, float* b, const integer_t ldb,
+ float* s, const float rcond, integer_t& rank, float* work,
+ const integer_t lwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_SGELSD( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work,
+ &lwork, iwork, &info );
 }
 
+inline void gelsd( const integer_t m, const integer_t n, const integer_t nrhs,
+ const double* a, const integer_t lda, double* b, const integer_t ldb,
+ double* s, const double rcond, integer_t& rank, double* work,
+ const integer_t lwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGELSD( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work,
+ &lwork, iwork, &info );
+}
+
+inline void gelsd( const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, float* s, const float rcond, integer_t& rank,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_CGELSD( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, s, &rcond, &rank,
+ traits::complex_ptr(work), &lwork, rwork, iwork, &info );
+}
+
+inline void gelsd( const integer_t m, const integer_t n, const integer_t nrhs,
+ const traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, double* s, const double rcond, integer_t& rank,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_ZGELSD( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, s, &rcond, &rank,
+ traits::complex_ptr(work), &lwork, rwork, iwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gelsd_impl{};
@@ -346,6 +347,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,41 +37,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gelss( const integer_t m, const integer_t n,
- const integer_t nrhs, float* a, const integer_t lda, float* b,
- const integer_t ldb, float* s, const float rcond, integer_t& rank,
- float* work, const integer_t lwork, integer_t& info ) {
- LAPACK_SGELSS( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank,
- work, &lwork, &info );
- }
- inline void gelss( const integer_t m, const integer_t n,
- const integer_t nrhs, double* a, const integer_t lda, double* b,
- const integer_t ldb, double* s, const double rcond,
- integer_t& rank, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DGELSS( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank,
- work, &lwork, &info );
- }
- inline void gelss( const integer_t m, const integer_t n,
- const integer_t nrhs, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, float* s,
- const float rcond, integer_t& rank, traits::complex_f* work,
- const integer_t lwork, float* rwork, integer_t& info ) {
- LAPACK_CGELSS( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, s, &rcond, &rank,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
- inline void gelss( const integer_t m, const integer_t n,
- const integer_t nrhs, traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb, double* s,
- const double rcond, integer_t& rank, traits::complex_d* work,
- const integer_t lwork, double* rwork, integer_t& info ) {
- LAPACK_ZGELSS( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, s, &rcond, &rank,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
+
+inline void gelss( const integer_t m, const integer_t n, const integer_t nrhs,
+ float* a, const integer_t lda, float* b, const integer_t ldb,
+ float* s, const float rcond, integer_t& rank, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SGELSS( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work,
+ &lwork, &info );
 }
 
+inline void gelss( const integer_t m, const integer_t n, const integer_t nrhs,
+ double* a, const integer_t lda, double* b, const integer_t ldb,
+ double* s, const double rcond, integer_t& rank, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DGELSS( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work,
+ &lwork, &info );
+}
+
+inline void gelss( const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, float* s, const float rcond, integer_t& rank,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ integer_t& info ) {
+ LAPACK_CGELSS( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, s, &rcond, &rank,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+inline void gelss( const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, double* s, const double rcond, integer_t& rank,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZGELSS( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, s, &rcond, &rank,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gelss_impl{};
@@ -272,6 +276,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,42 +37,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gelsy( const integer_t m, const integer_t n,
- const integer_t nrhs, float* a, const integer_t lda, float* b,
- const integer_t ldb, integer_t* jpvt, const float rcond,
- integer_t& rank, float* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_SGELSY( &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank,
- work, &lwork, &info );
- }
- inline void gelsy( const integer_t m, const integer_t n,
- const integer_t nrhs, double* a, const integer_t lda, double* b,
- const integer_t ldb, integer_t* jpvt, const double rcond,
- integer_t& rank, double* work, const integer_t lwork,
- integer_t& info ) {
- LAPACK_DGELSY( &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank,
- work, &lwork, &info );
- }
- inline void gelsy( const integer_t m, const integer_t n,
- const integer_t nrhs, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, integer_t* jpvt,
- const float rcond, integer_t& rank, traits::complex_f* work,
- const integer_t lwork, float* rwork, integer_t& info ) {
- LAPACK_CGELSY( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, jpvt, &rcond, &rank,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
- inline void gelsy( const integer_t m, const integer_t n,
- const integer_t nrhs, traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb, integer_t* jpvt,
- const double rcond, integer_t& rank, traits::complex_d* work,
- const integer_t lwork, double* rwork, integer_t& info ) {
- LAPACK_ZGELSY( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, jpvt, &rcond, &rank,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
+
+inline void gelsy( const integer_t m, const integer_t n, const integer_t nrhs,
+ float* a, const integer_t lda, float* b, const integer_t ldb,
+ integer_t* jpvt, const float rcond, integer_t& rank, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SGELSY( &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank, work,
+ &lwork, &info );
 }
 
+inline void gelsy( const integer_t m, const integer_t n, const integer_t nrhs,
+ double* a, const integer_t lda, double* b, const integer_t ldb,
+ integer_t* jpvt, const double rcond, integer_t& rank, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DGELSY( &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank, work,
+ &lwork, &info );
+}
+
+inline void gelsy( const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, integer_t* jpvt, const float rcond,
+ integer_t& rank, traits::complex_f* work, const integer_t lwork,
+ float* rwork, integer_t& info ) {
+ LAPACK_CGELSY( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, jpvt, &rcond, &rank,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+inline void gelsy( const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, integer_t* jpvt, const double rcond,
+ integer_t& rank, traits::complex_d* work, const integer_t lwork,
+ double* rwork, integer_t& info ) {
+ LAPACK_ZGELSY( &m, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, jpvt, &rcond, &rank,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gelsy_impl{};
@@ -261,6 +264,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,43 +37,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gesdd( const char jobz, const integer_t m, const integer_t n,
- float* a, const integer_t lda, float* s, float* u,
- const integer_t ldu, float* vt, const integer_t ldvt, float* work,
- const integer_t lwork, integer_t* iwork, integer_t& info ) {
- LAPACK_SGESDD( &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work,
- &lwork, iwork, &info );
- }
- inline void gesdd( const char jobz, const integer_t m, const integer_t n,
- double* a, const integer_t lda, double* s, double* u,
- const integer_t ldu, double* vt, const integer_t ldvt,
- double* work, const integer_t lwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_DGESDD( &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work,
- &lwork, iwork, &info );
- }
- inline void gesdd( const char jobz, const integer_t m, const integer_t n,
- traits::complex_f* a, const integer_t lda, float* s,
- traits::complex_f* u, const integer_t ldu, traits::complex_f* vt,
- const integer_t ldvt, traits::complex_f* work,
- const integer_t lwork, float* rwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_CGESDD( &jobz, &m, &n, traits::complex_ptr(a), &lda, s,
- traits::complex_ptr(u), &ldu, traits::complex_ptr(vt), &ldvt,
- traits::complex_ptr(work), &lwork, rwork, iwork, &info );
- }
- inline void gesdd( const char jobz, const integer_t m, const integer_t n,
- traits::complex_d* a, const integer_t lda, double* s,
- traits::complex_d* u, const integer_t ldu, traits::complex_d* vt,
- const integer_t ldvt, traits::complex_d* work,
- const integer_t lwork, double* rwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_ZGESDD( &jobz, &m, &n, traits::complex_ptr(a), &lda, s,
- traits::complex_ptr(u), &ldu, traits::complex_ptr(vt), &ldvt,
- traits::complex_ptr(work), &lwork, rwork, iwork, &info );
- }
+
+inline void gesdd( const char jobz, const integer_t m, const integer_t n,
+ float* a, const integer_t lda, float* s, float* u,
+ const integer_t ldu, float* vt, const integer_t ldvt, float* work,
+ const integer_t lwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_SGESDD( &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work,
+ &lwork, iwork, &info );
 }
 
+inline void gesdd( const char jobz, const integer_t m, const integer_t n,
+ double* a, const integer_t lda, double* s, double* u,
+ const integer_t ldu, double* vt, const integer_t ldvt, double* work,
+ const integer_t lwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGESDD( &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work,
+ &lwork, iwork, &info );
+}
+
+inline void gesdd( const char jobz, const integer_t m, const integer_t n,
+ traits::complex_f* a, const integer_t lda, float* s,
+ traits::complex_f* u, const integer_t ldu, traits::complex_f* vt,
+ const integer_t ldvt, traits::complex_f* work, const integer_t lwork,
+ float* rwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_CGESDD( &jobz, &m, &n, traits::complex_ptr(a), &lda, s,
+ traits::complex_ptr(u), &ldu, traits::complex_ptr(vt), &ldvt,
+ traits::complex_ptr(work), &lwork, rwork, iwork, &info );
+}
+
+inline void gesdd( const char jobz, const integer_t m, const integer_t n,
+ traits::complex_d* a, const integer_t lda, double* s,
+ traits::complex_d* u, const integer_t ldu, traits::complex_d* vt,
+ const integer_t ldvt, traits::complex_d* work, const integer_t lwork,
+ double* rwork, integer_t* iwork, integer_t& info ) {
+ LAPACK_ZGESDD( &jobz, &m, &n, traits::complex_ptr(a), &lda, s,
+ traits::complex_ptr(u), &ldu, traits::complex_ptr(vt), &ldvt,
+ traits::complex_ptr(work), &lwork, rwork, iwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gesdd_impl{};
@@ -297,6 +299,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -32,30 +32,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gesv( const integer_t n, const integer_t nrhs, float* a,
- const integer_t lda, integer_t* ipiv, float* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_SGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
- }
- inline void gesv( const integer_t n, const integer_t nrhs, double* a,
- const integer_t lda, integer_t* ipiv, double* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_DGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
- }
- inline void gesv( const integer_t n, const integer_t nrhs,
- traits::complex_f* a, const integer_t lda, integer_t* ipiv,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CGESV( &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void gesv( const integer_t n, const integer_t nrhs,
- traits::complex_d* a, const integer_t lda, integer_t* ipiv,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZGESV( &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void gesv( const integer_t n, const integer_t nrhs, float* a,
+ const integer_t lda, integer_t* ipiv, float* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_SGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
+}
+
+inline void gesv( const integer_t n, const integer_t nrhs, double* a,
+ const integer_t lda, integer_t* ipiv, double* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_DGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, &info );
+}
+
+inline void gesv( const integer_t n, const integer_t nrhs,
+ traits::complex_f* a, const integer_t lda, integer_t* ipiv,
+ traits::complex_f* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_CGESV( &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void gesv( const integer_t n, const integer_t nrhs,
+ traits::complex_d* a, const integer_t lda, integer_t* ipiv,
+ traits::complex_d* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_ZGESV( &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct gesv_impl {
@@ -113,6 +118,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,42 +37,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gesvd( const char jobu, const char jobvt, const integer_t m,
- const integer_t n, float* a, const integer_t lda, float* s,
- float* u, const integer_t ldu, float* vt, const integer_t ldvt,
- float* work, const integer_t lwork, integer_t& info ) {
- LAPACK_SGESVD( &jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt,
- work, &lwork, &info );
- }
- inline void gesvd( const char jobu, const char jobvt, const integer_t m,
- const integer_t n, double* a, const integer_t lda, double* s,
- double* u, const integer_t ldu, double* vt, const integer_t ldvt,
- double* work, const integer_t lwork, integer_t& info ) {
- LAPACK_DGESVD( &jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt,
- work, &lwork, &info );
- }
- inline void gesvd( const char jobu, const char jobvt, const integer_t m,
- const integer_t n, traits::complex_f* a, const integer_t lda,
- float* s, traits::complex_f* u, const integer_t ldu,
- traits::complex_f* vt, const integer_t ldvt,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t& info ) {
- LAPACK_CGESVD( &jobu, &jobvt, &m, &n, traits::complex_ptr(a), &lda, s,
- traits::complex_ptr(u), &ldu, traits::complex_ptr(vt), &ldvt,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
- inline void gesvd( const char jobu, const char jobvt, const integer_t m,
- const integer_t n, traits::complex_d* a, const integer_t lda,
- double* s, traits::complex_d* u, const integer_t ldu,
- traits::complex_d* vt, const integer_t ldvt,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t& info ) {
- LAPACK_ZGESVD( &jobu, &jobvt, &m, &n, traits::complex_ptr(a), &lda, s,
- traits::complex_ptr(u), &ldu, traits::complex_ptr(vt), &ldvt,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
+
+inline void gesvd( const char jobu, const char jobvt, const integer_t m,
+ const integer_t n, float* a, const integer_t lda, float* s, float* u,
+ const integer_t ldu, float* vt, const integer_t ldvt, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SGESVD( &jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt,
+ work, &lwork, &info );
 }
 
+inline void gesvd( const char jobu, const char jobvt, const integer_t m,
+ const integer_t n, double* a, const integer_t lda, double* s,
+ double* u, const integer_t ldu, double* vt, const integer_t ldvt,
+ double* work, const integer_t lwork, integer_t& info ) {
+ LAPACK_DGESVD( &jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt,
+ work, &lwork, &info );
+}
+
+inline void gesvd( const char jobu, const char jobvt, const integer_t m,
+ const integer_t n, traits::complex_f* a, const integer_t lda,
+ float* s, traits::complex_f* u, const integer_t ldu,
+ traits::complex_f* vt, const integer_t ldvt, traits::complex_f* work,
+ const integer_t lwork, float* rwork, integer_t& info ) {
+ LAPACK_CGESVD( &jobu, &jobvt, &m, &n, traits::complex_ptr(a), &lda, s,
+ traits::complex_ptr(u), &ldu, traits::complex_ptr(vt), &ldvt,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+inline void gesvd( const char jobu, const char jobvt, const integer_t m,
+ const integer_t n, traits::complex_d* a, const integer_t lda,
+ double* s, traits::complex_d* u, const integer_t ldu,
+ traits::complex_d* vt, const integer_t ldvt, traits::complex_d* work,
+ const integer_t lwork, double* rwork, integer_t& info ) {
+ LAPACK_ZGESVD( &jobu, &jobvt, &m, &n, traits::complex_ptr(a), &lda, s,
+ traits::complex_ptr(u), &ldu, traits::complex_ptr(vt), &ldvt,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gesvd_impl{};
@@ -279,6 +282,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,52 +36,55 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gesvx( const char fact, const char trans, const integer_t n,
- const integer_t nrhs, float* a, const integer_t lda, float* af,
- const integer_t ldaf, integer_t* ipiv, char& equed, float* r,
- float* c, float* b, const integer_t ldb, float* x,
- const integer_t ldx, float& rcond, float* ferr, float* berr,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SGESVX( &fact, &trans, &n, &nrhs, a, &lda, af, &ldaf, ipiv,
- &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr, berr, work,
- iwork, &info );
- }
- inline void gesvx( const char fact, const char trans, const integer_t n,
- const integer_t nrhs, double* a, const integer_t lda, double* af,
- const integer_t ldaf, integer_t* ipiv, char& equed, double* r,
- double* c, double* b, const integer_t ldb, double* x,
- const integer_t ldx, double& rcond, double* ferr, double* berr,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DGESVX( &fact, &trans, &n, &nrhs, a, &lda, af, &ldaf, ipiv,
- &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr, berr, work,
- iwork, &info );
- }
- inline void gesvx( const char fact, const char trans, const integer_t n,
- const integer_t nrhs, traits::complex_f* a, const integer_t lda,
- traits::complex_f* af, const integer_t ldaf, integer_t* ipiv,
- char& equed, float* r, float* c, traits::complex_f* b,
- const integer_t ldb, traits::complex_f* x, const integer_t ldx,
- float& rcond, float* ferr, float* berr, traits::complex_f* work,
- float* rwork, integer_t& info ) {
- LAPACK_CGESVX( &fact, &trans, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, &equed, r, c,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
- inline void gesvx( const char fact, const char trans, const integer_t n,
- const integer_t nrhs, traits::complex_d* a, const integer_t lda,
- traits::complex_d* af, const integer_t ldaf, integer_t* ipiv,
- char& equed, double* r, double* c, traits::complex_d* b,
- const integer_t ldb, traits::complex_d* x, const integer_t ldx,
- double& rcond, double* ferr, double* berr,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZGESVX( &fact, &trans, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, &equed, r, c,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void gesvx( const char fact, const char trans, const integer_t n,
+ const integer_t nrhs, float* a, const integer_t lda, float* af,
+ const integer_t ldaf, integer_t* ipiv, char& equed, float* r,
+ float* c, float* b, const integer_t ldb, float* x,
+ const integer_t ldx, float& rcond, float* ferr, float* berr,
+ float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SGESVX( &fact, &trans, &n, &nrhs, a, &lda, af, &ldaf, ipiv, &equed,
+ r, c, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info );
+}
+
+inline void gesvx( const char fact, const char trans, const integer_t n,
+ const integer_t nrhs, double* a, const integer_t lda, double* af,
+ const integer_t ldaf, integer_t* ipiv, char& equed, double* r,
+ double* c, double* b, const integer_t ldb, double* x,
+ const integer_t ldx, double& rcond, double* ferr, double* berr,
+ double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGESVX( &fact, &trans, &n, &nrhs, a, &lda, af, &ldaf, ipiv, &equed,
+ r, c, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info );
+}
+
+inline void gesvx( const char fact, const char trans, const integer_t n,
+ const integer_t nrhs, traits::complex_f* a, const integer_t lda,
+ traits::complex_f* af, const integer_t ldaf, integer_t* ipiv,
+ char& equed, float* r, float* c, traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float& rcond, float* ferr, float* berr, traits::complex_f* work,
+ float* rwork, integer_t& info ) {
+ LAPACK_CGESVX( &fact, &trans, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, &equed, r, c,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
 }
 
+inline void gesvx( const char fact, const char trans, const integer_t n,
+ const integer_t nrhs, traits::complex_d* a, const integer_t lda,
+ traits::complex_d* af, const integer_t ldaf, integer_t* ipiv,
+ char& equed, double* r, double* c, traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double& rcond, double* ferr, double* berr, traits::complex_d* work,
+ double* rwork, integer_t& info ) {
+ LAPACK_ZGESVX( &fact, &trans, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, &equed, r, c,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gesvx_impl{};
@@ -339,6 +342,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,62 +37,59 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gges( const char jobvsl, const char jobvsr, const char sort,
- logical_t* selctg, const integer_t n, float* a,
- const integer_t lda, float* b, const integer_t ldb,
- integer_t& sdim, float* alphar, float* alphai, float* beta,
- float* vsl, const integer_t ldvsl, float* vsr,
- const integer_t ldvsr, float* work, const integer_t lwork,
- logical_t* bwork, integer_t& info ) {
- LAPACK_SGGES( &jobvsl, &jobvsr, &sort, &selctg, &n, a, &lda, b, &ldb,
- &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr, work,
- &lwork, bwork, &info );
- }
- inline void gges( const char jobvsl, const char jobvsr, const char sort,
- logical_t* selctg, const integer_t n, double* a,
- const integer_t lda, double* b, const integer_t ldb,
- integer_t& sdim, double* alphar, double* alphai, double* beta,
- double* vsl, const integer_t ldvsl, double* vsr,
- const integer_t ldvsr, double* work, const integer_t lwork,
- logical_t* bwork, integer_t& info ) {
- LAPACK_DGGES( &jobvsl, &jobvsr, &sort, &selctg, &n, a, &lda, b, &ldb,
- &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr, work,
- &lwork, bwork, &info );
- }
- inline void gges( const char jobvsl, const char jobvsr, const char sort,
- logical_t* selctg, const integer_t n, traits::complex_f* a,
- const integer_t lda, traits::complex_f* b, const integer_t ldb,
- integer_t& sdim, traits::complex_f* alpha,
- traits::complex_f* beta, traits::complex_f* vsl,
- const integer_t ldvsl, traits::complex_f* vsr,
- const integer_t ldvsr, traits::complex_f* work,
- const integer_t lwork, float* rwork, logical_t* bwork,
- integer_t& info ) {
- LAPACK_CGGES( &jobvsl, &jobvsr, &sort, &selctg, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &sdim, traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(vsl), &ldvsl, traits::complex_ptr(vsr),
- &ldvsr, traits::complex_ptr(work), &lwork, rwork, bwork,
- &info );
- }
- inline void gges( const char jobvsl, const char jobvsr, const char sort,
- logical_t* selctg, const integer_t n, traits::complex_d* a,
- const integer_t lda, traits::complex_d* b, const integer_t ldb,
- integer_t& sdim, traits::complex_d* alpha,
- traits::complex_d* beta, traits::complex_d* vsl,
- const integer_t ldvsl, traits::complex_d* vsr,
- const integer_t ldvsr, traits::complex_d* work,
- const integer_t lwork, double* rwork, logical_t* bwork,
- integer_t& info ) {
- LAPACK_ZGGES( &jobvsl, &jobvsr, &sort, &selctg, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &sdim, traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(vsl), &ldvsl, traits::complex_ptr(vsr),
- &ldvsr, traits::complex_ptr(work), &lwork, rwork, bwork,
- &info );
- }
+
+inline void gges( const char jobvsl, const char jobvsr, const char sort,
+ logical_t* selctg, const integer_t n, float* a, const integer_t lda,
+ float* b, const integer_t ldb, integer_t& sdim, float* alphar,
+ float* alphai, float* beta, float* vsl, const integer_t ldvsl,
+ float* vsr, const integer_t ldvsr, float* work, const integer_t lwork,
+ logical_t* bwork, integer_t& info ) {
+ LAPACK_SGGES( &jobvsl, &jobvsr, &sort, &selctg, &n, a, &lda, b, &ldb,
+ &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr, work,
+ &lwork, bwork, &info );
 }
 
+inline void gges( const char jobvsl, const char jobvsr, const char sort,
+ logical_t* selctg, const integer_t n, double* a, const integer_t lda,
+ double* b, const integer_t ldb, integer_t& sdim, double* alphar,
+ double* alphai, double* beta, double* vsl, const integer_t ldvsl,
+ double* vsr, const integer_t ldvsr, double* work,
+ const integer_t lwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_DGGES( &jobvsl, &jobvsr, &sort, &selctg, &n, a, &lda, b, &ldb,
+ &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr, work,
+ &lwork, bwork, &info );
+}
+
+inline void gges( const char jobvsl, const char jobvsr, const char sort,
+ logical_t* selctg, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* b, const integer_t ldb,
+ integer_t& sdim, traits::complex_f* alpha, traits::complex_f* beta,
+ traits::complex_f* vsl, const integer_t ldvsl, traits::complex_f* vsr,
+ const integer_t ldvsr, traits::complex_f* work, const integer_t lwork,
+ float* rwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_CGGES( &jobvsl, &jobvsr, &sort, &selctg, &n,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, &sdim,
+ traits::complex_ptr(alpha), traits::complex_ptr(beta),
+ traits::complex_ptr(vsl), &ldvsl, traits::complex_ptr(vsr),
+ &ldvsr, traits::complex_ptr(work), &lwork, rwork, bwork, &info );
+}
+
+inline void gges( const char jobvsl, const char jobvsr, const char sort,
+ logical_t* selctg, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* b, const integer_t ldb,
+ integer_t& sdim, traits::complex_d* alpha, traits::complex_d* beta,
+ traits::complex_d* vsl, const integer_t ldvsl, traits::complex_d* vsr,
+ const integer_t ldvsr, traits::complex_d* work, const integer_t lwork,
+ double* rwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_ZGGES( &jobvsl, &jobvsr, &sort, &selctg, &n,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, &sdim,
+ traits::complex_ptr(alpha), traits::complex_ptr(beta),
+ traits::complex_ptr(vsl), &ldvsl, traits::complex_ptr(vsr),
+ &ldvsr, traits::complex_ptr(work), &lwork, rwork, bwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gges_impl{};
@@ -397,6 +394,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,68 +37,69 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggesx( const char jobvsl, const char jobvsr, const char sort,
- logical_t* selctg, const char sense, const integer_t n, float* a,
- const integer_t lda, float* b, const integer_t ldb,
- integer_t& sdim, float* alphar, float* alphai, float* beta,
- float* vsl, const integer_t ldvsl, float* vsr,
- const integer_t ldvsr, float* rconde, float* rcondv, float* work,
- const integer_t lwork, integer_t* iwork, const integer_t liwork,
- logical_t* bwork, integer_t& info ) {
- LAPACK_SGGESX( &jobvsl, &jobvsr, &sort, &selctg, &sense, &n, a, &lda,
- b, &ldb, &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr,
- &ldvsr, rconde, rcondv, work, &lwork, iwork, &liwork, bwork,
- &info );
- }
- inline void ggesx( const char jobvsl, const char jobvsr, const char sort,
- logical_t* selctg, const char sense, const integer_t n, double* a,
- const integer_t lda, double* b, const integer_t ldb,
- integer_t& sdim, double* alphar, double* alphai, double* beta,
- double* vsl, const integer_t ldvsl, double* vsr,
- const integer_t ldvsr, double* rconde, double* rcondv,
- double* work, const integer_t lwork, integer_t* iwork,
- const integer_t liwork, logical_t* bwork, integer_t& info ) {
- LAPACK_DGGESX( &jobvsl, &jobvsr, &sort, &selctg, &sense, &n, a, &lda,
- b, &ldb, &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr,
- &ldvsr, rconde, rcondv, work, &lwork, iwork, &liwork, bwork,
- &info );
- }
- inline void ggesx( const char jobvsl, const char jobvsr, const char sort,
- logical_t* selctg, const char sense, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* b,
- const integer_t ldb, integer_t& sdim, traits::complex_f* alpha,
- traits::complex_f* beta, traits::complex_f* vsl,
- const integer_t ldvsl, traits::complex_f* vsr,
- const integer_t ldvsr, float* rconde, float* rcondv,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t* iwork, const integer_t liwork, logical_t* bwork,
- integer_t& info ) {
- LAPACK_CGGESX( &jobvsl, &jobvsr, &sort, &selctg, &sense, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &sdim, traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(vsl), &ldvsl, traits::complex_ptr(vsr),
- &ldvsr, rconde, rcondv, traits::complex_ptr(work), &lwork,
- rwork, iwork, &liwork, bwork, &info );
- }
- inline void ggesx( const char jobvsl, const char jobvsr, const char sort,
- logical_t* selctg, const char sense, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* b,
- const integer_t ldb, integer_t& sdim, traits::complex_d* alpha,
- traits::complex_d* beta, traits::complex_d* vsl,
- const integer_t ldvsl, traits::complex_d* vsr,
- const integer_t ldvsr, double* rconde, double* rcondv,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t* iwork, const integer_t liwork, logical_t* bwork,
- integer_t& info ) {
- LAPACK_ZGGESX( &jobvsl, &jobvsr, &sort, &selctg, &sense, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &sdim, traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(vsl), &ldvsl, traits::complex_ptr(vsr),
- &ldvsr, rconde, rcondv, traits::complex_ptr(work), &lwork,
- rwork, iwork, &liwork, bwork, &info );
- }
+
+inline void ggesx( const char jobvsl, const char jobvsr, const char sort,
+ logical_t* selctg, const char sense, const integer_t n, float* a,
+ const integer_t lda, float* b, const integer_t ldb, integer_t& sdim,
+ float* alphar, float* alphai, float* beta, float* vsl,
+ const integer_t ldvsl, float* vsr, const integer_t ldvsr,
+ float* rconde, float* rcondv, float* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, logical_t* bwork,
+ integer_t& info ) {
+ LAPACK_SGGESX( &jobvsl, &jobvsr, &sort, &selctg, &sense, &n, a, &lda, b,
+ &ldb, &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr,
+ rconde, rcondv, work, &lwork, iwork, &liwork, bwork, &info );
 }
 
+inline void ggesx( const char jobvsl, const char jobvsr, const char sort,
+ logical_t* selctg, const char sense, const integer_t n, double* a,
+ const integer_t lda, double* b, const integer_t ldb, integer_t& sdim,
+ double* alphar, double* alphai, double* beta, double* vsl,
+ const integer_t ldvsl, double* vsr, const integer_t ldvsr,
+ double* rconde, double* rcondv, double* work, const integer_t lwork,
+ integer_t* iwork, const integer_t liwork, logical_t* bwork,
+ integer_t& info ) {
+ LAPACK_DGGESX( &jobvsl, &jobvsr, &sort, &selctg, &sense, &n, a, &lda, b,
+ &ldb, &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr,
+ rconde, rcondv, work, &lwork, iwork, &liwork, bwork, &info );
+}
+
+inline void ggesx( const char jobvsl, const char jobvsr, const char sort,
+ logical_t* selctg, const char sense, const integer_t n,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, integer_t& sdim, traits::complex_f* alpha,
+ traits::complex_f* beta, traits::complex_f* vsl,
+ const integer_t ldvsl, traits::complex_f* vsr, const integer_t ldvsr,
+ float* rconde, float* rcondv, traits::complex_f* work,
+ const integer_t lwork, float* rwork, integer_t* iwork,
+ const integer_t liwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_CGGESX( &jobvsl, &jobvsr, &sort, &selctg, &sense, &n,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, &sdim,
+ traits::complex_ptr(alpha), traits::complex_ptr(beta),
+ traits::complex_ptr(vsl), &ldvsl, traits::complex_ptr(vsr),
+ &ldvsr, rconde, rcondv, traits::complex_ptr(work), &lwork, rwork,
+ iwork, &liwork, bwork, &info );
+}
+
+inline void ggesx( const char jobvsl, const char jobvsr, const char sort,
+ logical_t* selctg, const char sense, const integer_t n,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, integer_t& sdim, traits::complex_d* alpha,
+ traits::complex_d* beta, traits::complex_d* vsl,
+ const integer_t ldvsl, traits::complex_d* vsr, const integer_t ldvsr,
+ double* rconde, double* rcondv, traits::complex_d* work,
+ const integer_t lwork, double* rwork, integer_t* iwork,
+ const integer_t liwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_ZGGESX( &jobvsl, &jobvsr, &sort, &selctg, &sense, &n,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, &sdim,
+ traits::complex_ptr(alpha), traits::complex_ptr(beta),
+ traits::complex_ptr(vsl), &ldvsl, traits::complex_ptr(vsr),
+ &ldvsr, rconde, rcondv, traits::complex_ptr(work), &lwork, rwork,
+ iwork, &liwork, bwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggesx_impl{};
@@ -487,6 +488,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,50 +37,53 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggev( const char jobvl, const char jobvr, const integer_t n,
- float* a, const integer_t lda, float* b, const integer_t ldb,
- float* alphar, float* alphai, float* beta, float* vl,
- const integer_t ldvl, float* vr, const integer_t ldvr,
- float* work, const integer_t lwork, integer_t& info ) {
- LAPACK_SGGEV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai,
- beta, vl, &ldvl, vr, &ldvr, work, &lwork, &info );
- }
- inline void ggev( const char jobvl, const char jobvr, const integer_t n,
- double* a, const integer_t lda, double* b, const integer_t ldb,
- double* alphar, double* alphai, double* beta, double* vl,
- const integer_t ldvl, double* vr, const integer_t ldvr,
- double* work, const integer_t lwork, integer_t& info ) {
- LAPACK_DGGEV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai,
- beta, vl, &ldvl, vr, &ldvr, work, &lwork, &info );
- }
- inline void ggev( const char jobvl, const char jobvr, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* b,
- const integer_t ldb, traits::complex_f* alpha,
- traits::complex_f* beta, traits::complex_f* vl,
- const integer_t ldvl, traits::complex_f* vr, const integer_t ldvr,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t& info ) {
- LAPACK_CGGEV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
- traits::complex_ptr(beta), traits::complex_ptr(vl), &ldvl,
- traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work),
- &lwork, rwork, &info );
- }
- inline void ggev( const char jobvl, const char jobvr, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* b,
- const integer_t ldb, traits::complex_d* alpha,
- traits::complex_d* beta, traits::complex_d* vl,
- const integer_t ldvl, traits::complex_d* vr, const integer_t ldvr,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t& info ) {
- LAPACK_ZGGEV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
- traits::complex_ptr(beta), traits::complex_ptr(vl), &ldvl,
- traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work),
- &lwork, rwork, &info );
- }
+
+inline void ggev( const char jobvl, const char jobvr, const integer_t n,
+ float* a, const integer_t lda, float* b, const integer_t ldb,
+ float* alphar, float* alphai, float* beta, float* vl,
+ const integer_t ldvl, float* vr, const integer_t ldvr, float* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_SGGEV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai, beta,
+ vl, &ldvl, vr, &ldvr, work, &lwork, &info );
+}
+
+inline void ggev( const char jobvl, const char jobvr, const integer_t n,
+ double* a, const integer_t lda, double* b, const integer_t ldb,
+ double* alphar, double* alphai, double* beta, double* vl,
+ const integer_t ldvl, double* vr, const integer_t ldvr, double* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_DGGEV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai, beta,
+ vl, &ldvl, vr, &ldvr, work, &lwork, &info );
+}
+
+inline void ggev( const char jobvl, const char jobvr, const integer_t n,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* alpha,
+ traits::complex_f* beta, traits::complex_f* vl, const integer_t ldvl,
+ traits::complex_f* vr, const integer_t ldvr, traits::complex_f* work,
+ const integer_t lwork, float* rwork, integer_t& info ) {
+ LAPACK_CGGEV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
+ traits::complex_ptr(beta), traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work), &lwork,
+ rwork, &info );
 }
 
+inline void ggev( const char jobvl, const char jobvr, const integer_t n,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* alpha,
+ traits::complex_d* beta, traits::complex_d* vl, const integer_t ldvl,
+ traits::complex_d* vr, const integer_t ldvr, traits::complex_d* work,
+ const integer_t lwork, double* rwork, integer_t& info ) {
+ LAPACK_ZGGEV( &jobvl, &jobvr, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(alpha),
+ traits::complex_ptr(beta), traits::complex_ptr(vl), &ldvl,
+ traits::complex_ptr(vr), &ldvr, traits::complex_ptr(work), &lwork,
+ rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggev_impl{};
@@ -340,6 +343,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,71 +37,71 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggevx( const char balanc, const char jobvl, const char jobvr,
- const char sense, const integer_t n, float* a,
- const integer_t lda, float* b, const integer_t ldb, float* alphar,
- float* alphai, float* beta, float* vl, const integer_t ldvl,
- float* vr, const integer_t ldvr, integer_t& ilo, integer_t& ihi,
- float* lscale, float* rscale, float& abnrm, float& bbnrm,
- float* rconde, float* rcondv, float* work, const integer_t lwork,
- integer_t* iwork, logical_t* bwork, integer_t& info ) {
- LAPACK_SGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb,
- alphar, alphai, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi,
- lscale, rscale, &abnrm, &bbnrm, rconde, rcondv, work, &lwork,
- iwork, bwork, &info );
- }
- inline void ggevx( const char balanc, const char jobvl, const char jobvr,
- const char sense, const integer_t n, double* a,
- const integer_t lda, double* b, const integer_t ldb,
- double* alphar, double* alphai, double* beta, double* vl,
- const integer_t ldvl, double* vr, const integer_t ldvr,
- integer_t& ilo, integer_t& ihi, double* lscale, double* rscale,
- double& abnrm, double& bbnrm, double* rconde, double* rcondv,
- double* work, const integer_t lwork, integer_t* iwork,
- logical_t* bwork, integer_t& info ) {
- LAPACK_DGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb,
- alphar, alphai, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi,
- lscale, rscale, &abnrm, &bbnrm, rconde, rcondv, work, &lwork,
- iwork, bwork, &info );
- }
- inline void ggevx( const char balanc, const char jobvl, const char jobvr,
- const char sense, const integer_t n, traits::complex_f* a,
- const integer_t lda, traits::complex_f* b, const integer_t ldb,
- traits::complex_f* alpha, traits::complex_f* beta,
- traits::complex_f* vl, const integer_t ldvl,
- traits::complex_f* vr, const integer_t ldvr, integer_t& ilo,
- integer_t& ihi, float* lscale, float* rscale, float& abnrm,
- float& bbnrm, float* rconde, float* rcondv,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t* iwork, logical_t* bwork, integer_t& info ) {
- LAPACK_CGGEVX( &balanc, &jobvl, &jobvr, &sense, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, &ilo, &ihi, lscale, rscale, &abnrm, &bbnrm, rconde,
- rcondv, traits::complex_ptr(work), &lwork, rwork, iwork,
- bwork, &info );
- }
- inline void ggevx( const char balanc, const char jobvl, const char jobvr,
- const char sense, const integer_t n, traits::complex_d* a,
- const integer_t lda, traits::complex_d* b, const integer_t ldb,
- traits::complex_d* alpha, traits::complex_d* beta,
- traits::complex_d* vl, const integer_t ldvl,
- traits::complex_d* vr, const integer_t ldvr, integer_t& ilo,
- integer_t& ihi, double* lscale, double* rscale, double& abnrm,
- double& bbnrm, double* rconde, double* rcondv,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t* iwork, logical_t* bwork, integer_t& info ) {
- LAPACK_ZGGEVX( &balanc, &jobvl, &jobvr, &sense, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(alpha), traits::complex_ptr(beta),
- traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
- &ldvr, &ilo, &ihi, lscale, rscale, &abnrm, &bbnrm, rconde,
- rcondv, traits::complex_ptr(work), &lwork, rwork, iwork,
- bwork, &info );
- }
+
+inline void ggevx( const char balanc, const char jobvl, const char jobvr,
+ const char sense, const integer_t n, float* a, const integer_t lda,
+ float* b, const integer_t ldb, float* alphar, float* alphai,
+ float* beta, float* vl, const integer_t ldvl, float* vr,
+ const integer_t ldvr, integer_t& ilo, integer_t& ihi, float* lscale,
+ float* rscale, float& abnrm, float& bbnrm, float* rconde,
+ float* rcondv, float* work, const integer_t lwork, integer_t* iwork,
+ logical_t* bwork, integer_t& info ) {
+ LAPACK_SGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb,
+ alphar, alphai, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi, lscale,
+ rscale, &abnrm, &bbnrm, rconde, rcondv, work, &lwork, iwork,
+ bwork, &info );
 }
 
+inline void ggevx( const char balanc, const char jobvl, const char jobvr,
+ const char sense, const integer_t n, double* a, const integer_t lda,
+ double* b, const integer_t ldb, double* alphar, double* alphai,
+ double* beta, double* vl, const integer_t ldvl, double* vr,
+ const integer_t ldvr, integer_t& ilo, integer_t& ihi, double* lscale,
+ double* rscale, double& abnrm, double& bbnrm, double* rconde,
+ double* rcondv, double* work, const integer_t lwork, integer_t* iwork,
+ logical_t* bwork, integer_t& info ) {
+ LAPACK_DGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb,
+ alphar, alphai, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi, lscale,
+ rscale, &abnrm, &bbnrm, rconde, rcondv, work, &lwork, iwork,
+ bwork, &info );
+}
+
+inline void ggevx( const char balanc, const char jobvl, const char jobvr,
+ const char sense, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* b, const integer_t ldb,
+ traits::complex_f* alpha, traits::complex_f* beta,
+ traits::complex_f* vl, const integer_t ldvl, traits::complex_f* vr,
+ const integer_t ldvr, integer_t& ilo, integer_t& ihi, float* lscale,
+ float* rscale, float& abnrm, float& bbnrm, float* rconde,
+ float* rcondv, traits::complex_f* work, const integer_t lwork,
+ float* rwork, integer_t* iwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_CGGEVX( &balanc, &jobvl, &jobvr, &sense, &n,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(alpha), traits::complex_ptr(beta),
+ traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr,
+ &ilo, &ihi, lscale, rscale, &abnrm, &bbnrm, rconde, rcondv,
+ traits::complex_ptr(work), &lwork, rwork, iwork, bwork, &info );
+}
+
+inline void ggevx( const char balanc, const char jobvl, const char jobvr,
+ const char sense, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* b, const integer_t ldb,
+ traits::complex_d* alpha, traits::complex_d* beta,
+ traits::complex_d* vl, const integer_t ldvl, traits::complex_d* vr,
+ const integer_t ldvr, integer_t& ilo, integer_t& ihi, double* lscale,
+ double* rscale, double& abnrm, double& bbnrm, double* rconde,
+ double* rcondv, traits::complex_d* work, const integer_t lwork,
+ double* rwork, integer_t* iwork, logical_t* bwork, integer_t& info ) {
+ LAPACK_ZGGEVX( &balanc, &jobvl, &jobvr, &sense, &n,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(alpha), traits::complex_ptr(beta),
+ traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr,
+ &ilo, &ihi, lscale, rscale, &abnrm, &bbnrm, rconde, rcondv,
+ traits::complex_ptr(work), &lwork, rwork, iwork, bwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggevx_impl{};
@@ -554,6 +554,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,42 +37,47 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggglm( const integer_t n, const integer_t m,
- const integer_t p, float* a, const integer_t lda, float* b,
- const integer_t ldb, float* d, float* x, float* y, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGGGLM( &n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork,
- &info );
- }
- inline void ggglm( const integer_t n, const integer_t m,
- const integer_t p, double* a, const integer_t lda, double* b,
- const integer_t ldb, double* d, double* x, double* y,
- double* work, const integer_t lwork, integer_t& info ) {
- LAPACK_DGGGLM( &n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork,
- &info );
- }
- inline void ggglm( const integer_t n, const integer_t m,
- const integer_t p, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, traits::complex_f* d,
- traits::complex_f* x, traits::complex_f* y,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGGGLM( &n, &m, &p, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(d),
- traits::complex_ptr(x), traits::complex_ptr(y),
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void ggglm( const integer_t n, const integer_t m,
- const integer_t p, traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb, traits::complex_d* d,
- traits::complex_d* x, traits::complex_d* y,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGGGLM( &n, &m, &p, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(d),
- traits::complex_ptr(x), traits::complex_ptr(y),
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void ggglm( const integer_t n, const integer_t m, const integer_t p,
+ float* a, const integer_t lda, float* b, const integer_t ldb,
+ float* d, float* x, float* y, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGGGLM( &n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork,
+ &info );
 }
 
+inline void ggglm( const integer_t n, const integer_t m, const integer_t p,
+ double* a, const integer_t lda, double* b, const integer_t ldb,
+ double* d, double* x, double* y, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DGGGLM( &n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork,
+ &info );
+}
+
+inline void ggglm( const integer_t n, const integer_t m, const integer_t p,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* d, traits::complex_f* x,
+ traits::complex_f* y, traits::complex_f* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_CGGGLM( &n, &m, &p, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(d),
+ traits::complex_ptr(x), traits::complex_ptr(y),
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+inline void ggglm( const integer_t n, const integer_t m, const integer_t p,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* d, traits::complex_d* x,
+ traits::complex_d* y, traits::complex_d* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_ZGGGLM( &n, &m, &p, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(d),
+ traits::complex_ptr(x), traits::complex_ptr(y),
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggglm_impl{};
@@ -267,6 +272,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -37,42 +37,47 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gglse( const integer_t m, const integer_t n,
- const integer_t p, float* a, const integer_t lda, float* b,
- const integer_t ldb, float* c, float* d, float* x, float* work,
- const integer_t lwork, integer_t& info ) {
- LAPACK_SGGLSE( &m, &n, &p, a, &lda, b, &ldb, c, d, x, work, &lwork,
- &info );
- }
- inline void gglse( const integer_t m, const integer_t n,
- const integer_t p, double* a, const integer_t lda, double* b,
- const integer_t ldb, double* c, double* d, double* x,
- double* work, const integer_t lwork, integer_t& info ) {
- LAPACK_DGGLSE( &m, &n, &p, a, &lda, b, &ldb, c, d, x, work, &lwork,
- &info );
- }
- inline void gglse( const integer_t m, const integer_t n,
- const integer_t p, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, traits::complex_f* c,
- traits::complex_f* d, traits::complex_f* x,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CGGLSE( &m, &n, &p, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(c),
- traits::complex_ptr(d), traits::complex_ptr(x),
- traits::complex_ptr(work), &lwork, &info );
- }
- inline void gglse( const integer_t m, const integer_t n,
- const integer_t p, traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb, traits::complex_d* c,
- traits::complex_d* d, traits::complex_d* x,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZGGLSE( &m, &n, &p, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(c),
- traits::complex_ptr(d), traits::complex_ptr(x),
- traits::complex_ptr(work), &lwork, &info );
- }
+
+inline void gglse( const integer_t m, const integer_t n, const integer_t p,
+ float* a, const integer_t lda, float* b, const integer_t ldb,
+ float* c, float* d, float* x, float* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_SGGLSE( &m, &n, &p, a, &lda, b, &ldb, c, d, x, work, &lwork,
+ &info );
 }
 
+inline void gglse( const integer_t m, const integer_t n, const integer_t p,
+ double* a, const integer_t lda, double* b, const integer_t ldb,
+ double* c, double* d, double* x, double* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_DGGLSE( &m, &n, &p, a, &lda, b, &ldb, c, d, x, work, &lwork,
+ &info );
+}
+
+inline void gglse( const integer_t m, const integer_t n, const integer_t p,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* c, traits::complex_f* d,
+ traits::complex_f* x, traits::complex_f* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_CGGLSE( &m, &n, &p, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(c),
+ traits::complex_ptr(d), traits::complex_ptr(x),
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+inline void gglse( const integer_t m, const integer_t n, const integer_t p,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* c, traits::complex_d* d,
+ traits::complex_d* x, traits::complex_d* work, const integer_t lwork,
+ integer_t& info ) {
+ LAPACK_ZGGLSE( &m, &n, &p, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(c),
+ traits::complex_ptr(d), traits::complex_ptr(x),
+ traits::complex_ptr(work), &lwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gglse_impl{};
@@ -263,6 +268,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,60 +36,60 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ggsvd( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t n, const integer_t p,
- integer_t& k, integer_t& l, float* a, const integer_t lda,
- float* b, const integer_t ldb, float* alpha, float* beta,
- float* u, const integer_t ldu, float* v, const integer_t ldv,
- float* q, const integer_t ldq, float* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_SGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l, a, &lda, b,
- &ldb, alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, iwork,
- &info );
- }
- inline void ggsvd( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t n, const integer_t p,
- integer_t& k, integer_t& l, double* a, const integer_t lda,
- double* b, const integer_t ldb, double* alpha, double* beta,
- double* u, const integer_t ldu, double* v, const integer_t ldv,
- double* q, const integer_t ldq, double* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_DGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l, a, &lda, b,
- &ldb, alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, iwork,
- &info );
- }
- inline void ggsvd( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t n, const integer_t p,
- integer_t& k, integer_t& l, traits::complex_f* a,
- const integer_t lda, traits::complex_f* b, const integer_t ldb,
- float* alpha, float* beta, traits::complex_f* u,
- const integer_t ldu, traits::complex_f* v, const integer_t ldv,
- traits::complex_f* q, const integer_t ldq,
- traits::complex_f* work, float* rwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_CGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- alpha, beta, traits::complex_ptr(u), &ldu,
- traits::complex_ptr(v), &ldv, traits::complex_ptr(q), &ldq,
- traits::complex_ptr(work), rwork, iwork, &info );
- }
- inline void ggsvd( const char jobu, const char jobv, const char jobq,
- const integer_t m, const integer_t n, const integer_t p,
- integer_t& k, integer_t& l, traits::complex_d* a,
- const integer_t lda, traits::complex_d* b, const integer_t ldb,
- double* alpha, double* beta, traits::complex_d* u,
- const integer_t ldu, traits::complex_d* v, const integer_t ldv,
- traits::complex_d* q, const integer_t ldq,
- traits::complex_d* work, double* rwork, integer_t* iwork,
- integer_t& info ) {
- LAPACK_ZGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- alpha, beta, traits::complex_ptr(u), &ldu,
- traits::complex_ptr(v), &ldv, traits::complex_ptr(q), &ldq,
- traits::complex_ptr(work), rwork, iwork, &info );
- }
+
+inline void ggsvd( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t n, const integer_t p, integer_t& k,
+ integer_t& l, float* a, const integer_t lda, float* b,
+ const integer_t ldb, float* alpha, float* beta, float* u,
+ const integer_t ldu, float* v, const integer_t ldv, float* q,
+ const integer_t ldq, float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l, a, &lda, b, &ldb,
+ alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, iwork, &info );
 }
 
+inline void ggsvd( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t n, const integer_t p, integer_t& k,
+ integer_t& l, double* a, const integer_t lda, double* b,
+ const integer_t ldb, double* alpha, double* beta, double* u,
+ const integer_t ldu, double* v, const integer_t ldv, double* q,
+ const integer_t ldq, double* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l, a, &lda, b, &ldb,
+ alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, iwork, &info );
+}
+
+inline void ggsvd( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t n, const integer_t p, integer_t& k,
+ integer_t& l, traits::complex_f* a, const integer_t lda,
+ traits::complex_f* b, const integer_t ldb, float* alpha, float* beta,
+ traits::complex_f* u, const integer_t ldu, traits::complex_f* v,
+ const integer_t ldv, traits::complex_f* q, const integer_t ldq,
+ traits::complex_f* work, float* rwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_CGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, alpha,
+ beta, traits::complex_ptr(u), &ldu, traits::complex_ptr(v), &ldv,
+ traits::complex_ptr(q), &ldq, traits::complex_ptr(work), rwork,
+ iwork, &info );
+}
+
+inline void ggsvd( const char jobu, const char jobv, const char jobq,
+ const integer_t m, const integer_t n, const integer_t p, integer_t& k,
+ integer_t& l, traits::complex_d* a, const integer_t lda,
+ traits::complex_d* b, const integer_t ldb, double* alpha,
+ double* beta, traits::complex_d* u, const integer_t ldu,
+ traits::complex_d* v, const integer_t ldv, traits::complex_d* q,
+ const integer_t ldq, traits::complex_d* work, double* rwork,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_ZGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l,
+ traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb, alpha,
+ beta, traits::complex_ptr(u), &ldu, traits::complex_ptr(v), &ldv,
+ traits::complex_ptr(q), &ldq, traits::complex_ptr(work), rwork,
+ iwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ggsvd_impl{};
@@ -335,6 +335,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,34 +31,34 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gtsv( const integer_t n, const integer_t nrhs, float* dl,
- float* d, float* du, float* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_SGTSV( &n, &nrhs, dl, d, du, b, &ldb, &info );
- }
- inline void gtsv( const integer_t n, const integer_t nrhs, double* dl,
- double* d, double* du, double* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_DGTSV( &n, &nrhs, dl, d, du, b, &ldb, &info );
- }
- inline void gtsv( const integer_t n, const integer_t nrhs,
- traits::complex_f* dl, traits::complex_f* d,
- traits::complex_f* du, traits::complex_f* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_CGTSV( &n, &nrhs, traits::complex_ptr(dl),
- traits::complex_ptr(d), traits::complex_ptr(du),
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void gtsv( const integer_t n, const integer_t nrhs,
- traits::complex_d* dl, traits::complex_d* d,
- traits::complex_d* du, traits::complex_d* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_ZGTSV( &n, &nrhs, traits::complex_ptr(dl),
- traits::complex_ptr(d), traits::complex_ptr(du),
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void gtsv( const integer_t n, const integer_t nrhs, float* dl,
+ float* d, float* du, float* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_SGTSV( &n, &nrhs, dl, d, du, b, &ldb, &info );
+}
+
+inline void gtsv( const integer_t n, const integer_t nrhs, double* dl,
+ double* d, double* du, double* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_DGTSV( &n, &nrhs, dl, d, du, b, &ldb, &info );
+}
+
+inline void gtsv( const integer_t n, const integer_t nrhs,
+ traits::complex_f* dl, traits::complex_f* d, traits::complex_f* du,
+ traits::complex_f* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_CGTSV( &n, &nrhs, traits::complex_ptr(dl), traits::complex_ptr(d),
+ traits::complex_ptr(du), traits::complex_ptr(b), &ldb, &info );
+}
+
+inline void gtsv( const integer_t n, const integer_t nrhs,
+ traits::complex_d* dl, traits::complex_d* d, traits::complex_d* du,
+ traits::complex_d* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_ZGTSV( &n, &nrhs, traits::complex_ptr(dl), traits::complex_ptr(d),
+ traits::complex_ptr(du), traits::complex_ptr(b), &ldb, &info );
 }
 
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct gtsv_impl {
@@ -114,6 +114,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,61 +36,61 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void gtsvx( const char fact, const char trans, const integer_t n,
- const integer_t nrhs, const float* dl, const float* d,
- const float* du, float* dlf, float* df, float* duf, float* du2,
- integer_t* ipiv, const float* b, const integer_t ldb, float* x,
- const integer_t ldx, float& rcond, float* ferr, float* berr,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SGTSVX( &fact, &trans, &n, &nrhs, dl, d, du, dlf, df, duf, du2,
- ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork,
- &info );
- }
- inline void gtsvx( const char fact, const char trans, const integer_t n,
- const integer_t nrhs, const double* dl, const double* d,
- const double* du, double* dlf, double* df, double* duf,
- double* du2, integer_t* ipiv, const double* b,
- const integer_t ldb, double* x, const integer_t ldx,
- double& rcond, double* ferr, double* berr, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DGTSVX( &fact, &trans, &n, &nrhs, dl, d, du, dlf, df, duf, du2,
- ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork,
- &info );
- }
- inline void gtsvx( const char fact, const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_f* dl,
- const traits::complex_f* d, const traits::complex_f* du,
- traits::complex_f* dlf, traits::complex_f* df,
- traits::complex_f* duf, traits::complex_f* du2, integer_t* ipiv,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float& rcond,
- float* ferr, float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CGTSVX( &fact, &trans, &n, &nrhs, traits::complex_ptr(dl),
- traits::complex_ptr(d), traits::complex_ptr(du),
- traits::complex_ptr(dlf), traits::complex_ptr(df),
- traits::complex_ptr(duf), traits::complex_ptr(du2), ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
- inline void gtsvx( const char fact, const char trans, const integer_t n,
- const integer_t nrhs, const traits::complex_d* dl,
- const traits::complex_d* d, const traits::complex_d* du,
- traits::complex_d* dlf, traits::complex_d* df,
- traits::complex_d* duf, traits::complex_d* du2, integer_t* ipiv,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double& rcond,
- double* ferr, double* berr, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZGTSVX( &fact, &trans, &n, &nrhs, traits::complex_ptr(dl),
- traits::complex_ptr(d), traits::complex_ptr(du),
- traits::complex_ptr(dlf), traits::complex_ptr(df),
- traits::complex_ptr(duf), traits::complex_ptr(du2), ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void gtsvx( const char fact, const char trans, const integer_t n,
+ const integer_t nrhs, const float* dl, const float* d,
+ const float* du, float* dlf, float* df, float* duf, float* du2,
+ integer_t* ipiv, const float* b, const integer_t ldb, float* x,
+ const integer_t ldx, float& rcond, float* ferr, float* berr,
+ float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SGTSVX( &fact, &trans, &n, &nrhs, dl, d, du, dlf, df, duf, du2,
+ ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info );
+}
+
+inline void gtsvx( const char fact, const char trans, const integer_t n,
+ const integer_t nrhs, const double* dl, const double* d,
+ const double* du, double* dlf, double* df, double* duf, double* du2,
+ integer_t* ipiv, const double* b, const integer_t ldb, double* x,
+ const integer_t ldx, double& rcond, double* ferr, double* berr,
+ double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DGTSVX( &fact, &trans, &n, &nrhs, dl, d, du, dlf, df, duf, du2,
+ ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info );
+}
+
+inline void gtsvx( const char fact, const char trans, const integer_t n,
+ const integer_t nrhs, const traits::complex_f* dl,
+ const traits::complex_f* d, const traits::complex_f* du,
+ traits::complex_f* dlf, traits::complex_f* df, traits::complex_f* duf,
+ traits::complex_f* du2, integer_t* ipiv, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float& rcond, float* ferr, float* berr, traits::complex_f* work,
+ float* rwork, integer_t& info ) {
+ LAPACK_CGTSVX( &fact, &trans, &n, &nrhs, traits::complex_ptr(dl),
+ traits::complex_ptr(d), traits::complex_ptr(du),
+ traits::complex_ptr(dlf), traits::complex_ptr(df),
+ traits::complex_ptr(duf), traits::complex_ptr(du2), ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
 }
 
+inline void gtsvx( const char fact, const char trans, const integer_t n,
+ const integer_t nrhs, const traits::complex_d* dl,
+ const traits::complex_d* d, const traits::complex_d* du,
+ traits::complex_d* dlf, traits::complex_d* df, traits::complex_d* duf,
+ traits::complex_d* du2, integer_t* ipiv, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double& rcond, double* ferr, double* berr, traits::complex_d* work,
+ double* rwork, integer_t& info ) {
+ LAPACK_ZGTSVX( &fact, &trans, &n, &nrhs, traits::complex_ptr(dl),
+ traits::complex_ptr(d), traits::complex_ptr(du),
+ traits::complex_ptr(dlf), traits::complex_ptr(df),
+ traits::complex_ptr(duf), traits::complex_ptr(du2), ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct gtsvx_impl{};
@@ -369,6 +369,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,24 +33,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hbev( const char jobz, const char uplo, const integer_t n,
- const integer_t kd, traits::complex_f* ab, const integer_t ldab,
- float* w, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CHBEV( &jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
- w, traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- rwork, &info );
- }
- inline void hbev( const char jobz, const char uplo, const integer_t n,
- const integer_t kd, traits::complex_d* ab, const integer_t ldab,
- double* w, traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZHBEV( &jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
- w, traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- rwork, &info );
- }
+
+inline void hbev( const char jobz, const char uplo, const integer_t n,
+ const integer_t kd, traits::complex_f* ab, const integer_t ldab,
+ float* w, traits::complex_f* z, const integer_t ldz,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CHBEV( &jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), rwork,
+ &info );
 }
 
+inline void hbev( const char jobz, const char uplo, const integer_t n,
+ const integer_t kd, traits::complex_d* ab, const integer_t ldab,
+ double* w, traits::complex_d* z, const integer_t ldz,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZHBEV( &jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), rwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hbev_impl {
@@ -137,6 +140,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,28 +34,31 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hbevd( const char jobz, const char uplo, const integer_t n,
- const integer_t kd, traits::complex_f* ab, const integer_t ldab,
- float* w, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_CHBEVD( &jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
- w, traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- &lwork, rwork, &lrwork, iwork, &liwork, &info );
- }
- inline void hbevd( const char jobz, const char uplo, const integer_t n,
- const integer_t kd, traits::complex_d* ab, const integer_t ldab,
- double* w, traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_ZHBEVD( &jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
- w, traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- &lwork, rwork, &lrwork, iwork, &liwork, &info );
- }
+
+inline void hbevd( const char jobz, const char uplo, const integer_t n,
+ const integer_t kd, traits::complex_f* ab, const integer_t ldab,
+ float* w, traits::complex_f* z, const integer_t ldz,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_CHBEVD( &jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), &lwork,
+ rwork, &lrwork, iwork, &liwork, &info );
 }
 
+inline void hbevd( const char jobz, const char uplo, const integer_t n,
+ const integer_t kd, traits::complex_d* ab, const integer_t ldab,
+ double* w, traits::complex_d* z, const integer_t ldz,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_ZHBEVD( &jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab, w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), &lwork,
+ rwork, &lrwork, iwork, &liwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hbevd_impl {
@@ -187,6 +190,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,34 +33,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hbevx( const char jobz, const char range, const char uplo,
- const integer_t n, const integer_t kd, traits::complex_f* ab,
- const integer_t ldab, traits::complex_f* q, const integer_t ldq,
- const float vl, const float vu, const integer_t il,
- const integer_t iu, const float abstol, integer_t& m, float* w,
- traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, float* rwork, integer_t* iwork,
- integer_t* ifail, integer_t& info ) {
- LAPACK_CHBEVX( &jobz, &range, &uplo, &n, &kd, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(q), &ldq, &vl, &vu, &il, &iu,
- &abstol, &m, w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, iwork, ifail, &info );
- }
- inline void hbevx( const char jobz, const char range, const char uplo,
- const integer_t n, const integer_t kd, traits::complex_d* ab,
- const integer_t ldab, traits::complex_d* q, const integer_t ldq,
- const double vl, const double vu, const integer_t il,
- const integer_t iu, const double abstol, integer_t& m, double* w,
- traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, double* rwork, integer_t* iwork,
- integer_t* ifail, integer_t& info ) {
- LAPACK_ZHBEVX( &jobz, &range, &uplo, &n, &kd, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(q), &ldq, &vl, &vu, &il, &iu,
- &abstol, &m, w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, iwork, ifail, &info );
- }
+
+inline void hbevx( const char jobz, const char range, const char uplo,
+ const integer_t n, const integer_t kd, traits::complex_f* ab,
+ const integer_t ldab, traits::complex_f* q, const integer_t ldq,
+ const float vl, const float vu, const integer_t il,
+ const integer_t iu, const float abstol, integer_t& m, float* w,
+ traits::complex_f* z, const integer_t ldz, traits::complex_f* work,
+ float* rwork, integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_CHBEVX( &jobz, &range, &uplo, &n, &kd, traits::complex_ptr(ab),
+ &ldab, traits::complex_ptr(q), &ldq, &vl, &vu, &il, &iu, &abstol,
+ &m, w, traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
+ rwork, iwork, ifail, &info );
 }
 
+inline void hbevx( const char jobz, const char range, const char uplo,
+ const integer_t n, const integer_t kd, traits::complex_d* ab,
+ const integer_t ldab, traits::complex_d* q, const integer_t ldq,
+ const double vl, const double vu, const integer_t il,
+ const integer_t iu, const double abstol, integer_t& m, double* w,
+ traits::complex_d* z, const integer_t ldz, traits::complex_d* work,
+ double* rwork, integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_ZHBEVX( &jobz, &range, &uplo, &n, &kd, traits::complex_ptr(ab),
+ &ldab, traits::complex_ptr(q), &ldq, &vl, &vu, &il, &iu, &abstol,
+ &m, w, traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
+ rwork, iwork, ifail, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hbevx_impl {
@@ -191,6 +192,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,28 +33,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hbgv( const char jobz, const char uplo, const integer_t n,
- const integer_t ka, const integer_t kb, traits::complex_f* ab,
- const integer_t ldab, traits::complex_f* bb, const integer_t ldbb,
- float* w, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CHBGV( &jobz, &uplo, &n, &ka, &kb, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(bb), &ldbb, w,
- traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- rwork, &info );
- }
- inline void hbgv( const char jobz, const char uplo, const integer_t n,
- const integer_t ka, const integer_t kb, traits::complex_d* ab,
- const integer_t ldab, traits::complex_d* bb, const integer_t ldbb,
- double* w, traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZHBGV( &jobz, &uplo, &n, &ka, &kb, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(bb), &ldbb, w,
- traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- rwork, &info );
- }
+
+inline void hbgv( const char jobz, const char uplo, const integer_t n,
+ const integer_t ka, const integer_t kb, traits::complex_f* ab,
+ const integer_t ldab, traits::complex_f* bb, const integer_t ldbb,
+ float* w, traits::complex_f* z, const integer_t ldz,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CHBGV( &jobz, &uplo, &n, &ka, &kb, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(bb), &ldbb, w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void hbgv( const char jobz, const char uplo, const integer_t n,
+ const integer_t ka, const integer_t kb, traits::complex_d* ab,
+ const integer_t ldab, traits::complex_d* bb, const integer_t ldbb,
+ double* w, traits::complex_d* z, const integer_t ldz,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZHBGV( &jobz, &uplo, &n, &ka, &kb, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(bb), &ldbb, w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hbgv_impl {
@@ -155,6 +156,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,32 +34,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hbgvd( const char jobz, const char uplo, const integer_t n,
- const integer_t ka, const integer_t kb, traits::complex_f* ab,
- const integer_t ldab, traits::complex_f* bb, const integer_t ldbb,
- float* w, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_CHBGVD( &jobz, &uplo, &n, &ka, &kb, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(bb), &ldbb, w,
- traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- &lwork, rwork, &lrwork, iwork, &liwork, &info );
- }
- inline void hbgvd( const char jobz, const char uplo, const integer_t n,
- const integer_t ka, const integer_t kb, traits::complex_d* ab,
- const integer_t ldab, traits::complex_d* bb, const integer_t ldbb,
- double* w, traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_ZHBGVD( &jobz, &uplo, &n, &ka, &kb, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(bb), &ldbb, w,
- traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- &lwork, rwork, &lrwork, iwork, &liwork, &info );
- }
+
+inline void hbgvd( const char jobz, const char uplo, const integer_t n,
+ const integer_t ka, const integer_t kb, traits::complex_f* ab,
+ const integer_t ldab, traits::complex_f* bb, const integer_t ldbb,
+ float* w, traits::complex_f* z, const integer_t ldz,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_CHBGVD( &jobz, &uplo, &n, &ka, &kb, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(bb), &ldbb, w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork,
+ &info );
 }
 
+inline void hbgvd( const char jobz, const char uplo, const integer_t n,
+ const integer_t ka, const integer_t kb, traits::complex_d* ab,
+ const integer_t ldab, traits::complex_d* bb, const integer_t ldbb,
+ double* w, traits::complex_d* z, const integer_t ldz,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_ZHBGVD( &jobz, &uplo, &n, &ka, &kb, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(bb), &ldbb, w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hbgvd_impl {
@@ -206,6 +209,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,38 +33,39 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hbgvx( const char jobz, const char range, const char uplo,
- const integer_t n, const integer_t ka, const integer_t kb,
- traits::complex_f* ab, const integer_t ldab,
- traits::complex_f* bb, const integer_t ldbb, traits::complex_f* q,
- const integer_t ldq, const float vl, const float vu,
- const integer_t il, const integer_t iu, const float abstol,
- integer_t& m, float* w, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, float* rwork, integer_t* iwork,
- integer_t* ifail, integer_t& info ) {
- LAPACK_CHBGVX( &jobz, &range, &uplo, &n, &ka, &kb,
- traits::complex_ptr(ab), &ldab, traits::complex_ptr(bb),
- &ldbb, traits::complex_ptr(q), &ldq, &vl, &vu, &il, &iu,
- &abstol, &m, w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, iwork, ifail, &info );
- }
- inline void hbgvx( const char jobz, const char range, const char uplo,
- const integer_t n, const integer_t ka, const integer_t kb,
- traits::complex_d* ab, const integer_t ldab,
- traits::complex_d* bb, const integer_t ldbb, traits::complex_d* q,
- const integer_t ldq, const double vl, const double vu,
- const integer_t il, const integer_t iu, const double abstol,
- integer_t& m, double* w, traits::complex_d* z,
- const integer_t ldz, traits::complex_d* work, double* rwork,
- integer_t* iwork, integer_t* ifail, integer_t& info ) {
- LAPACK_ZHBGVX( &jobz, &range, &uplo, &n, &ka, &kb,
- traits::complex_ptr(ab), &ldab, traits::complex_ptr(bb),
- &ldbb, traits::complex_ptr(q), &ldq, &vl, &vu, &il, &iu,
- &abstol, &m, w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, iwork, ifail, &info );
- }
+
+inline void hbgvx( const char jobz, const char range, const char uplo,
+ const integer_t n, const integer_t ka, const integer_t kb,
+ traits::complex_f* ab, const integer_t ldab, traits::complex_f* bb,
+ const integer_t ldbb, traits::complex_f* q, const integer_t ldq,
+ const float vl, const float vu, const integer_t il,
+ const integer_t iu, const float abstol, integer_t& m, float* w,
+ traits::complex_f* z, const integer_t ldz, traits::complex_f* work,
+ float* rwork, integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_CHBGVX( &jobz, &range, &uplo, &n, &ka, &kb,
+ traits::complex_ptr(ab), &ldab, traits::complex_ptr(bb), &ldbb,
+ traits::complex_ptr(q), &ldq, &vl, &vu, &il, &iu, &abstol, &m, w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), rwork,
+ iwork, ifail, &info );
 }
 
+inline void hbgvx( const char jobz, const char range, const char uplo,
+ const integer_t n, const integer_t ka, const integer_t kb,
+ traits::complex_d* ab, const integer_t ldab, traits::complex_d* bb,
+ const integer_t ldbb, traits::complex_d* q, const integer_t ldq,
+ const double vl, const double vu, const integer_t il,
+ const integer_t iu, const double abstol, integer_t& m, double* w,
+ traits::complex_d* z, const integer_t ldz, traits::complex_d* work,
+ double* rwork, integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_ZHBGVX( &jobz, &range, &uplo, &n, &ka, &kb,
+ traits::complex_ptr(ab), &ldab, traits::complex_ptr(bb), &ldbb,
+ traits::complex_ptr(q), &ldq, &vl, &vu, &il, &iu, &abstol, &m, w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), rwork,
+ iwork, ifail, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hbgvx_impl {
@@ -206,6 +207,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,22 +34,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void heev( const char jobz, const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, float* w,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t& info ) {
- LAPACK_CHEEV( &jobz, &uplo, &n, traits::complex_ptr(a), &lda, w,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
- inline void heev( const char jobz, const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, double* w,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t& info ) {
- LAPACK_ZHEEV( &jobz, &uplo, &n, traits::complex_ptr(a), &lda, w,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
+
+inline void heev( const char jobz, const char uplo, const integer_t n,
+ traits::complex_f* a, const integer_t lda, float* w,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ integer_t& info ) {
+ LAPACK_CHEEV( &jobz, &uplo, &n, traits::complex_ptr(a), &lda, w,
+ traits::complex_ptr(work), &lwork, rwork, &info );
 }
 
+inline void heev( const char jobz, const char uplo, const integer_t n,
+ traits::complex_d* a, const integer_t lda, double* w,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZHEEV( &jobz, &uplo, &n, traits::complex_ptr(a), &lda, w,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct heev_impl {
@@ -137,6 +140,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void heevd( const char jobz, const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, float* w,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_CHEEVD( &jobz, &uplo, &n, traits::complex_ptr(a), &lda, w,
- traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork,
- &liwork, &info );
- }
- inline void heevd( const char jobz, const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, double* w,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_ZHEEVD( &jobz, &uplo, &n, traits::complex_ptr(a), &lda, w,
- traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork,
- &liwork, &info );
- }
+
+inline void heevd( const char jobz, const char uplo, const integer_t n,
+ traits::complex_f* a, const integer_t lda, float* w,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_CHEEVD( &jobz, &uplo, &n, traits::complex_ptr(a), &lda, w,
+ traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork,
+ &info );
 }
 
+inline void heevd( const char jobz, const char uplo, const integer_t n,
+ traits::complex_d* a, const integer_t lda, double* w,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_ZHEEVD( &jobz, &uplo, &n, traits::complex_ptr(a), &lda, w,
+ traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct heevd_impl {
@@ -175,6 +178,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,34 +34,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void heevr( const char jobz, const char range, const char uplo,
- const integer_t n, traits::complex_f* a, const integer_t lda,
- const float vl, const float vu, const integer_t il,
- const integer_t iu, const float abstol, integer_t& m, float* w,
- traits::complex_f* z, const integer_t ldz, integer_t* isuppz,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_CHEEVR( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
- &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z),
- &ldz, isuppz, traits::complex_ptr(work), &lwork, rwork,
- &lrwork, iwork, &liwork, &info );
- }
- inline void heevr( const char jobz, const char range, const char uplo,
- const integer_t n, traits::complex_d* a, const integer_t lda,
- const double vl, const double vu, const integer_t il,
- const integer_t iu, const double abstol, integer_t& m, double* w,
- traits::complex_d* z, const integer_t ldz, integer_t* isuppz,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- const integer_t lrwork, integer_t* iwork, const integer_t liwork,
- integer_t& info ) {
- LAPACK_ZHEEVR( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
- &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z),
- &ldz, isuppz, traits::complex_ptr(work), &lwork, rwork,
- &lrwork, iwork, &liwork, &info );
- }
+
+inline void heevr( const char jobz, const char range, const char uplo,
+ const integer_t n, traits::complex_f* a, const integer_t lda,
+ const float vl, const float vu, const integer_t il,
+ const integer_t iu, const float abstol, integer_t& m, float* w,
+ traits::complex_f* z, const integer_t ldz, integer_t* isuppz,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_CHEEVR( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
+ &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
+ isuppz, traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork,
+ &liwork, &info );
 }
 
+inline void heevr( const char jobz, const char range, const char uplo,
+ const integer_t n, traits::complex_d* a, const integer_t lda,
+ const double vl, const double vu, const integer_t il,
+ const integer_t iu, const double abstol, integer_t& m, double* w,
+ traits::complex_d* z, const integer_t ldz, integer_t* isuppz,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_ZHEEVR( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
+ &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
+ isuppz, traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork,
+ &liwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct heevr_impl {
@@ -207,6 +210,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,32 +34,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void heevx( const char jobz, const char range, const char uplo,
- const integer_t n, traits::complex_f* a, const integer_t lda,
- const float vl, const float vu, const integer_t il,
- const integer_t iu, const float abstol, integer_t& m, float* w,
- traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t* iwork, integer_t* ifail, integer_t& info ) {
- LAPACK_CHEEVX( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
- &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z),
- &ldz, traits::complex_ptr(work), &lwork, rwork, iwork, ifail,
- &info );
- }
- inline void heevx( const char jobz, const char range, const char uplo,
- const integer_t n, traits::complex_d* a, const integer_t lda,
- const double vl, const double vu, const integer_t il,
- const integer_t iu, const double abstol, integer_t& m, double* w,
- traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t* iwork, integer_t* ifail, integer_t& info ) {
- LAPACK_ZHEEVX( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
- &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z),
- &ldz, traits::complex_ptr(work), &lwork, rwork, iwork, ifail,
- &info );
- }
+
+inline void heevx( const char jobz, const char range, const char uplo,
+ const integer_t n, traits::complex_f* a, const integer_t lda,
+ const float vl, const float vu, const integer_t il,
+ const integer_t iu, const float abstol, integer_t& m, float* w,
+ traits::complex_f* z, const integer_t ldz, traits::complex_f* work,
+ const integer_t lwork, float* rwork, integer_t* iwork,
+ integer_t* ifail, integer_t& info ) {
+ LAPACK_CHEEVX( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
+ &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, iwork, ifail, &info );
 }
 
+inline void heevx( const char jobz, const char range, const char uplo,
+ const integer_t n, traits::complex_d* a, const integer_t lda,
+ const double vl, const double vu, const integer_t il,
+ const integer_t iu, const double abstol, integer_t& m, double* w,
+ traits::complex_d* z, const integer_t ldz, traits::complex_d* work,
+ const integer_t lwork, double* rwork, integer_t* iwork,
+ integer_t* ifail, integer_t& info ) {
+ LAPACK_ZHEEVX( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
+ &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, iwork, ifail, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct heevx_impl {
@@ -203,6 +204,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hegv( const integer_t itype, const char jobz, const char uplo,
- const integer_t n, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, float* w,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t& info ) {
- LAPACK_CHEGV( &itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work),
- &lwork, rwork, &info );
- }
- inline void hegv( const integer_t itype, const char jobz, const char uplo,
- const integer_t n, traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb, double* w,
- traits::complex_d* work, const integer_t lwork, double* rwork,
- integer_t& info ) {
- LAPACK_ZHEGV( &itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work),
- &lwork, rwork, &info );
- }
+
+inline void hegv( const integer_t itype, const char jobz, const char uplo,
+ const integer_t n, traits::complex_f* a, const integer_t lda,
+ traits::complex_f* b, const integer_t ldb, float* w,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ integer_t& info ) {
+ LAPACK_CHEGV( &itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work),
+ &lwork, rwork, &info );
 }
 
+inline void hegv( const integer_t itype, const char jobz, const char uplo,
+ const integer_t n, traits::complex_d* a, const integer_t lda,
+ traits::complex_d* b, const integer_t ldb, double* w,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZHEGV( &itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work),
+ &lwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hegv_impl {
@@ -152,6 +155,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,28 +34,31 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hegvd( const integer_t itype, const char jobz,
- const char uplo, const integer_t n, traits::complex_f* a,
- const integer_t lda, traits::complex_f* b, const integer_t ldb,
- float* w, traits::complex_f* work, const integer_t lwork,
- float* rwork, const integer_t lrwork, integer_t* iwork,
- const integer_t liwork, integer_t& info ) {
- LAPACK_CHEGVD( &itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work),
- &lwork, rwork, &lrwork, iwork, &liwork, &info );
- }
- inline void hegvd( const integer_t itype, const char jobz,
- const char uplo, const integer_t n, traits::complex_d* a,
- const integer_t lda, traits::complex_d* b, const integer_t ldb,
- double* w, traits::complex_d* work, const integer_t lwork,
- double* rwork, const integer_t lrwork, integer_t* iwork,
- const integer_t liwork, integer_t& info ) {
- LAPACK_ZHEGVD( &itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work),
- &lwork, rwork, &lrwork, iwork, &liwork, &info );
- }
+
+inline void hegvd( const integer_t itype, const char jobz, const char uplo,
+ const integer_t n, traits::complex_f* a, const integer_t lda,
+ traits::complex_f* b, const integer_t ldb, float* w,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_CHEGVD( &itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work),
+ &lwork, rwork, &lrwork, iwork, &liwork, &info );
 }
 
+inline void hegvd( const integer_t itype, const char jobz, const char uplo,
+ const integer_t n, traits::complex_d* a, const integer_t lda,
+ traits::complex_d* b, const integer_t ldb, double* w,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_ZHEGVD( &itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work),
+ &lwork, rwork, &lrwork, iwork, &liwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hegvd_impl {
@@ -188,6 +191,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,37 +34,37 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hegvx( const integer_t itype, const char jobz,
- const char range, const char uplo, const integer_t n,
- traits::complex_f* a, const integer_t lda, traits::complex_f* b,
- const integer_t ldb, const float vl, const float vu,
- const integer_t il, const integer_t iu, const float abstol,
- integer_t& m, float* w, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, const integer_t lwork, float* rwork,
- integer_t* iwork, integer_t* ifail, integer_t& info ) {
- LAPACK_CHEGVX( &itype, &jobz, &range, &uplo, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z),
- &ldz, traits::complex_ptr(work), &lwork, rwork, iwork, ifail,
- &info );
- }
- inline void hegvx( const integer_t itype, const char jobz,
- const char range, const char uplo, const integer_t n,
- traits::complex_d* a, const integer_t lda, traits::complex_d* b,
- const integer_t ldb, const double vl, const double vu,
- const integer_t il, const integer_t iu, const double abstol,
- integer_t& m, double* w, traits::complex_d* z,
- const integer_t ldz, traits::complex_d* work,
- const integer_t lwork, double* rwork, integer_t* iwork,
- integer_t* ifail, integer_t& info ) {
- LAPACK_ZHEGVX( &itype, &jobz, &range, &uplo, &n,
- traits::complex_ptr(a), &lda, traits::complex_ptr(b), &ldb,
- &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z),
- &ldz, traits::complex_ptr(work), &lwork, rwork, iwork, ifail,
- &info );
- }
+
+inline void hegvx( const integer_t itype, const char jobz, const char range,
+ const char uplo, const integer_t n, traits::complex_f* a,
+ const integer_t lda, traits::complex_f* b, const integer_t ldb,
+ const float vl, const float vu, const integer_t il,
+ const integer_t iu, const float abstol, integer_t& m, float* w,
+ traits::complex_f* z, const integer_t ldz, traits::complex_f* work,
+ const integer_t lwork, float* rwork, integer_t* iwork,
+ integer_t* ifail, integer_t& info ) {
+ LAPACK_CHEGVX( &itype, &jobz, &range, &uplo, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, &vl, &vu, &il, &iu, &abstol,
+ &m, w, traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
+ &lwork, rwork, iwork, ifail, &info );
 }
 
+inline void hegvx( const integer_t itype, const char jobz, const char range,
+ const char uplo, const integer_t n, traits::complex_d* a,
+ const integer_t lda, traits::complex_d* b, const integer_t ldb,
+ const double vl, const double vu, const integer_t il,
+ const integer_t iu, const double abstol, integer_t& m, double* w,
+ traits::complex_d* z, const integer_t ldz, traits::complex_d* work,
+ const integer_t lwork, double* rwork, integer_t* iwork,
+ integer_t* ifail, integer_t& info ) {
+ LAPACK_ZHEGVX( &itype, &jobz, &range, &uplo, &n, traits::complex_ptr(a),
+ &lda, traits::complex_ptr(b), &ldb, &vl, &vu, &il, &iu, &abstol,
+ &m, w, traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
+ &lwork, rwork, iwork, ifail, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hegvx_impl {
@@ -210,6 +210,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,24 +34,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hesv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_f* a, const integer_t lda,
- integer_t* ipiv, traits::complex_f* b, const integer_t ldb,
- traits::complex_f* work, const integer_t lwork, integer_t& info ) {
- LAPACK_CHESV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(work),
- &lwork, &info );
- }
- inline void hesv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_d* a, const integer_t lda,
- integer_t* ipiv, traits::complex_d* b, const integer_t ldb,
- traits::complex_d* work, const integer_t lwork, integer_t& info ) {
- LAPACK_ZHESV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(work),
- &lwork, &info );
- }
+
+inline void hesv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_f* a, const integer_t lda, integer_t* ipiv,
+ traits::complex_f* b, const integer_t ldb, traits::complex_f* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_CHESV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(work), &lwork,
+ &info );
 }
 
+inline void hesv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_d* a, const integer_t lda, integer_t* ipiv,
+ traits::complex_d* b, const integer_t ldb, traits::complex_d* work,
+ const integer_t lwork, integer_t& info ) {
+ LAPACK_ZHESV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda, ipiv,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(work), &lwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hesv_impl {
@@ -153,6 +156,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,32 +34,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hesvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* a,
- const integer_t lda, traits::complex_f* af, const integer_t ldaf,
- integer_t* ipiv, const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float& rcond,
- float* ferr, float* berr, traits::complex_f* work,
- const integer_t lwork, float* rwork, integer_t& info ) {
- LAPACK_CHESVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
- inline void hesvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* a,
- const integer_t lda, traits::complex_d* af, const integer_t ldaf,
- integer_t* ipiv, const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double& rcond,
- double* ferr, double* berr, traits::complex_d* work,
- const integer_t lwork, double* rwork, integer_t& info ) {
- LAPACK_ZHESVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), &lwork, rwork, &info );
- }
+
+inline void hesvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, const traits::complex_f* a, const integer_t lda,
+ traits::complex_f* af, const integer_t ldaf, integer_t* ipiv,
+ const traits::complex_f* b, const integer_t ldb, traits::complex_f* x,
+ const integer_t ldx, float& rcond, float* ferr, float* berr,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ integer_t& info ) {
+ LAPACK_CHESVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), &lwork, rwork, &info );
 }
 
+inline void hesvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, const traits::complex_d* a, const integer_t lda,
+ traits::complex_d* af, const integer_t ldaf, integer_t* ipiv,
+ const traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
+ const integer_t ldx, double& rcond, double* ferr, double* berr,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZHESVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, ipiv, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), &lwork, rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hesvx_impl {
@@ -203,6 +206,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,24 +33,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hpev( const char jobz, const char uplo, const integer_t n,
- traits::complex_f* ap, float* w, traits::complex_f* z,
- const integer_t ldz, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CHPEV( &jobz, &uplo, &n, traits::complex_ptr(ap), w,
- traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- rwork, &info );
- }
- inline void hpev( const char jobz, const char uplo, const integer_t n,
- traits::complex_d* ap, double* w, traits::complex_d* z,
- const integer_t ldz, traits::complex_d* work, double* rwork,
- integer_t& info ) {
- LAPACK_ZHPEV( &jobz, &uplo, &n, traits::complex_ptr(ap), w,
- traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- rwork, &info );
- }
+
+inline void hpev( const char jobz, const char uplo, const integer_t n,
+ traits::complex_f* ap, float* w, traits::complex_f* z,
+ const integer_t ldz, traits::complex_f* work, float* rwork,
+ integer_t& info ) {
+ LAPACK_CHPEV( &jobz, &uplo, &n, traits::complex_ptr(ap), w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), rwork,
+ &info );
 }
 
+inline void hpev( const char jobz, const char uplo, const integer_t n,
+ traits::complex_d* ap, double* w, traits::complex_d* z,
+ const integer_t ldz, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZHPEV( &jobz, &uplo, &n, traits::complex_ptr(ap), w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), rwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hpev_impl {
@@ -130,6 +133,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,26 +34,29 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hpevd( const char jobz, const char uplo, const integer_t n,
- traits::complex_f* ap, float* w, traits::complex_f* z,
- const integer_t ldz, traits::complex_f* work,
- const integer_t lwork, float* rwork, const integer_t lrwork,
- integer_t* iwork, const integer_t liwork, integer_t& info ) {
- LAPACK_CHPEVD( &jobz, &uplo, &n, traits::complex_ptr(ap), w,
- traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- &lwork, rwork, &lrwork, iwork, &liwork, &info );
- }
- inline void hpevd( const char jobz, const char uplo, const integer_t n,
- traits::complex_d* ap, double* w, traits::complex_d* z,
- const integer_t ldz, traits::complex_d* work,
- const integer_t lwork, double* rwork, const integer_t lrwork,
- integer_t* iwork, const integer_t liwork, integer_t& info ) {
- LAPACK_ZHPEVD( &jobz, &uplo, &n, traits::complex_ptr(ap), w,
- traits::complex_ptr(z), &ldz, traits::complex_ptr(work),
- &lwork, rwork, &lrwork, iwork, &liwork, &info );
- }
+
+inline void hpevd( const char jobz, const char uplo, const integer_t n,
+ traits::complex_f* ap, float* w, traits::complex_f* z,
+ const integer_t ldz, traits::complex_f* work, const integer_t lwork,
+ float* rwork, const integer_t lrwork, integer_t* iwork,
+ const integer_t liwork, integer_t& info ) {
+ LAPACK_CHPEVD( &jobz, &uplo, &n, traits::complex_ptr(ap), w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), &lwork,
+ rwork, &lrwork, iwork, &liwork, &info );
 }
 
+inline void hpevd( const char jobz, const char uplo, const integer_t n,
+ traits::complex_d* ap, double* w, traits::complex_d* z,
+ const integer_t ldz, traits::complex_d* work, const integer_t lwork,
+ double* rwork, const integer_t lrwork, integer_t* iwork,
+ const integer_t liwork, integer_t& info ) {
+ LAPACK_ZHPEVD( &jobz, &uplo, &n, traits::complex_ptr(ap), w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), &lwork,
+ rwork, &lrwork, iwork, &liwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hpevd_impl {
@@ -179,6 +182,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,29 +33,31 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hpevx( const char jobz, const char range, const char uplo,
- const integer_t n, traits::complex_f* ap, const float vl,
- const float vu, const integer_t il, const integer_t iu,
- const float abstol, integer_t& m, float* w, traits::complex_f* z,
- const integer_t ldz, traits::complex_f* work, float* rwork,
- integer_t* iwork, integer_t* ifail, integer_t& info ) {
- LAPACK_CHPEVX( &jobz, &range, &uplo, &n, traits::complex_ptr(ap), &vl,
- &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, iwork, ifail, &info );
- }
- inline void hpevx( const char jobz, const char range, const char uplo,
- const integer_t n, traits::complex_d* ap, const double vl,
- const double vu, const integer_t il, const integer_t iu,
- const double abstol, integer_t& m, double* w,
- traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, double* rwork, integer_t* iwork,
- integer_t* ifail, integer_t& info ) {
- LAPACK_ZHPEVX( &jobz, &range, &uplo, &n, traits::complex_ptr(ap), &vl,
- &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, iwork, ifail, &info );
- }
+
+inline void hpevx( const char jobz, const char range, const char uplo,
+ const integer_t n, traits::complex_f* ap, const float vl,
+ const float vu, const integer_t il, const integer_t iu,
+ const float abstol, integer_t& m, float* w, traits::complex_f* z,
+ const integer_t ldz, traits::complex_f* work, float* rwork,
+ integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_CHPEVX( &jobz, &range, &uplo, &n, traits::complex_ptr(ap), &vl,
+ &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), rwork, iwork, ifail, &info );
 }
 
+inline void hpevx( const char jobz, const char range, const char uplo,
+ const integer_t n, traits::complex_d* ap, const double vl,
+ const double vu, const integer_t il, const integer_t iu,
+ const double abstol, integer_t& m, double* w, traits::complex_d* z,
+ const integer_t ldz, traits::complex_d* work, double* rwork,
+ integer_t* iwork, integer_t* ifail, integer_t& info ) {
+ LAPACK_ZHPEVX( &jobz, &range, &uplo, &n, traits::complex_ptr(ap), &vl,
+ &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), rwork, iwork, ifail, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hpevx_impl {
@@ -177,6 +179,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,24 +33,27 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hpgv( const integer_t itype, const char jobz, const char uplo,
- const integer_t n, traits::complex_f* ap, traits::complex_f* bp,
- float* w, traits::complex_f* z, const integer_t ldz,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CHPGV( &itype, &jobz, &uplo, &n, traits::complex_ptr(ap),
- traits::complex_ptr(bp), w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void hpgv( const integer_t itype, const char jobz, const char uplo,
- const integer_t n, traits::complex_d* ap, traits::complex_d* bp,
- double* w, traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZHPGV( &itype, &jobz, &uplo, &n, traits::complex_ptr(ap),
- traits::complex_ptr(bp), w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void hpgv( const integer_t itype, const char jobz, const char uplo,
+ const integer_t n, traits::complex_f* ap, traits::complex_f* bp,
+ float* w, traits::complex_f* z, const integer_t ldz,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CHPGV( &itype, &jobz, &uplo, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(bp), w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void hpgv( const integer_t itype, const char jobz, const char uplo,
+ const integer_t n, traits::complex_d* ap, traits::complex_d* bp,
+ double* w, traits::complex_d* z, const integer_t ldz,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZHPGV( &itype, &jobz, &uplo, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(bp), w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hpgv_impl {
@@ -144,6 +147,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,30 +34,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hpgvd( const integer_t itype, const char jobz,
- const char uplo, const integer_t n, traits::complex_f* ap,
- traits::complex_f* bp, float* w, traits::complex_f* z,
- const integer_t ldz, traits::complex_f* work,
- const integer_t lwork, float* rwork, const integer_t lrwork,
- integer_t* iwork, const integer_t liwork, integer_t& info ) {
- LAPACK_CHPGVD( &itype, &jobz, &uplo, &n, traits::complex_ptr(ap),
- traits::complex_ptr(bp), w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork,
- &liwork, &info );
- }
- inline void hpgvd( const integer_t itype, const char jobz,
- const char uplo, const integer_t n, traits::complex_d* ap,
- traits::complex_d* bp, double* w, traits::complex_d* z,
- const integer_t ldz, traits::complex_d* work,
- const integer_t lwork, double* rwork, const integer_t lrwork,
- integer_t* iwork, const integer_t liwork, integer_t& info ) {
- LAPACK_ZHPGVD( &itype, &jobz, &uplo, &n, traits::complex_ptr(ap),
- traits::complex_ptr(bp), w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork,
- &liwork, &info );
- }
+
+inline void hpgvd( const integer_t itype, const char jobz, const char uplo,
+ const integer_t n, traits::complex_f* ap, traits::complex_f* bp,
+ float* w, traits::complex_f* z, const integer_t ldz,
+ traits::complex_f* work, const integer_t lwork, float* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_CHPGVD( &itype, &jobz, &uplo, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(bp), w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork,
+ &info );
 }
 
+inline void hpgvd( const integer_t itype, const char jobz, const char uplo,
+ const integer_t n, traits::complex_d* ap, traits::complex_d* bp,
+ double* w, traits::complex_d* z, const integer_t ldz,
+ traits::complex_d* work, const integer_t lwork, double* rwork,
+ const integer_t lrwork, integer_t* iwork, const integer_t liwork,
+ integer_t& info ) {
+ LAPACK_ZHPGVD( &itype, &jobz, &uplo, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(bp), w, traits::complex_ptr(z), &ldz,
+ traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hpgvd_impl {
@@ -196,6 +199,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,33 +33,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hpgvx( const integer_t itype, const char jobz,
- const char range, const char uplo, const integer_t n,
- traits::complex_f* ap, traits::complex_f* bp, const float vl,
- const float vu, const integer_t il, const integer_t iu,
- const float abstol, integer_t& m, float* w, traits::complex_f* z,
- const integer_t ldz, traits::complex_f* work, float* rwork,
- integer_t* iwork, integer_t* ifail, integer_t& info ) {
- LAPACK_CHPGVX( &itype, &jobz, &range, &uplo, &n,
- traits::complex_ptr(ap), traits::complex_ptr(bp), &vl, &vu,
- &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, iwork, ifail, &info );
- }
- inline void hpgvx( const integer_t itype, const char jobz,
- const char range, const char uplo, const integer_t n,
- traits::complex_d* ap, traits::complex_d* bp, const double vl,
- const double vu, const integer_t il, const integer_t iu,
- const double abstol, integer_t& m, double* w,
- traits::complex_d* z, const integer_t ldz,
- traits::complex_d* work, double* rwork, integer_t* iwork,
- integer_t* ifail, integer_t& info ) {
- LAPACK_ZHPGVX( &itype, &jobz, &range, &uplo, &n,
- traits::complex_ptr(ap), traits::complex_ptr(bp), &vl, &vu,
- &il, &iu, &abstol, &m, w, traits::complex_ptr(z), &ldz,
- traits::complex_ptr(work), rwork, iwork, ifail, &info );
- }
+
+inline void hpgvx( const integer_t itype, const char jobz, const char range,
+ const char uplo, const integer_t n, traits::complex_f* ap,
+ traits::complex_f* bp, const float vl, const float vu,
+ const integer_t il, const integer_t iu, const float abstol,
+ integer_t& m, float* w, traits::complex_f* z, const integer_t ldz,
+ traits::complex_f* work, float* rwork, integer_t* iwork,
+ integer_t* ifail, integer_t& info ) {
+ LAPACK_CHPGVX( &itype, &jobz, &range, &uplo, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(bp), &vl, &vu, &il, &iu, &abstol, &m, w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), rwork,
+ iwork, ifail, &info );
 }
 
+inline void hpgvx( const integer_t itype, const char jobz, const char range,
+ const char uplo, const integer_t n, traits::complex_d* ap,
+ traits::complex_d* bp, const double vl, const double vu,
+ const integer_t il, const integer_t iu, const double abstol,
+ integer_t& m, double* w, traits::complex_d* z, const integer_t ldz,
+ traits::complex_d* work, double* rwork, integer_t* iwork,
+ integer_t* ifail, integer_t& info ) {
+ LAPACK_ZHPGVX( &itype, &jobz, &range, &uplo, &n, traits::complex_ptr(ap),
+ traits::complex_ptr(bp), &vl, &vu, &il, &iu, &abstol, &m, w,
+ traits::complex_ptr(z), &ldz, traits::complex_ptr(work), rwork,
+ iwork, ifail, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hpgvx_impl {
@@ -188,6 +190,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,20 +31,23 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hpsv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_f* ap, integer_t* ipiv,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CHPSV( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void hpsv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_d* ap, integer_t* ipiv,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZHPSV( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void hpsv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_f* ap, integer_t* ipiv, traits::complex_f* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_CHPSV( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void hpsv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_d* ap, integer_t* ipiv, traits::complex_d* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_ZHPSV( &uplo, &n, &nrhs, traits::complex_ptr(ap), ipiv,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hpsv_impl {
@@ -100,6 +103,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,32 +33,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void hpsvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_f* ap,
- traits::complex_f* afp, integer_t* ipiv,
- const traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float& rcond,
- float* ferr, float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CHPSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void hpsvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, const traits::complex_d* ap,
- traits::complex_d* afp, integer_t* ipiv,
- const traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double& rcond,
- double* ferr, double* berr, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZHPSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void hpsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, const traits::complex_f* ap,
+ traits::complex_f* afp, integer_t* ipiv, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float& rcond, float* ferr, float* berr, traits::complex_f* work,
+ float* rwork, integer_t& info ) {
+ LAPACK_CHPSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void hpsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, const traits::complex_d* ap,
+ traits::complex_d* afp, integer_t* ipiv, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double& rcond, double* ferr, double* berr, traits::complex_d* work,
+ double* rwork, integer_t& info ) {
+ LAPACK_ZHPSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), ipiv, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct hpsvx_impl {
@@ -181,6 +182,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,16 +31,19 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void lacgv( const integer_t n, traits::complex_f* x,
- const integer_t incx ) {
- LAPACK_CLACGV( &n, traits::complex_ptr(x), &incx );
- }
- inline void lacgv( const integer_t n, traits::complex_d* x,
- const integer_t incx ) {
- LAPACK_ZLACGV( &n, traits::complex_ptr(x), &incx );
- }
+
+inline void lacgv( const integer_t n, traits::complex_f* x,
+ const integer_t incx ) {
+ LAPACK_CLACGV( &n, traits::complex_ptr(x), &incx );
 }
 
+inline void lacgv( const integer_t n, traits::complex_d* x,
+ const integer_t incx ) {
+ LAPACK_ZLACGV( &n, traits::complex_ptr(x), &incx );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct lacgv_impl {
@@ -67,6 +70,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,41 +36,45 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void lalsd( const char uplo, const integer_t smlsiz,
- const integer_t n, const integer_t nrhs, float* d, float* e,
- float* b, const integer_t ldb, const float rcond, integer_t& rank,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond,
- &rank, work, iwork, &info );
- }
- inline void lalsd( const char uplo, const integer_t smlsiz,
- const integer_t n, const integer_t nrhs, double* d, double* e,
- double* b, const integer_t ldb, const double rcond,
- integer_t& rank, double* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_DLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond,
- &rank, work, iwork, &info );
- }
- inline void lalsd( const char uplo, const integer_t smlsiz,
- const integer_t n, const integer_t nrhs, float* d, float* e,
- traits::complex_f* b, const integer_t ldb, const float rcond,
- integer_t& rank, traits::complex_f* work, float* rwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_CLALSD( &uplo, &smlsiz, &n, &nrhs, d, e,
- traits::complex_ptr(b), &ldb, &rcond, &rank,
- traits::complex_ptr(work), rwork, iwork, &info );
- }
- inline void lalsd( const char uplo, const integer_t smlsiz,
- const integer_t n, const integer_t nrhs, double* d, double* e,
- traits::complex_d* b, const integer_t ldb, const double rcond,
- integer_t& rank, traits::complex_d* work, double* rwork,
- integer_t* iwork, integer_t& info ) {
- LAPACK_ZLALSD( &uplo, &smlsiz, &n, &nrhs, d, e,
- traits::complex_ptr(b), &ldb, &rcond, &rank,
- traits::complex_ptr(work), rwork, iwork, &info );
- }
+
+inline void lalsd( const char uplo, const integer_t smlsiz, const integer_t n,
+ const integer_t nrhs, float* d, float* e, float* b,
+ const integer_t ldb, const float rcond, integer_t& rank, float* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_SLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank,
+ work, iwork, &info );
 }
 
+inline void lalsd( const char uplo, const integer_t smlsiz, const integer_t n,
+ const integer_t nrhs, double* d, double* e, double* b,
+ const integer_t ldb, const double rcond, integer_t& rank,
+ double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank,
+ work, iwork, &info );
+}
+
+inline void lalsd( const char uplo, const integer_t smlsiz, const integer_t n,
+ const integer_t nrhs, float* d, float* e, traits::complex_f* b,
+ const integer_t ldb, const float rcond, integer_t& rank,
+ traits::complex_f* work, float* rwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_CLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, traits::complex_ptr(b),
+ &ldb, &rcond, &rank, traits::complex_ptr(work), rwork, iwork,
+ &info );
+}
+
+inline void lalsd( const char uplo, const integer_t smlsiz, const integer_t n,
+ const integer_t nrhs, double* d, double* e, traits::complex_d* b,
+ const integer_t ldb, const double rcond, integer_t& rank,
+ traits::complex_d* work, double* rwork, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_ZLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, traits::complex_ptr(b),
+ &ldb, &rcond, &rank, traits::complex_ptr(work), rwork, iwork,
+ &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct lalsd_impl{};
@@ -278,6 +282,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,29 +34,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void largv( const integer_t n, float* x, const integer_t incx,
- float* y, const integer_t incy, float* c, const integer_t incc ) {
- LAPACK_SLARGV( &n, x, &incx, y, &incy, c, &incc );
- }
- inline void largv( const integer_t n, double* x, const integer_t incx,
- double* y, const integer_t incy, double* c,
- const integer_t incc ) {
- LAPACK_DLARGV( &n, x, &incx, y, &incy, c, &incc );
- }
- inline void largv( const integer_t n, traits::complex_f* x,
- const integer_t incx, traits::complex_f* y, const integer_t incy,
- float* c, const integer_t incc ) {
- LAPACK_CLARGV( &n, traits::complex_ptr(x), &incx,
- traits::complex_ptr(y), &incy, c, &incc );
- }
- inline void largv( const integer_t n, traits::complex_d* x,
- const integer_t incx, traits::complex_d* y, const integer_t incy,
- double* c, const integer_t incc ) {
- LAPACK_ZLARGV( &n, traits::complex_ptr(x), &incx,
- traits::complex_ptr(y), &incy, c, &incc );
- }
+
+inline void largv( const integer_t n, float* x, const integer_t incx,
+ float* y, const integer_t incy, float* c, const integer_t incc ) {
+ LAPACK_SLARGV( &n, x, &incx, y, &incy, c, &incc );
 }
 
+inline void largv( const integer_t n, double* x, const integer_t incx,
+ double* y, const integer_t incy, double* c, const integer_t incc ) {
+ LAPACK_DLARGV( &n, x, &incx, y, &incy, c, &incc );
+}
+
+inline void largv( const integer_t n, traits::complex_f* x,
+ const integer_t incx, traits::complex_f* y, const integer_t incy,
+ float* c, const integer_t incc ) {
+ LAPACK_CLARGV( &n, traits::complex_ptr(x), &incx, traits::complex_ptr(y),
+ &incy, c, &incc );
+}
+
+inline void largv( const integer_t n, traits::complex_d* x,
+ const integer_t incx, traits::complex_d* y, const integer_t incy,
+ double* c, const integer_t incc ) {
+ LAPACK_ZLARGV( &n, traits::complex_ptr(x), &incx, traits::complex_ptr(y),
+ &incy, c, &incc );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct largv_impl{};
@@ -124,6 +128,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,30 +31,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pbsv( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, float* ab, const integer_t ldab, float* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_SPBSV( &uplo, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
- }
- inline void pbsv( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, double* ab, const integer_t ldab, double* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_DPBSV( &uplo, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
- }
- inline void pbsv( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, traits::complex_f* ab, const integer_t ldab,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CPBSV( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void pbsv( const char uplo, const integer_t n, const integer_t kd,
- const integer_t nrhs, traits::complex_d* ab, const integer_t ldab,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZPBSV( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void pbsv( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, float* ab, const integer_t ldab, float* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_SPBSV( &uplo, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
+}
+
+inline void pbsv( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, double* ab, const integer_t ldab, double* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_DPBSV( &uplo, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
+}
+
+inline void pbsv( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, traits::complex_f* ab, const integer_t ldab,
+ traits::complex_f* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_CPBSV( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void pbsv( const char uplo, const integer_t n, const integer_t kd,
+ const integer_t nrhs, traits::complex_d* ab, const integer_t ldab,
+ traits::complex_d* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_ZPBSV( &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab), &ldab,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct pbsv_impl {
@@ -104,6 +109,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,52 +36,56 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void pbsvx( const char fact, const char uplo, const integer_t n,
- const integer_t kd, const integer_t nrhs, float* ab,
- const integer_t ldab, float* afb, const integer_t ldafb,
- char& equed, float* s, float* b, const integer_t ldb, float* x,
- const integer_t ldx, float& rcond, float* ferr, float* berr,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SPBSVX( &fact, &uplo, &n, &kd, &nrhs, ab, &ldab, afb, &ldafb,
- &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork,
- &info );
- }
- inline void pbsvx( const char fact, const char uplo, const integer_t n,
- const integer_t kd, const integer_t nrhs, double* ab,
- const integer_t ldab, double* afb, const integer_t ldafb,
- char& equed, double* s, double* b, const integer_t ldb, double* x,
- const integer_t ldx, double& rcond, double* ferr, double* berr,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DPBSVX( &fact, &uplo, &n, &kd, &nrhs, ab, &ldab, afb, &ldafb,
- &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork,
- &info );
- }
- inline void pbsvx( const char fact, const char uplo, const integer_t n,
- const integer_t kd, const integer_t nrhs, traits::complex_f* ab,
- const integer_t ldab, traits::complex_f* afb,
- const integer_t ldafb, char& equed, float* s,
- traits::complex_f* b, const integer_t ldb, traits::complex_f* x,
- const integer_t ldx, float& rcond, float* ferr, float* berr,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CPBSVX( &fact, &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(afb), &ldafb, &equed, s,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
- inline void pbsvx( const char fact, const char uplo, const integer_t n,
- const integer_t kd, const integer_t nrhs, traits::complex_d* ab,
- const integer_t ldab, traits::complex_d* afb,
- const integer_t ldafb, char& equed, double* s,
- traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
- const integer_t ldx, double& rcond, double* ferr, double* berr,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZPBSVX( &fact, &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab),
- &ldab, traits::complex_ptr(afb), &ldafb, &equed, s,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void pbsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t kd, const integer_t nrhs, float* ab,
+ const integer_t ldab, float* afb, const integer_t ldafb, char& equed,
+ float* s, float* b, const integer_t ldb, float* x,
+ const integer_t ldx, float& rcond, float* ferr, float* berr,
+ float* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_SPBSVX( &fact, &uplo, &n, &kd, &nrhs, ab, &ldab, afb, &ldafb,
+ &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork,
+ &info );
+}
+
+inline void pbsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t kd, const integer_t nrhs, double* ab,
+ const integer_t ldab, double* afb, const integer_t ldafb, char& equed,
+ double* s, double* b, const integer_t ldb, double* x,
+ const integer_t ldx, double& rcond, double* ferr, double* berr,
+ double* work, integer_t* iwork, integer_t& info ) {
+ LAPACK_DPBSVX( &fact, &uplo, &n, &kd, &nrhs, ab, &ldab, afb, &ldafb,
+ &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork,
+ &info );
+}
+
+inline void pbsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t kd, const integer_t nrhs, traits::complex_f* ab,
+ const integer_t ldab, traits::complex_f* afb, const integer_t ldafb,
+ char& equed, float* s, traits::complex_f* b, const integer_t ldb,
+ traits::complex_f* x, const integer_t ldx, float& rcond, float* ferr,
+ float* berr, traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CPBSVX( &fact, &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab),
+ &ldab, traits::complex_ptr(afb), &ldafb, &equed, s,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
 }
 
+inline void pbsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t kd, const integer_t nrhs, traits::complex_d* ab,
+ const integer_t ldab, traits::complex_d* afb, const integer_t ldafb,
+ char& equed, double* s, traits::complex_d* b, const integer_t ldb,
+ traits::complex_d* x, const integer_t ldx, double& rcond,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZPBSVX( &fact, &uplo, &n, &kd, &nrhs, traits::complex_ptr(ab),
+ &ldab, traits::complex_ptr(afb), &ldafb, &equed, s,
+ traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
+ &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct pbsvx_impl{};
@@ -320,6 +324,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,30 +31,35 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void posv( const char uplo, const integer_t n,
- const integer_t nrhs, float* a, const integer_t lda, float* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_SPOSV( &uplo, &n, &nrhs, a, &lda, b, &ldb, &info );
- }
- inline void posv( const char uplo, const integer_t n,
- const integer_t nrhs, double* a, const integer_t lda, double* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_DPOSV( &uplo, &n, &nrhs, a, &lda, b, &ldb, &info );
- }
- inline void posv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_f* a, const integer_t lda,
- traits::complex_f* b, const integer_t ldb, integer_t& info ) {
- LAPACK_CPOSV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void posv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_d* a, const integer_t lda,
- traits::complex_d* b, const integer_t ldb, integer_t& info ) {
- LAPACK_ZPOSV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void posv( const char uplo, const integer_t n, const integer_t nrhs,
+ float* a, const integer_t lda, float* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_SPOSV( &uplo, &n, &nrhs, a, &lda, b, &ldb, &info );
+}
+
+inline void posv( const char uplo, const integer_t n, const integer_t nrhs,
+ double* a, const integer_t lda, double* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_DPOSV( &uplo, &n, &nrhs, a, &lda, b, &ldb, &info );
+}
+
+inline void posv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_f* a, const integer_t lda, traits::complex_f* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_CPOSV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, &info );
 }
 
+inline void posv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_d* a, const integer_t lda, traits::complex_d* b,
+ const integer_t ldb, integer_t& info ) {
+ LAPACK_ZPOSV( &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct posv_impl {
@@ -103,6 +108,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,50 +36,53 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void posvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, float* a, const integer_t lda, float* af,
- const integer_t ldaf, char& equed, float* s, float* b,
- const integer_t ldb, float* x, const integer_t ldx, float& rcond,
- float* ferr, float* berr, float* work, integer_t* iwork,
- integer_t& info ) {
- LAPACK_SPOSVX( &fact, &uplo, &n, &nrhs, a, &lda, af, &ldaf, &equed, s,
- b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info );
- }
- inline void posvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, double* a, const integer_t lda, double* af,
- const integer_t ldaf, char& equed, double* s, double* b,
- const integer_t ldb, double* x, const integer_t ldx,
- double& rcond, double* ferr, double* berr, double* work,
- integer_t* iwork, integer_t& info ) {
- LAPACK_DPOSVX( &fact, &uplo, &n, &nrhs, a, &lda, af, &ldaf, &equed, s,
- b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info );
- }
- inline void posvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_f* a, const integer_t lda,
- traits::complex_f* af, const integer_t ldaf, char& equed,
- float* s, traits::complex_f* b, const integer_t ldb,
- traits::complex_f* x, const integer_t ldx, float& rcond,
- float* ferr, float* berr, traits::complex_f* work, float* rwork,
- integer_t& info ) {
- LAPACK_CPOSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, &equed, s,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
- inline void posvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_d* a, const integer_t lda,
- traits::complex_d* af, const integer_t ldaf, char& equed,
- double* s, traits::complex_d* b, const integer_t ldb,
- traits::complex_d* x, const integer_t ldx, double& rcond,
- double* ferr, double* berr, traits::complex_d* work,
- double* rwork, integer_t& info ) {
- LAPACK_ZPOSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
- traits::complex_ptr(af), &ldaf, &equed, s,
- traits::complex_ptr(b), &ldb, traits::complex_ptr(x), &ldx,
- &rcond, ferr, berr, traits::complex_ptr(work), rwork, &info );
- }
+
+inline void posvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, float* a, const integer_t lda, float* af,
+ const integer_t ldaf, char& equed, float* s, float* b,
+ const integer_t ldb, float* x, const integer_t ldx, float& rcond,
+ float* ferr, float* berr, float* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_SPOSVX( &fact, &uplo, &n, &nrhs, a, &lda, af, &ldaf, &equed, s, b,
+ &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info );
+}
+
+inline void posvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, double* a, const integer_t lda, double* af,
+ const integer_t ldaf, char& equed, double* s, double* b,
+ const integer_t ldb, double* x, const integer_t ldx, double& rcond,
+ double* ferr, double* berr, double* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_DPOSVX( &fact, &uplo, &n, &nrhs, a, &lda, af, &ldaf, &equed, s, b,
+ &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info );
+}
+
+inline void posvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, traits::complex_f* a, const integer_t lda,
+ traits::complex_f* af, const integer_t ldaf, char& equed, float* s,
+ traits::complex_f* b, const integer_t ldb, traits::complex_f* x,
+ const integer_t ldx, float& rcond, float* ferr, float* berr,
+ traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CPOSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, &equed, s, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void posvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, traits::complex_d* a, const integer_t lda,
+ traits::complex_d* af, const integer_t ldaf, char& equed, double* s,
+ traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
+ const integer_t ldx, double& rcond, double* ferr, double* berr,
+ traits::complex_d* work, double* rwork, integer_t& info ) {
+ LAPACK_ZPOSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(a), &lda,
+ traits::complex_ptr(af), &ldaf, &equed, s, traits::complex_ptr(b),
+ &ldb, traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct posvx_impl{};
@@ -320,6 +323,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -31,30 +31,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ppsv( const char uplo, const integer_t n,
- const integer_t nrhs, float* ap, float* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_SPPSV( &uplo, &n, &nrhs, ap, b, &ldb, &info );
- }
- inline void ppsv( const char uplo, const integer_t n,
- const integer_t nrhs, double* ap, double* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_DPPSV( &uplo, &n, &nrhs, ap, b, &ldb, &info );
- }
- inline void ppsv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_f* ap, traits::complex_f* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_CPPSV( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void ppsv( const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_d* ap, traits::complex_d* b,
- const integer_t ldb, integer_t& info ) {
- LAPACK_ZPPSV( &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void ppsv( const char uplo, const integer_t n, const integer_t nrhs,
+ float* ap, float* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_SPPSV( &uplo, &n, &nrhs, ap, b, &ldb, &info );
 }
 
+inline void ppsv( const char uplo, const integer_t n, const integer_t nrhs,
+ double* ap, double* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_DPPSV( &uplo, &n, &nrhs, ap, b, &ldb, &info );
+}
+
+inline void ppsv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_f* ap, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CPPSV( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+inline void ppsv( const char uplo, const integer_t n, const integer_t nrhs,
+ traits::complex_d* ap, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZPPSV( &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct ppsv_impl {
@@ -100,6 +103,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,46 +36,50 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ppsvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, float* ap, float* afp, char& equed,
- float* s, float* b, const integer_t ldb, float* x,
- const integer_t ldx, float& rcond, float* ferr, float* berr,
- float* work, integer_t* iwork, integer_t& info ) {
- LAPACK_SPPSVX( &fact, &uplo, &n, &nrhs, ap, afp, &equed, s, b, &ldb,
- x, &ldx, &rcond, ferr, berr, work, iwork, &info );
- }
- inline void ppsvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, double* ap, double* afp, char& equed,
- double* s, double* b, const integer_t ldb, double* x,
- const integer_t ldx, double& rcond, double* ferr, double* berr,
- double* work, integer_t* iwork, integer_t& info ) {
- LAPACK_DPPSVX( &fact, &uplo, &n, &nrhs, ap, afp, &equed, s, b, &ldb,
- x, &ldx, &rcond, ferr, berr, work, iwork, &info );
- }
- inline void ppsvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_f* ap,
- traits::complex_f* afp, char& equed, float* s,
- traits::complex_f* b, const integer_t ldb, traits::complex_f* x,
- const integer_t ldx, float& rcond, float* ferr, float* berr,
- traits::complex_f* work, float* rwork, integer_t& info ) {
- LAPACK_CPPSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), &equed, s, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void ppsvx( const char fact, const char uplo, const integer_t n,
- const integer_t nrhs, traits::complex_d* ap,
- traits::complex_d* afp, char& equed, double* s,
- traits::complex_d* b, const integer_t ldb, traits::complex_d* x,
- const integer_t ldx, double& rcond, double* ferr, double* berr,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZPPSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(ap),
- traits::complex_ptr(afp), &equed, s, traits::complex_ptr(b),
- &ldb, traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void ppsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, float* ap, float* afp, char& equed, float* s,
+ float* b, const integer_t ldb, float* x, const integer_t ldx,
+ float& rcond, float* ferr, float* berr, float* work, integer_t* iwork,
+ integer_t& info ) {
+ LAPACK_SPPSVX( &fact, &uplo, &n, &nrhs, ap, afp, &equed, s, b, &ldb, x,
+ &ldx, &rcond, ferr, berr, work, iwork, &info );
+}
+
+inline void ppsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, double* ap, double* afp, char& equed, double* s,
+ double* b, const integer_t ldb, double* x, const integer_t ldx,
+ double& rcond, double* ferr, double* berr, double* work,
+ integer_t* iwork, integer_t& info ) {
+ LAPACK_DPPSVX( &fact, &uplo, &n, &nrhs, ap, afp, &equed, s, b, &ldb, x,
+ &ldx, &rcond, ferr, berr, work, iwork, &info );
+}
+
+inline void ppsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, traits::complex_f* ap, traits::complex_f* afp,
+ char& equed, float* s, traits::complex_f* b, const integer_t ldb,
+ traits::complex_f* x, const integer_t ldx, float& rcond, float* ferr,
+ float* berr, traits::complex_f* work, float* rwork, integer_t& info ) {
+ LAPACK_CPPSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), &equed, s, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void ppsvx( const char fact, const char uplo, const integer_t n,
+ const integer_t nrhs, traits::complex_d* ap, traits::complex_d* afp,
+ char& equed, double* s, traits::complex_d* b, const integer_t ldb,
+ traits::complex_d* x, const integer_t ldx, double& rcond,
+ double* ferr, double* berr, traits::complex_d* work, double* rwork,
+ integer_t& info ) {
+ LAPACK_ZPPSVX( &fact, &uplo, &n, &nrhs, traits::complex_ptr(ap),
+ traits::complex_ptr(afp), &equed, s, traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ppsvx_impl{};
@@ -306,6 +310,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,28 +34,33 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ptsv( const integer_t n, const integer_t nrhs, float* d,
- float* e, float* b, const integer_t ldb, integer_t& info ) {
- LAPACK_SPTSV( &n, &nrhs, d, e, b, &ldb, &info );
- }
- inline void ptsv( const integer_t n, const integer_t nrhs, double* d,
- double* e, double* b, const integer_t ldb, integer_t& info ) {
- LAPACK_DPTSV( &n, &nrhs, d, e, b, &ldb, &info );
- }
- inline void ptsv( const integer_t n, const integer_t nrhs, float* d,
- traits::complex_f* e, traits::complex_f* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_CPTSV( &n, &nrhs, d, traits::complex_ptr(e),
- traits::complex_ptr(b), &ldb, &info );
- }
- inline void ptsv( const integer_t n, const integer_t nrhs, double* d,
- traits::complex_d* e, traits::complex_d* b, const integer_t ldb,
- integer_t& info ) {
- LAPACK_ZPTSV( &n, &nrhs, d, traits::complex_ptr(e),
- traits::complex_ptr(b), &ldb, &info );
- }
+
+inline void ptsv( const integer_t n, const integer_t nrhs, float* d, float* e,
+ float* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_SPTSV( &n, &nrhs, d, e, b, &ldb, &info );
 }
 
+inline void ptsv( const integer_t n, const integer_t nrhs, double* d,
+ double* e, double* b, const integer_t ldb, integer_t& info ) {
+ LAPACK_DPTSV( &n, &nrhs, d, e, b, &ldb, &info );
+}
+
+inline void ptsv( const integer_t n, const integer_t nrhs, float* d,
+ traits::complex_f* e, traits::complex_f* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_CPTSV( &n, &nrhs, d, traits::complex_ptr(e),
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+inline void ptsv( const integer_t n, const integer_t nrhs, double* d,
+ traits::complex_d* e, traits::complex_d* b, const integer_t ldb,
+ integer_t& info ) {
+ LAPACK_ZPTSV( &n, &nrhs, d, traits::complex_ptr(e),
+ traits::complex_ptr(b), &ldb, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ptsv_impl{};
@@ -144,6 +149,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -36,46 +36,50 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void ptsvx( const char fact, const integer_t n,
- const integer_t nrhs, const float* d, const float* e, float* df,
- float* ef, const float* b, const integer_t ldb, float* x,
- const integer_t ldx, float& rcond, float* ferr, float* berr,
- float* work, integer_t& info ) {
- LAPACK_SPTSVX( &fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx,
- &rcond, ferr, berr, work, &info );
- }
- inline void ptsvx( const char fact, const integer_t n,
- const integer_t nrhs, const double* d, const double* e,
- double* df, double* ef, const double* b, const integer_t ldb,
- double* x, const integer_t ldx, double& rcond, double* ferr,
- double* berr, double* work, integer_t& info ) {
- LAPACK_DPTSVX( &fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx,
- &rcond, ferr, berr, work, &info );
- }
- inline void ptsvx( const char fact, const integer_t n,
- const integer_t nrhs, const float* d, const traits::complex_f* e,
- float* df, traits::complex_f* ef, const traits::complex_f* b,
- const integer_t ldb, traits::complex_f* x, const integer_t ldx,
- float& rcond, float* ferr, float* berr, traits::complex_f* work,
- float* rwork, integer_t& info ) {
- LAPACK_CPTSVX( &fact, &n, &nrhs, d, traits::complex_ptr(e), df,
- traits::complex_ptr(ef), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
- inline void ptsvx( const char fact, const integer_t n,
- const integer_t nrhs, const double* d, const traits::complex_d* e,
- double* df, traits::complex_d* ef, const traits::complex_d* b,
- const integer_t ldb, traits::complex_d* x, const integer_t ldx,
- double& rcond, double* ferr, double* berr,
- traits::complex_d* work, double* rwork, integer_t& info ) {
- LAPACK_ZPTSVX( &fact, &n, &nrhs, d, traits::complex_ptr(e), df,
- traits::complex_ptr(ef), traits::complex_ptr(b), &ldb,
- traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
- traits::complex_ptr(work), rwork, &info );
- }
+
+inline void ptsvx( const char fact, const integer_t n, const integer_t nrhs,
+ const float* d, const float* e, float* df, float* ef, const float* b,
+ const integer_t ldb, float* x, const integer_t ldx, float& rcond,
+ float* ferr, float* berr, float* work, integer_t& info ) {
+ LAPACK_SPTSVX( &fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, &rcond,
+ ferr, berr, work, &info );
+}
+
+inline void ptsvx( const char fact, const integer_t n, const integer_t nrhs,
+ const double* d, const double* e, double* df, double* ef,
+ const double* b, const integer_t ldb, double* x, const integer_t ldx,
+ double& rcond, double* ferr, double* berr, double* work,
+ integer_t& info ) {
+ LAPACK_DPTSVX( &fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, &rcond,
+ ferr, berr, work, &info );
+}
+
+inline void ptsvx( const char fact, const integer_t n, const integer_t nrhs,
+ const float* d, const traits::complex_f* e, float* df,
+ traits::complex_f* ef, const traits::complex_f* b,
+ const integer_t ldb, traits::complex_f* x, const integer_t ldx,
+ float& rcond, float* ferr, float* berr, traits::complex_f* work,
+ float* rwork, integer_t& info ) {
+ LAPACK_CPTSVX( &fact, &n, &nrhs, d, traits::complex_ptr(e), df,
+ traits::complex_ptr(ef), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
 }
 
+inline void ptsvx( const char fact, const integer_t n, const integer_t nrhs,
+ const double* d, const traits::complex_d* e, double* df,
+ traits::complex_d* ef, const traits::complex_d* b,
+ const integer_t ldb, traits::complex_d* x, const integer_t ldx,
+ double& rcond, double* ferr, double* berr, traits::complex_d* work,
+ double* rwork, integer_t& info ) {
+ LAPACK_ZPTSVX( &fact, &n, &nrhs, d, traits::complex_ptr(e), df,
+ traits::complex_ptr(ef), traits::complex_ptr(b), &ldb,
+ traits::complex_ptr(x), &ldx, &rcond, ferr, berr,
+ traits::complex_ptr(work), rwork, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType, typename Enable = void >
 struct ptsvx_impl{};
@@ -295,6 +299,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -33,20 +33,21 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sbev( const char jobz, const char uplo, const integer_t n,
- const integer_t kd, float* ab, const integer_t ldab, float* w,
- float* z, const integer_t ldz, float* work, integer_t& info ) {
- LAPACK_SSBEV( &jobz, &uplo, &n, &kd, ab, &ldab, w, z, &ldz, work,
- &info );
- }
- inline void sbev( const char jobz, const char uplo, const integer_t n,
- const integer_t kd, double* ab, const integer_t ldab, double* w,
- double* z, const integer_t ldz, double* work, integer_t& info ) {
- LAPACK_DSBEV( &jobz, &uplo, &n, &kd, ab, &ldab, w, z, &ldz, work,
- &info );
- }
+
+inline void sbev( const char jobz, const char uplo, const integer_t n,
+ const integer_t kd, float* ab, const integer_t ldab, float* w,
+ float* z, const integer_t ldz, float* work, integer_t& info ) {
+ LAPACK_SSBEV( &jobz, &uplo, &n, &kd, ab, &ldab, w, z, &ldz, work, &info );
 }
 
+inline void sbev( const char jobz, const char uplo, const integer_t n,
+ const integer_t kd, double* ab, const integer_t ldab, double* w,
+ double* z, const integer_t ldz, double* work, integer_t& info ) {
+ LAPACK_DSBEV( &jobz, &uplo, &n, &kd, ab, &ldab, w, z, &ldz, work, &info );
+}
+
+} // namespace detail
+
 // value-type based template
 template< typename ValueType >
 struct sbev_impl {
@@ -127,6 +128,9 @@
     return info;
 }
 
-}}}} // namespace boost::numeric::bindings::lapack
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp 2009-09-18 05:40:51 EDT (Fri, 18 Sep 2009)
@@ -34,23 +34,25 @@
 
 // overloaded functions to call lapack
 namespace detail {
- inline void sbevd( const char jobz, const char uplo, const integer_t n,
- const integer_t kd, float* ab, const integer_t ldab, float* w,
- float* z, const integer_t ldz, float* work, const integer_t lwork,
- integer_t* iwork, const integer_t liwork, integer_t& info ) {
- LAPACK_SSBEVD( &jobz, &uplo, &n, &kd, ab, &ldab, w, z, &ldz, work,
- &lwork, iwork, &liwork, &info );
- }
- inline void sbevd( const char jobz, const char uplo, const integer_t n,
- const integer_t kd, double* ab, const integer_t ldab, double* w,
-